Reformat

src/main/java/com/massivecraft/factions/Conf.java

@@ -269,20 +269,7 @@ public class Conf {
     public static int dynmapLayerMinimumZoom = 0;
 
     // Format for popup - substitute values for macros
-    public static String dynmapDescription =
+    public static String dynmapDescription = "<div class=\"infowindow\">\n" + "<span style=\"font-weight: bold; font-size: 150%;\">%name%</span><br>\n" + "<span style=\"font-style: italic; font-size: 110%;\">%description%</span><br>" + "<br>\n" + "<span style=\"font-weight: bold;\">Leader:</span> %players.leader%<br>\n" + "<span style=\"font-weight: bold;\">Admins:</span> %players.admins.count%<br>\n" + "<span style=\"font-weight: bold;\">Moderators:</span> %players.moderators.count%<br>\n" + "<span style=\"font-weight: bold;\">Members:</span> %players.normals.count%<br>\n" + "<span style=\"font-weight: bold;\">TOTAL:</span> %players.count%<br>\n" + "</br>\n" + "<span style=\"font-weight: bold;\">Bank:</span> %money%<br>\n" + "<br>\n" + "</div>";
-        "<div class=\"infowindow\">\n"
-          + "<span style=\"font-weight: bold; font-size: 150%;\">%name%</span><br>\n"
-          + "<span style=\"font-style: italic; font-size: 110%;\">%description%</span><br>"
-          + "<br>\n"
-          + "<span style=\"font-weight: bold;\">Leader:</span> %players.leader%<br>\n"
-          + "<span style=\"font-weight: bold;\">Admins:</span> %players.admins.count%<br>\n"
-          + "<span style=\"font-weight: bold;\">Moderators:</span> %players.moderators.count%<br>\n"
-          + "<span style=\"font-weight: bold;\">Members:</span> %players.normals.count%<br>\n"
-          + "<span style=\"font-weight: bold;\">TOTAL:</span> %players.count%<br>\n"
-          + "</br>\n"
-          + "<span style=\"font-weight: bold;\">Bank:</span> %money%<br>\n"
-          + "<br>\n"
-      + "</div>";
 
     // Enable the %money% macro. Only do this if you know your economy manager is thread-safe.
     public static boolean dynmapDescriptionMoney = false;
@@ -310,21 +297,11 @@ public class Conf {
     public static final transient String DYNMAP_STYLE_HOME_MARKER = "greenflag";
     public static final transient boolean DYNMAP_STYLE_BOOST = false;
 
-    public static DynmapStyle dynmapDefaultStyle = new DynmapStyle()
+    public static DynmapStyle dynmapDefaultStyle = new DynmapStyle().setStrokeColor(DYNMAP_STYLE_LINE_COLOR).setLineOpacity(DYNMAP_STYLE_LINE_OPACITY).setLineWeight(DYNMAP_STYLE_LINE_WEIGHT).setFillColor(DYNMAP_STYLE_FILL_COLOR).setFillOpacity(DYNMAP_STYLE_FILL_OPACITY).setHomeMarker(DYNMAP_STYLE_HOME_MARKER).setBoost(DYNMAP_STYLE_BOOST);
-            .setStrokeColor(DYNMAP_STYLE_LINE_COLOR)
-            .setLineOpacity(DYNMAP_STYLE_LINE_OPACITY)
-            .setLineWeight(DYNMAP_STYLE_LINE_WEIGHT)
-            .setFillColor(DYNMAP_STYLE_FILL_COLOR)
-            .setFillOpacity(DYNMAP_STYLE_FILL_OPACITY)
-            .setHomeMarker(DYNMAP_STYLE_HOME_MARKER)
-            .setBoost(DYNMAP_STYLE_BOOST);
 
     // Optional per Faction style overrides. Any defined replace those in dynmapDefaultStyle.
     // Specify Faction either by name or UUID.
-    public static Map<String, DynmapStyle> dynmapFactionStyles = ImmutableMap.of(
+    public static Map<String, DynmapStyle> dynmapFactionStyles = ImmutableMap.of("SafeZone", new DynmapStyle().setStrokeColor("#FF00FF").setFillColor("#FF00FF").setBoost(false), "WarZone", new DynmapStyle().setStrokeColor("#FF0000").setFillColor("#FF0000").setBoost(false));
-            "SafeZone", new DynmapStyle().setStrokeColor("#FF00FF").setFillColor("#FF00FF").setBoost(false),
-            "WarZone", new DynmapStyle().setStrokeColor("#FF0000").setFillColor("#FF0000").setBoost(false)
-    );
 
 
     //Faction banks, to pay for land claiming and other costs instead of individuals paying for them

src/main/java/com/massivecraft/factions/integration/Essentials.java

@@ -38,7 +38,7 @@ public class Essentials {
     }
 
     public static boolean isVanished(Player player) {
-        if(essentials == null) {
+        if (essentials == null) {
             return false;
         }
         return essentials.getUser(player).isVanished();

src/main/java/com/massivecraft/factions/integration/dynmap/DynmapStyle.java

@@ -2,65 +2,111 @@ package com.massivecraft.factions.integration.dynmap;
 
 import com.massivecraft.factions.Conf;
 
-public class DynmapStyle
+public class DynmapStyle {
-{
     // -------------------------------------------- //
     // FIELDS
     // -------------------------------------------- //
 
     public String lineColor = null;
-	public int getLineColor() { return getColor(coalesce(this.lineColor, Conf.dynmapDefaultStyle.lineColor, Conf.DYNMAP_STYLE_LINE_COLOR)); }
+
-	public DynmapStyle setStrokeColor(String strokeColor) { this.lineColor = strokeColor; return this; }
+    public int getLineColor() {
+        return getColor(coalesce(this.lineColor, Conf.dynmapDefaultStyle.lineColor, Conf.DYNMAP_STYLE_LINE_COLOR));
+    }
+
+    public DynmapStyle setStrokeColor(String strokeColor) {
+        this.lineColor = strokeColor;
+        return this;
+    }
 
     public Double lineOpacity = null;
-	public double getLineOpacity() { return coalesce(this.lineOpacity, Conf.dynmapDefaultStyle.lineOpacity, Conf.DYNMAP_STYLE_LINE_OPACITY); }
+
-	public DynmapStyle setLineOpacity(Double strokeOpacity) { this.lineOpacity = strokeOpacity; return this; }
+    public double getLineOpacity() {
+        return coalesce(this.lineOpacity, Conf.dynmapDefaultStyle.lineOpacity, Conf.DYNMAP_STYLE_LINE_OPACITY);
+    }
+
+    public DynmapStyle setLineOpacity(Double strokeOpacity) {
+        this.lineOpacity = strokeOpacity;
+        return this;
+    }
 
     public Integer lineWeight = null;
-	public int getLineWeight() { return coalesce(this.lineWeight, Conf.dynmapDefaultStyle.lineWeight, Conf.DYNMAP_STYLE_LINE_WEIGHT); }
+
-	public DynmapStyle setLineWeight(Integer strokeWeight) { this.lineWeight = strokeWeight; return this; }
+    public int getLineWeight() {
+        return coalesce(this.lineWeight, Conf.dynmapDefaultStyle.lineWeight, Conf.DYNMAP_STYLE_LINE_WEIGHT);
+    }
+
+    public DynmapStyle setLineWeight(Integer strokeWeight) {
+        this.lineWeight = strokeWeight;
+        return this;
+    }
 
     public String fillColor = null;
-	public int getFillColor() { return getColor(coalesce(this.fillColor, Conf.dynmapDefaultStyle.fillColor, Conf.DYNMAP_STYLE_FILL_COLOR)); }
+
-	public DynmapStyle setFillColor(String fillColor) { this.fillColor = fillColor; return this; }
+    public int getFillColor() {
+        return getColor(coalesce(this.fillColor, Conf.dynmapDefaultStyle.fillColor, Conf.DYNMAP_STYLE_FILL_COLOR));
+    }
+
+    public DynmapStyle setFillColor(String fillColor) {
+        this.fillColor = fillColor;
+        return this;
+    }
 
     public Double fillOpacity = null;
-	public double getFillOpacity() { return coalesce(this.fillOpacity, Conf.dynmapDefaultStyle.fillOpacity, Conf.DYNMAP_STYLE_FILL_OPACITY); }
+
-	public DynmapStyle setFillOpacity(Double fillOpacity) { this.fillOpacity = fillOpacity; return this; }
+    public double getFillOpacity() {
+        return coalesce(this.fillOpacity, Conf.dynmapDefaultStyle.fillOpacity, Conf.DYNMAP_STYLE_FILL_OPACITY);
+    }
+
+    public DynmapStyle setFillOpacity(Double fillOpacity) {
+        this.fillOpacity = fillOpacity;
+        return this;
+    }
 
     // NOTE: We just return the string here. We do not return the resolved Dynmap MarkerIcon object.
     // The reason is we use this class in the MConf. For serialization to work Dynmap would have to be loaded and we can't require that.
     // Using dynmap is optional.
     public String homeMarker = null;
-	public String getHomeMarker() { return coalesce(this.homeMarker, Conf.dynmapDefaultStyle.homeMarker, Conf.DYNMAP_STYLE_HOME_MARKER); }
+
-	public DynmapStyle setHomeMarker(String homeMarker) { this.homeMarker = homeMarker; return this; }
+    public String getHomeMarker() {
+        return coalesce(this.homeMarker, Conf.dynmapDefaultStyle.homeMarker, Conf.DYNMAP_STYLE_HOME_MARKER);
+    }
+
+    public DynmapStyle setHomeMarker(String homeMarker) {
+        this.homeMarker = homeMarker;
+        return this;
+    }
 
     public Boolean boost = null;
-	public boolean getBoost() { return coalesce(this.boost, Conf.dynmapDefaultStyle.boost, Conf.DYNMAP_STYLE_BOOST); }
+
-	public DynmapStyle setBoost(Boolean boost) { this.boost = boost; return this; }
+    public boolean getBoost() {
+        return coalesce(this.boost, Conf.dynmapDefaultStyle.boost, Conf.DYNMAP_STYLE_BOOST);
+    }
+
+    public DynmapStyle setBoost(Boolean boost) {
+        this.boost = boost;
+        return this;
+    }
 
     // -------------------------------------------- //
     // UTIL
     // -------------------------------------------- //
 
     @SafeVarargs
-	public static <T> T coalesce(T... items)
+    public static <T> T coalesce(T... items) {
-	{
+        for (T item : items) {
-		for (T item : items)
+            if (item != null) {
-		{
+                return item;
-			if (item != null) return item;
+            }
         }
         return null;
     }
 
-	public static int getColor(String string)
+    public static int getColor(String string) {
-	{
         int ret = 0x00FF00;
-		try
+        try {
-		{
             ret = Integer.parseInt(string.substring(1), 16);
+        } catch (NumberFormatException ignored) {
         }
-		catch (NumberFormatException ignored) {}
         return ret;
     }
 

src/main/java/com/massivecraft/factions/integration/dynmap/EngineDynmap.java

@@ -16,8 +16,7 @@ import java.util.*;
 import java.util.Map.Entry;
 
 // This source code is a heavily modified version of mikeprimms plugin Dynmap-Factions.
-public class EngineDynmap
+public class EngineDynmap {
-{
     // -------------------------------------------- //
     // CONSTANTS
     // -------------------------------------------- //
@@ -42,27 +41,28 @@ public class EngineDynmap
     // -------------------------------------------- //
 
     private static EngineDynmap i = new EngineDynmap();
-    public static EngineDynmap getInstance() { return i; }
+
-    private EngineDynmap() {}
+    public static EngineDynmap getInstance() {
+        return i;
+    }
+
+    private EngineDynmap() {
+    }
 
     public DynmapAPI dynmapApi;
     public MarkerAPI markerApi;
     public MarkerSet markerset;
 
-    public void init()
+    public void init() {
-    {
         Plugin dynmap = Bukkit.getServer().getPluginManager().getPlugin("dynmap");
 
-        if (dynmap == null || !dynmap.isEnabled())
+        if (dynmap == null || !dynmap.isEnabled()) {
-        {
             return;
         }
 
         // Should we even use dynmap?
-        if (!Conf.dynmapUse)
+        if (!Conf.dynmapUse) {
-        {
+            if (this.markerset != null) {
-            if (this.markerset != null)
-            {
                 this.markerset.deleteMarkerSet();
                 this.markerset = null;
             }
@@ -70,20 +70,22 @@ public class EngineDynmap
         }
 
         // Shedule non thread safe sync at the end!
-        Bukkit.getScheduler().scheduleSyncRepeatingTask(P.p, new Runnable()
+        Bukkit.getScheduler().scheduleSyncRepeatingTask(P.p, new Runnable() {
-        {
             @Override
-            public void run()
+            public void run() {
-            {
 
                 final Map<String, TempMarker> homes = createHomes();
                 final Map<String, TempAreaMarker> areas = createAreas();
                 final Map<String, Set<String>> playerSets = createPlayersets();
 
-                if (!updateCore()) return;
+                if (!updateCore()) {
+                    return;
+                }
 
                 // createLayer() is thread safe but it makes use of fields set in updateCore() so we must have it after.
-                if (!updateLayer(createLayer())) return;
+                if (!updateLayer(createLayer())) {
+                    return;
+                }
 
                 updateHomes(homes);
                 updateAreas(areas);
@@ -93,20 +95,17 @@ public class EngineDynmap
     }
 
     // Thread Safe / Asynchronous: No
-    public boolean updateCore()
+    public boolean updateCore() {
-    {
         // Get DynmapAPI
         this.dynmapApi = (DynmapAPI) Bukkit.getPluginManager().getPlugin("dynmap");
-        if (this.dynmapApi == null)
+        if (this.dynmapApi == null) {
-        {
             severe("Could not retrieve the DynmapAPI.");
             return false;
         }
 
         // Get MarkerAPI
         this.markerApi = this.dynmapApi.getMarkerAPI();
-        if (this.markerApi == null)
+        if (this.markerApi == null) {
-        {
             severe("Could not retrieve the MarkerAPI.");
             return false;
         }
@@ -115,8 +114,7 @@ public class EngineDynmap
     }
 
     // Thread Safe / Asynchronous: Yes
-    public TempMarkerSet createLayer()
+    public TempMarkerSet createLayer() {
-    {
         TempMarkerSet ret = new TempMarkerSet();
         ret.label = Conf.dynmapLayerName;
         ret.minimumZoom = Conf.dynmapLayerMinimumZoom;
@@ -126,20 +124,15 @@ public class EngineDynmap
     }
 
     // Thread Safe / Asynchronous: No
-    public boolean updateLayer(TempMarkerSet temp)
+    public boolean updateLayer(TempMarkerSet temp) {
-    {
         this.markerset = this.markerApi.getMarkerSet(FACTIONS_MARKERSET);
-        if (this.markerset == null)
+        if (this.markerset == null) {
-        {
             this.markerset = temp.create(this.markerApi, FACTIONS_MARKERSET);
-            if (this.markerset == null)
+            if (this.markerset == null) {
-            {
                 severe("Could not create the Faction Markerset/Layer");
                 return false;
             }
-        }
+        } else {
-        else
-        {
             temp.update(this.markerset);
         }
         return true;
@@ -150,15 +143,15 @@ public class EngineDynmap
     // -------------------------------------------- //
 
     // Thread Safe / Asynchronous: Yes
-    public Map<String, TempMarker> createHomes()
+    public Map<String, TempMarker> createHomes() {
-    {
         Map<String, TempMarker> ret = new HashMap<String, TempMarker>();
 
         // Loop current factions
-        for (Faction faction : Factions.getInstance().getAllFactions())
+        for (Faction faction : Factions.getInstance().getAllFactions()) {
-        {
             Location ps = faction.getHome();
-            if (ps == null) continue;
+            if (ps == null) {
+                continue;
+            }
 
             DynmapStyle style = getStyle(faction);
 
@@ -181,18 +174,15 @@ public class EngineDynmap
 
     // Thread Safe / Asynchronous: No
     // This method places out the faction home markers into the factions markerset.
-    public void updateHomes(Map<String, TempMarker> homes)
+    public void updateHomes(Map<String, TempMarker> homes) {
-    {
         // Put all current faction markers in a map
         Map<String, Marker> markers = new HashMap<String, Marker>();
-        for (Marker marker : this.markerset.getMarkers())
+        for (Marker marker : this.markerset.getMarkers()) {
-        {
             markers.put(marker.getMarkerID(), marker);
         }
 
         // Loop homes
-        for (Entry<String, TempMarker> entry : homes.entrySet())
+        for (Entry<String, TempMarker> entry : homes.entrySet()) {
-        {
             String markerId = entry.getKey();
             TempMarker temp = entry.getValue();
 
@@ -200,24 +190,19 @@ public class EngineDynmap
             // NOTE: I remove from the map created just in the beginning of this method.
             // NOTE: That way what is left at the end will be outdated markers to remove.
             Marker marker = markers.remove(markerId);
-            if (marker == null)
+            if (marker == null) {
-            {
                 marker = temp.create(this.markerApi, this.markerset, markerId);
-                if (marker == null)
+                if (marker == null) {
-                {
                     EngineDynmap.severe("Could not get/create the home marker " + markerId);
                 }
-            }
+            } else {
-            else
-            {
                 temp.update(this.markerApi, marker);
             }
         }
 
         // Delete Deprecated Markers
         // Only old markers should now be left
-        for (Marker marker : markers.values())
+        for (Marker marker : markers.values()) {
-        {
             marker.deleteMarker();
         }
     }
@@ -227,35 +212,31 @@ public class EngineDynmap
     // -------------------------------------------- //
 
     // Thread Safe: YES
-    public Map<String, TempAreaMarker> createAreas()
+    public Map<String, TempAreaMarker> createAreas() {
-    {
         Map<String, Map<Faction, Set<FLocation>>> worldFactionChunks = createWorldFactionChunks();
         return createAreas(worldFactionChunks);
     }
 
     // Thread Safe: YES
-    public Map<String, Map<Faction, Set<FLocation>>> createWorldFactionChunks()
+    public Map<String, Map<Faction, Set<FLocation>>> createWorldFactionChunks() {
-    {
         // Create map "world name --> faction --> set of chunk coords"
         Map<String, Map<Faction, Set<FLocation>>> worldFactionChunks = new HashMap<String, Map<Faction, Set<FLocation>>>();
 
         // Note: The board is the world. The board id is the world name.
         MemoryBoard board = (MemoryBoard) Board.getInstance();
 
-        for (Entry<FLocation,String> entry : board.flocationIds.entrySet())
+        for (Entry<FLocation, String> entry : board.flocationIds.entrySet()) {
-        {
             String world = entry.getKey().getWorldName();
             Faction chunkOwner = Factions.getInstance().getFactionById(entry.getValue());
 
             Map<Faction, Set<FLocation>> factionChunks = worldFactionChunks.get(world);
-            if (factionChunks == null)
+            if (factionChunks == null) {
-            {
                 factionChunks = new HashMap<Faction, Set<FLocation>>();
                 worldFactionChunks.put(world, factionChunks);
             }
 
             Set<FLocation> factionTerritory = factionChunks.get(chunkOwner);
-            if (factionTerritory == null){
+            if (factionTerritory == null) {
                 factionTerritory = new HashSet<FLocation>();
                 factionChunks.put(chunkOwner, factionTerritory);
             }
@@ -267,19 +248,16 @@ public class EngineDynmap
     }
 
     // Thread Safe: YES
-    public Map<String, TempAreaMarker> createAreas(Map<String, Map<Faction, Set<FLocation>>> worldFactionChunks)
+    public Map<String, TempAreaMarker> createAreas(Map<String, Map<Faction, Set<FLocation>>> worldFactionChunks) {
-    {
         Map<String, TempAreaMarker> ret = new HashMap<String, TempAreaMarker>();
 
         // For each world
-        for (Entry<String, Map<Faction, Set<FLocation>>> entry : worldFactionChunks.entrySet())
+        for (Entry<String, Map<Faction, Set<FLocation>>> entry : worldFactionChunks.entrySet()) {
-        {
             String world = entry.getKey();
             Map<Faction, Set<FLocation>> factionChunks = entry.getValue();
 
             // For each faction and its chunks in that world
-            for (Entry<Faction, Set<FLocation>> entry1 : factionChunks.entrySet())
+            for (Entry<Faction, Set<FLocation>> entry1 : factionChunks.entrySet()) {
-            {
                 Faction faction = entry1.getKey();
                 Set<FLocation> chunks = entry1.getValue();
                 Map<String, TempAreaMarker> worldFactionMarkers = createAreas(world, faction, chunks);
@@ -293,15 +271,18 @@ public class EngineDynmap
     // Thread Safe: YES
     // Handle specific faction on specific world
     // "handle faction on world"
-    public Map<String, TempAreaMarker> createAreas(String world, Faction faction, Set<FLocation> chunks)
+    public Map<String, TempAreaMarker> createAreas(String world, Faction faction, Set<FLocation> chunks) {
-    {
         Map<String, TempAreaMarker> ret = new HashMap<String, TempAreaMarker>();
 
         // If the faction is visible ...
-        if (!isVisible(faction, world)) return ret;
+        if (!isVisible(faction, world)) {
+            return ret;
+        }
 
         // ... and has any chunks ...
-        if (chunks.isEmpty()) return ret;
+        if (chunks.isEmpty()) {
+            return ret;
+        }
 
         // Index of polygon for given faction
         int markerIndex = 0;
@@ -315,29 +296,25 @@ public class EngineDynmap
         // Loop through chunks: set flags on chunk map
         TileFlags allChunkFlags = new TileFlags();
         LinkedList<FLocation> allChunks = new LinkedList<FLocation>();
-        for (FLocation chunk : chunks)
+        for (FLocation chunk : chunks) {
-        {
+            allChunkFlags.setFlag((int) chunk.getX(), (int) chunk.getZ(), true); // Set flag for chunk
-            allChunkFlags.setFlag((int)chunk.getX(), (int)chunk.getZ(), true); // Set flag for chunk
             allChunks.addLast(chunk);
         }
 
         // Loop through until we don't find more areas
-        while (allChunks != null)
+        while (allChunks != null) {
-        {
             TileFlags ourChunkFlags = null;
             LinkedList<FLocation> ourChunks = null;
             LinkedList<FLocation> newChunks = null;
 
             int minimumX = Integer.MAX_VALUE;
             int minimumZ = Integer.MAX_VALUE;
-            for (FLocation chunk : allChunks)
+            for (FLocation chunk : allChunks) {
-            {
+                int chunkX = (int) chunk.getX();
-                int chunkX = (int)chunk.getX();
+                int chunkZ = (int) chunk.getZ();
-                int chunkZ = (int)chunk.getZ();
 
                 // If we need to start shape, and this block is not part of one yet
-                if (ourChunkFlags == null && allChunkFlags.getFlag(chunkX, chunkZ))
+                if (ourChunkFlags == null && allChunkFlags.getFlag(chunkX, chunkZ)) {
-                {
                     ourChunkFlags = new TileFlags(); // Create map for shape
                     ourChunks = new LinkedList<FLocation>();
                     floodFillTarget(allChunkFlags, ourChunkFlags, chunkX, chunkZ); // Copy shape
@@ -346,23 +323,20 @@ public class EngineDynmap
                     minimumZ = chunkZ;
                 }
                 // If shape found, and we're in it, add to our node list
-                else if (ourChunkFlags != null && ourChunkFlags.getFlag(chunkX, chunkZ))
+                else if (ourChunkFlags != null && ourChunkFlags.getFlag(chunkX, chunkZ)) {
-                {
                     ourChunks.add(chunk);
-                    if (chunkX < minimumX)
+                    if (chunkX < minimumX) {
-                    {
                         minimumX = chunkX;
                         minimumZ = chunkZ;
-                    }
+                    } else if (chunkX == minimumX && chunkZ < minimumZ) {
-                    else if (chunkX == minimumX && chunkZ < minimumZ)
-                    {
                         minimumZ = chunkZ;
                     }
                 }
                 // Else, keep it in the list for the next polygon
-                else
+                else {
-                {
+                    if (newChunks == null) {
-                    if (newChunks == null) newChunks = new LinkedList<FLocation>();
+                        newChunks = new LinkedList<FLocation>();
+                    }
                     newChunks.add(chunk);
                 }
             }
@@ -370,7 +344,9 @@ public class EngineDynmap
             // Replace list (null if no more to process)
             allChunks = newChunks;
 
-            if (ourChunkFlags == null) continue;
+            if (ourChunkFlags == null) {
+                continue;
+            }
 
             // Trace outline of blocks - start from minx, minz going to x+
             int initialX = minimumX;
@@ -379,78 +355,56 @@ public class EngineDynmap
             int currentZ = minimumZ;
             Direction direction = Direction.XPLUS;
             ArrayList<int[]> linelist = new ArrayList<int[]>();
-            linelist.add(new int[]{ initialX, initialZ }); // Add start point
+            linelist.add(new int[]{initialX, initialZ}); // Add start point
-            while ((currentX != initialX) || (currentZ != initialZ) || (direction != Direction.ZMINUS))
+            while ((currentX != initialX) || (currentZ != initialZ) || (direction != Direction.ZMINUS)) {
-            {
+                switch (direction) {
-                switch (direction)
-                {
                     case XPLUS: // Segment in X+ direction
-                        if (!ourChunkFlags.getFlag(currentX + 1, currentZ))
+                        if (!ourChunkFlags.getFlag(currentX + 1, currentZ)) { // Right turn?
-                        { // Right turn?
+                            linelist.add(new int[]{currentX + 1, currentZ}); // Finish line
-                            linelist.add(new int[]{ currentX + 1, currentZ }); // Finish line
                             direction = Direction.ZPLUS; // Change direction
-                        }
+                        } else if (!ourChunkFlags.getFlag(currentX + 1, currentZ - 1)) { // Straight?
-                        else if (!ourChunkFlags.getFlag(currentX + 1, currentZ - 1))
-                        { // Straight?
                             currentX++;
-                        }
+                        } else { // Left turn
-                        else
+                            linelist.add(new int[]{currentX + 1, currentZ}); // Finish line
-                        { // Left turn
-                            linelist.add(new int[]{ currentX + 1, currentZ }); // Finish line
                             direction = Direction.ZMINUS;
                             currentX++;
                             currentZ--;
                         }
                         break;
                     case ZPLUS: // Segment in Z+ direction
-                        if (!ourChunkFlags.getFlag(currentX, currentZ + 1))
+                        if (!ourChunkFlags.getFlag(currentX, currentZ + 1)) { // Right turn?
-                        { // Right turn?
+                            linelist.add(new int[]{currentX + 1, currentZ + 1}); // Finish line
-                            linelist.add(new int[]{ currentX + 1, currentZ + 1 }); // Finish line
                             direction = Direction.XMINUS; // Change direction
-                        }
+                        } else if (!ourChunkFlags.getFlag(currentX + 1, currentZ + 1)) { // Straight?
-                        else if (!ourChunkFlags.getFlag(currentX + 1, currentZ + 1))
-                        { // Straight?
                             currentZ++;
-                        }
+                        } else { // Left turn
-                        else
+                            linelist.add(new int[]{currentX + 1, currentZ + 1}); // Finish line
-                        { // Left turn
-                            linelist.add(new int[]{ currentX + 1, currentZ + 1 }); // Finish line
                             direction = Direction.XPLUS;
                             currentX++;
                             currentZ++;
                         }
                         break;
                     case XMINUS: // Segment in X- direction
-                        if (!ourChunkFlags.getFlag(currentX - 1, currentZ))
+                        if (!ourChunkFlags.getFlag(currentX - 1, currentZ)) { // Right turn?
-                        { // Right turn?
+                            linelist.add(new int[]{currentX, currentZ + 1}); // Finish line
-                            linelist.add(new int[]{ currentX, currentZ + 1 }); // Finish line
                             direction = Direction.ZMINUS; // Change direction
-                        }
+                        } else if (!ourChunkFlags.getFlag(currentX - 1, currentZ + 1)) { // Straight?
-                        else if (!ourChunkFlags.getFlag(currentX - 1, currentZ + 1))
-                        { // Straight?
                             currentX--;
-                        }
+                        } else { // Left turn
-                        else
+                            linelist.add(new int[]{currentX, currentZ + 1}); // Finish line
-                        { // Left turn
-                            linelist.add(new int[] { currentX, currentZ + 1 }); // Finish line
                             direction = Direction.ZPLUS;
                             currentX--;
                             currentZ++;
                         }
                         break;
                     case ZMINUS: // Segment in Z- direction
-                        if (!ourChunkFlags.getFlag(currentX, currentZ - 1))
+                        if (!ourChunkFlags.getFlag(currentX, currentZ - 1)) { // Right turn?
-                        { // Right turn?
+                            linelist.add(new int[]{currentX, currentZ}); // Finish line
-                            linelist.add(new int[]{ currentX, currentZ }); // Finish line
                             direction = Direction.XPLUS; // Change direction
-                        }
+                        } else if (!ourChunkFlags.getFlag(currentX - 1, currentZ - 1)) { // Straight?
-                        else if (!ourChunkFlags.getFlag(currentX - 1, currentZ - 1))
-                        { // Straight?
                             currentZ--;
-                        }
+                        } else { // Left turn
-                        else
+                            linelist.add(new int[]{currentX, currentZ}); // Finish line
-                        { // Left turn
-                            linelist.add(new int[] { currentX, currentZ }); // Finish line
                             direction = Direction.XMINUS;
                             currentX--;
                             currentZ--;
@@ -462,8 +416,7 @@ public class EngineDynmap
             int sz = linelist.size();
             double[] x = new double[sz];
             double[] z = new double[sz];
-            for (int i = 0; i < sz; i++)
+            for (int i = 0; i < sz; i++) {
-            {
                 int[] line = linelist.get(i);
                 x[i] = (double) line[0] * (double) BLOCKS_PER_CHUNK;
                 z[i] = (double) line[1] * (double) BLOCKS_PER_CHUNK;
@@ -497,18 +450,15 @@ public class EngineDynmap
     }
 
     // Thread Safe: NO
-    public void updateAreas(Map<String, TempAreaMarker> areas)
+    public void updateAreas(Map<String, TempAreaMarker> areas) {
-    {
         // Map Current
         Map<String, AreaMarker> markers = new HashMap<String, AreaMarker>();
-        for (AreaMarker marker : this.markerset.getAreaMarkers())
+        for (AreaMarker marker : this.markerset.getAreaMarkers()) {
-        {
             markers.put(marker.getMarkerID(), marker);
         }
 
         // Loop New
-        for (Entry<String, TempAreaMarker> entry : areas.entrySet())
+        for (Entry<String, TempAreaMarker> entry : areas.entrySet()) {
-        {
             String markerId = entry.getKey();
             TempAreaMarker temp = entry.getValue();
 
@@ -516,23 +466,18 @@ public class EngineDynmap
             // NOTE: I remove from the map created just in the beginning of this method.
             // NOTE: That way what is left at the end will be outdated markers to remove.
             AreaMarker marker = markers.remove(markerId);
-            if (marker == null)
+            if (marker == null) {
-            {
                 marker = temp.create(this.markerset, markerId);
-                if (marker == null)
+                if (marker == null) {
-                {
                     severe("Could not get/create the area marker " + markerId);
                 }
-            }
+            } else {
-            else
-            {
                 temp.update(marker);
             }
         }
 
         // Only old/outdated should now be left. Delete them.
-        for (AreaMarker marker : markers.values())
+        for (AreaMarker marker : markers.values()) {
-        {
             marker.deleteMarker();
         }
     }
@@ -542,25 +487,32 @@ public class EngineDynmap
     // -------------------------------------------- //
 
     // Thread Safe / Asynchronous: Yes
-    public String createPlayersetId(Faction faction)
+    public String createPlayersetId(Faction faction) {
-    {
+        if (faction == null) {
-        if (faction == null) return null;
+            return null;
-        if (faction.isNone()) return null;
+        }
+        if (faction.isNone()) {
+            return null;
+        }
         String factionId = faction.getId();
-        if (factionId == null) return null;
+        if (factionId == null) {
+            return null;
+        }
         return FACTIONS_PLAYERSET_ + factionId;
     }
 
     // Thread Safe / Asynchronous: Yes
-    public Set<String> createPlayerset(Faction faction)
+    public Set<String> createPlayerset(Faction faction) {
-    {
+        if (faction == null) {
-        if (faction == null) return null;
+            return null;
-        if (faction.isNone()) return null;
+        }
+        if (faction.isNone()) {
+            return null;
+        }
 
         Set<String> ret = new HashSet<String>();
 
-        for (FPlayer fplayer : faction.getFPlayers())
+        for (FPlayer fplayer : faction.getFPlayers()) {
-        {
             // NOTE: We add both UUID and name. This might be a good idea for future proofing.
             ret.add(fplayer.getId());
             ret.add(fplayer.getName());
@@ -570,21 +522,22 @@ public class EngineDynmap
     }
 
     // Thread Safe / Asynchronous: Yes
-    public Map<String, Set<String>> createPlayersets()
+    public Map<String, Set<String>> createPlayersets() {
-    {
+        if (!Conf.dynmapVisibilityByFaction) {
-        if (!Conf.dynmapVisibilityByFaction)
-        {
             return null;
         }
 
         Map<String, Set<String>> ret = new HashMap<String, Set<String>>();
 
-        for (Faction faction : Factions.getInstance().getAllFactions())
+        for (Faction faction : Factions.getInstance().getAllFactions()) {
-        {
             String playersetId = createPlayersetId(faction);
-            if (playersetId == null) continue;
+            if (playersetId == null) {
+                continue;
+            }
             Set<String> playerIds = createPlayerset(faction);
-            if (playerIds == null) continue;
+            if (playerIds == null) {
+                continue;
+            }
             ret.put(playersetId, playerIds);
         }
 
@@ -592,41 +545,41 @@ public class EngineDynmap
     }
 
     // Thread Safe / Asynchronous: No
-    public void updatePlayersets(Map<String, Set<String>> playersets)
+    public void updatePlayersets(Map<String, Set<String>> playersets) {
-    {
+        if (playersets == null) {
-        if (playersets == null)
-        {
             return;
         }
 
         // Remove
-        for (PlayerSet set : this.markerApi.getPlayerSets())
+        for (PlayerSet set : this.markerApi.getPlayerSets()) {
-        {
+            if (!set.getSetID().startsWith(FACTIONS_PLAYERSET_)) {
-            if (!set.getSetID().startsWith(FACTIONS_PLAYERSET_)) continue;
+                continue;
+            }
 
             // (Null means remove all)
-            if (playersets.containsKey(set.getSetID())) continue;
+            if (playersets.containsKey(set.getSetID())) {
+                continue;
+            }
 
             set.deleteSet();
         }
 
         // Add / Update
-        for (Entry<String, Set<String>> entry : playersets.entrySet())
+        for (Entry<String, Set<String>> entry : playersets.entrySet()) {
-        {
             // Extract from Entry
             String setId = entry.getKey();
             Set<String> playerIds = entry.getValue();
 
             // Get Creatively
             PlayerSet set = this.markerApi.getPlayerSet(setId);
-            if (set == null) set = this.markerApi.createPlayerSet(
+            if (set == null) {
-                setId, // id
+                set = this.markerApi.createPlayerSet(setId, // id
                                                             true, // symmetric
                                                             playerIds, // players
                                                             false // persistent
                 );
-            if (set == null)
+            }
-            {
+            if (set == null) {
                 severe("Could not get/create the player set " + setId);
                 continue;
             }
@@ -641,8 +594,7 @@ public class EngineDynmap
     // -------------------------------------------- //
 
     // Thread Safe / Asynchronous: Yes
-    private String getDescription(Faction faction)
+    private String getDescription(Faction faction) {
-    {
         String ret = "<div class=\"regioninfo\">" + Conf.dynmapDescription + "</div>";
 
         // Name
@@ -660,8 +612,7 @@ public class EngineDynmap
         // Money
 
         String money = "unavailable";
-        if (Conf.bankEnabled && Conf.dynmapDescriptionMoney)
+        if (Conf.bankEnabled && Conf.dynmapDescriptionMoney) {
-        {
             money = String.format("%.2f", Econ.getBalance(faction.getAccountId()));
         }
         ret = ret.replace("%money%", money);
@@ -702,37 +653,33 @@ public class EngineDynmap
         return ret;
     }
 
-    public static String getHtmlPlayerString(Collection<FPlayer> playersOfficersList)
+    public static String getHtmlPlayerString(Collection<FPlayer> playersOfficersList) {
-    {
         String ret = "";
-        for (FPlayer fplayer : playersOfficersList)
+        for (FPlayer fplayer : playersOfficersList) {
-        {
+            if (ret.length() > 0) {
-            if (ret.length() > 0) ret += ", ";
+                ret += ", ";
+            }
             ret += getHtmlPlayerName(fplayer);
         }
         return ret;
     }
 
-    public static String getHtmlPlayerName(FPlayer fplayer)
+    public static String getHtmlPlayerName(FPlayer fplayer) {
-    {
+        if (fplayer == null) {
-        if (fplayer == null) return "none";
+            return "none";
+        }
         return escapeHtml(fplayer.getName());
     }
 
-    public static String escapeHtml(String string)
+    public static String escapeHtml(String string) {
-    {
         StringBuilder out = new StringBuilder(Math.max(16, string.length()));
-        for (int i = 0; i < string.length(); i++)
+        for (int i = 0; i < string.length(); i++) {
-        {
             char c = string.charAt(i);
-            if (c > 127 || c == '"' || c == '<' || c == '>' || c == '&')
+            if (c > 127 || c == '"' || c == '<' || c == '>' || c == '&') {
-            {
                 out.append("&#");
                 out.append((int) c);
                 out.append(';');
-            }
+            } else {
-            else
-            {
                 out.append(c);
             }
         }
@@ -740,24 +687,27 @@ public class EngineDynmap
     }
 
     // Thread Safe / Asynchronous: Yes
-    private boolean isVisible(Faction faction, String world)
+    private boolean isVisible(Faction faction, String world) {
-    {
+        if (faction == null) {
-        if (faction == null) return false;
+            return false;
+        }
         final String factionId = faction.getId();
-        if (factionId == null) return false;
+        if (factionId == null) {
+            return false;
+        }
         final String factionName = faction.getTag();
-        if (factionName == null) return false;
+        if (factionName == null) {
+            return false;
+        }
 
         Set<String> visible = Conf.dynmapVisibleFactions;
         Set<String> hidden = Conf.dynmapHiddenFactions;
 
-        if (!visible.isEmpty() && !visible.contains(factionId) && !visible.contains(factionName) && !visible.contains("world:" + world))
+        if (!visible.isEmpty() && !visible.contains(factionId) && !visible.contains(factionName) && !visible.contains("world:" + world)) {
-        {
             return false;
         }
 
-        if (hidden.contains(factionId) || hidden.contains(factionName) || hidden.contains("world:" + world))
+        if (hidden.contains(factionId) || hidden.contains(factionName) || hidden.contains("world:" + world)) {
-        {
             return false;
         }
 
@@ -765,59 +715,64 @@ public class EngineDynmap
     }
 
     // Thread Safe / Asynchronous: Yes
-    public DynmapStyle getStyle(Faction faction)
+    public DynmapStyle getStyle(Faction faction) {
-    {
         DynmapStyle ret;
 
         ret = Conf.dynmapFactionStyles.get(faction.getId());
-        if (ret != null) return ret;
+        if (ret != null) {
+            return ret;
+        }
 
         ret = Conf.dynmapFactionStyles.get(faction.getTag());
-        if (ret != null) return ret;
+        if (ret != null) {
+            return ret;
+        }
 
         return Conf.dynmapDefaultStyle;
     }
 
     // Thread Safe / Asynchronous: Yes
-    public static void info(String msg)
+    public static void info(String msg) {
-    {
         String message = DYNMAP_INTEGRATION + msg;
         System.out.println(message);
     }
 
     // Thread Safe / Asynchronous: Yes
-    public static void severe(String msg)
+    public static void severe(String msg) {
-    {
         String message = DYNMAP_INTEGRATION + ChatColor.RED.toString() + msg;
         System.out.println(message);
     }
 
-    enum Direction
+    enum Direction {
-    {
         XPLUS, ZPLUS, XMINUS, ZMINUS
     }
 
     // Find all contiguous blocks, set in target and clear in source
-    private int floodFillTarget(TileFlags source, TileFlags destination, int x, int y)
+    private int floodFillTarget(TileFlags source, TileFlags destination, int x, int y) {
-    {
         int cnt = 0;
         ArrayDeque<int[]> stack = new ArrayDeque<int[]>();
-        stack.push(new int[] { x, y });
+        stack.push(new int[]{x, y});
 
-        while (!stack.isEmpty())
+        while (!stack.isEmpty()) {
-        {
             int[] nxt = stack.pop();
             x = nxt[0];
             y = nxt[1];
-            if (source.getFlag(x, y))
+            if (source.getFlag(x, y)) { // Set in src
-            { // Set in src
                 source.setFlag(x, y, false); // Clear source
                 destination.setFlag(x, y, true); // Set in destination
                 cnt++;
-                if (source.getFlag(x + 1, y)) stack.push(new int[] { x + 1, y });
+                if (source.getFlag(x + 1, y)) {
-                if (source.getFlag(x - 1, y)) stack.push(new int[] { x - 1, y });
+                    stack.push(new int[]{x + 1, y});
-                if (source.getFlag(x, y + 1)) stack.push(new int[] { x, y + 1 });
+                }
-                if (source.getFlag(x, y - 1)) stack.push(new int[] { x, y - 1 });
+                if (source.getFlag(x - 1, y)) {
+                    stack.push(new int[]{x - 1, y});
+                }
+                if (source.getFlag(x, y + 1)) {
+                    stack.push(new int[]{x, y + 1});
+                }
+                if (source.getFlag(x, y - 1)) {
+                    stack.push(new int[]{x, y - 1});
+                }
             }
         }
         return cnt;

src/main/java/com/massivecraft/factions/integration/dynmap/TempAreaMarker.java

@@ -3,8 +3,7 @@ package com.massivecraft.factions.integration.dynmap;
 import org.dynmap.markers.AreaMarker;
 import org.dynmap.markers.MarkerSet;
 
-public class TempAreaMarker
+public class TempAreaMarker {
-{
     // -------------------------------------------- //
     // FIELDS
     // -------------------------------------------- //
@@ -28,19 +27,13 @@ public class TempAreaMarker
     // CREATE
     // -------------------------------------------- //
 
-	public AreaMarker create(MarkerSet markerset, String markerId)
+    public AreaMarker create(MarkerSet markerset, String markerId) {
-	{
+        AreaMarker ret = markerset.createAreaMarker(markerId, this.label, false, this.world, this.x, this.z, false // not persistent
-		AreaMarker ret = markerset.createAreaMarker(
-			markerId,
-			this.label,
-			false,
-			this.world,
-			this.x,
-			this.z,
-			false // not persistent
         );
 
-		if (ret == null) return null;
+        if (ret == null) {
+            return null;
+        }
 
         // Description
         ret.setDescription(this.description);
@@ -61,52 +54,35 @@ public class TempAreaMarker
     // UPDATE
     // -------------------------------------------- //
 
-	public void update(AreaMarker marker)
+    public void update(AreaMarker marker) {
-	{
         // Corner Locations
-		if (!equals(marker, this.x, this.z))
+        if (!equals(marker, this.x, this.z)) {
-		{
             marker.setCornerLocations(this.x, this.z);
         }
 
         // Label
-		if (!marker.getLabel().equals(this.label))
+        if (!marker.getLabel().equals(this.label)) {
-		{
             marker.setLabel(this.label);
         }
 
         // Description
-		if (!marker.getDescription().equals( this.description))
+        if (!marker.getDescription().equals(this.description)) {
-		{
             marker.setDescription(this.description);
         }
 
         // Line Style
-		if
+        if (marker.getLineWeight() != this.lineWeight ||
-		(
+                    marker.getLineOpacity() != this.lineOpacity ||
-			marker.getLineWeight()!=this.lineWeight
+                    marker.getLineColor() != this.lineColor) {
-			||
-			marker.getLineOpacity()!=this.lineOpacity
-			||
-			marker.getLineColor()!=this.lineColor
-		)
-		{
             marker.setLineStyle(this.lineWeight, this.lineOpacity, this.lineColor);
         }
 
         // Fill Style
-		if
+        if ((marker.getFillOpacity() != this.fillOpacity) || (marker.getFillColor() != this.fillColor)) {
-		(
-			(marker.getFillOpacity()!=this.fillOpacity)
-			||
-			(marker.getFillColor()!=this.fillColor)
-		)
-		{
             marker.setFillStyle(this.fillOpacity, this.fillColor);
         }
         // Boost Flag
-		if (marker.getBoostFlag()!=this.boost)
+        if (marker.getBoostFlag() != this.boost) {
-		{
             marker.setBoostFlag(this.boost);
         }
     }
@@ -115,17 +91,23 @@ public class TempAreaMarker
     // UTIL
     // -------------------------------------------- //
 
-	public static boolean equals(AreaMarker marker, double x[], double z[])
+    public static boolean equals(AreaMarker marker, double x[], double z[]) {
-	{
         int length = marker.getCornerCount();
 
-		if (x.length != length) return false;
+        if (x.length != length) {
-		if (z.length != length) return false;
+            return false;
+        }
+        if (z.length != length) {
+            return false;
+        }
 
-		for (int i = 0; i < length; i++)
+        for (int i = 0; i < length; i++) {
-		{
+            if (marker.getCornerX(i) != x[i]) {
-			if (marker.getCornerX(i) != x[i]) return false;
+                return false;
-			if (marker.getCornerZ(i) != z[i]) return false;
+            }
+            if (marker.getCornerZ(i) != z[i]) {
+                return false;
+            }
         }
 
         return true;

src/main/java/com/massivecraft/factions/integration/dynmap/TempMarker.java

@@ -1,14 +1,12 @@
 package com.massivecraft.factions.integration.dynmap;
 
+import com.massivecraft.factions.Conf;
 import org.dynmap.markers.Marker;
 import org.dynmap.markers.MarkerAPI;
 import org.dynmap.markers.MarkerIcon;
 import org.dynmap.markers.MarkerSet;
 
-import com.massivecraft.factions.Conf;
+public class TempMarker {
-
-public class TempMarker
-{
     // -------------------------------------------- //
     // FIELDS
     // -------------------------------------------- //
@@ -25,20 +23,13 @@ public class TempMarker
     // CREATE
     // -------------------------------------------- //
 
-	public Marker create(MarkerAPI markerApi, MarkerSet markerset, String markerId)
+    public Marker create(MarkerAPI markerApi, MarkerSet markerset, String markerId) {
-	{
+        Marker ret = markerset.createMarker(markerId, this.label, this.world, this.x, this.y, this.z, getMarkerIcon(markerApi, this.iconName), false // not persistent
-		Marker ret = markerset.createMarker(
-			markerId,
-			this.label,
-			this.world,
-			this.x,
-			this.y,
-			this.z,
-			getMarkerIcon(markerApi, this.iconName),
-			false // not persistent
         );
 
-		if (ret == null) return null;
+        if (ret == null) {
+            return null;
+        }
 
         ret.setDescription(this.description);
 
@@ -49,31 +40,21 @@ public class TempMarker
     // UPDATE
     // -------------------------------------------- //
 
-	public void update(MarkerAPI markerApi, Marker marker)
+    public void update(MarkerAPI markerApi, Marker marker) {
-	{
+        if (!this.world.equals(marker.getWorld()) || this.x != marker.getX() || this.y != marker.getY() || this.z != marker.getZ()) {
-		if (!this.world.equals(marker.getWorld()) || this.x != marker.getX() || this.y != marker.getY() || this.z != marker.getZ())
+            marker.setLocation(this.world, this.x, this.y, this.z);
-		{
-			marker.setLocation(
-					this.world,
-					this.x,
-					this.y,
-					this.z
-			);
         }
 
-		if (!marker.getLabel().equals(this.label))
+        if (!marker.getLabel().equals(this.label)) {
-		{
             marker.setLabel(this.label);
         }
 
         MarkerIcon icon = getMarkerIcon(markerApi, this.iconName);
-		if (marker.getMarkerIcon()==null||marker.getMarkerIcon().equals(icon))
+        if (marker.getMarkerIcon() == null || marker.getMarkerIcon().equals(icon)) {
-		{
             marker.setMarkerIcon(icon);
         }
 
-		if (!marker.getDescription().equals(this.description))
+        if (!marker.getDescription().equals(this.description)) {
-		{
             marker.setDescription(this.description);
         }
     }
@@ -82,10 +63,11 @@ public class TempMarker
     // UTIL
     // -------------------------------------------- //
 
-	public static MarkerIcon getMarkerIcon(MarkerAPI markerApi, String name)
+    public static MarkerIcon getMarkerIcon(MarkerAPI markerApi, String name) {
-	{
         MarkerIcon ret = markerApi.getMarkerIcon(name);
-		if (ret == null) ret = markerApi.getMarkerIcon(Conf.DYNMAP_STYLE_HOME_MARKER);
+        if (ret == null) {
+            ret = markerApi.getMarkerIcon(Conf.DYNMAP_STYLE_HOME_MARKER);
+        }
         return ret;
     }
 

src/main/java/com/massivecraft/factions/integration/dynmap/TempMarkerSet.java

@@ -3,23 +3,22 @@ package com.massivecraft.factions.integration.dynmap;
 import org.dynmap.markers.MarkerAPI;
 import org.dynmap.markers.MarkerSet;
 
-public class TempMarkerSet
+public class TempMarkerSet {
-{
 
     public String label;
     public int minimumZoom;
     public int priority;
     public boolean hideByDefault;
 
-	public MarkerSet create(MarkerAPI markerApi, String id)
+    public MarkerSet create(MarkerAPI markerApi, String id) {
-	{
         MarkerSet ret = markerApi.createMarkerSet(id, this.label, null, false); // ("null, false" at the end means "all icons allowed, not perisistent")
 
-		if (ret == null) return null;
+        if (ret == null) {
+            return null;
+        }
 
         // Minimum Zoom
-		if (this.minimumZoom > 0)
+        if (this.minimumZoom > 0) {
-		{
             ret.setMinZoom(this.minimumZoom);
         }
 
@@ -32,29 +31,23 @@ public class TempMarkerSet
         return ret;
     }
 
-	public void update(MarkerSet markerset)
+    public void update(MarkerSet markerset) {
-	{
         // Name
-		if (!markerset.getMarkerSetLabel().equals(this.label))
+        if (!markerset.getMarkerSetLabel().equals(this.label)) {
-		{
             markerset.setMarkerSetLabel(this.label);
         }
 
-		if (this.minimumZoom > 0)
+        if (this.minimumZoom > 0) {
-		{
+            if (markerset.getMinZoom() != this.minimumZoom) {
-			if (markerset.getMinZoom()!=this.minimumZoom)
-			{
                 markerset.setMinZoom(this.minimumZoom);
             }
         }
 
-		if (markerset.getLayerPriority()!=this.priority)
+        if (markerset.getLayerPriority() != this.priority) {
-		{
             markerset.setLayerPriority(this.priority);
         }
 
-		if (markerset.getHideByDefault()!=this.hideByDefault)
+        if (markerset.getHideByDefault() != this.hideByDefault) {
-		{
             markerset.setHideByDefault(this.hideByDefault);
         }
     }

src/main/java/com/massivecraft/factions/listeners/FactionsBlockListener.java

@@ -101,7 +101,7 @@ public class FactionsBlockListener implements Listener {
         Faction otherFaction = Board.getInstance().getFactionAt(new FLocation(targetLoc));
 
         // Check if the piston is moving in a faction's territory. This disables pistons entirely in faction territory.
-        if(otherFaction.isNormal() && P.p.getConfig().getBoolean("disable-pistons-in-territory", false)) {
+        if (otherFaction.isNormal() && P.p.getConfig().getBoolean("disable-pistons-in-territory", false)) {
             event.setCancelled(true);
             return;
         }

src/main/java/com/massivecraft/factions/scoreboards/BufferedObjective.java

@@ -36,7 +36,8 @@ public class BufferedObjective {
         Method addEntryMethodLookup = null;
         try {
             addEntryMethodLookup = Team.class.getMethod("addEntry", String.class);
-        } catch (NoSuchMethodException ignored) {}
+        } catch (NoSuchMethodException ignored) {
+        }
 
         addEntryMethod = addEntryMethodLookup;
 
@@ -130,7 +131,8 @@ public class BufferedObjective {
 
                 try {
                     addEntryMethod.invoke(team, name);
-                } catch (ReflectiveOperationException ignored) {}
+                } catch (ReflectiveOperationException ignored) {
+                }
                 buffer.getScore(name).setScore(entry.getKey());
             } else {
                 buffer.getScore(entry.getValue()).setScore(entry.getKey());

src/main/java/com/massivecraft/factions/util/AutoLeaveProcessTask.java

@@ -2,7 +2,6 @@ package com.massivecraft.factions.util;
 
 import com.massivecraft.factions.*;
 import com.massivecraft.factions.struct.Role;
-
 import org.bukkit.scheduler.BukkitRunnable;
 
 import java.util.ArrayList;

src/main/java/com/massivecraft/factions/zcore/persist/MemoryBoard.java

@@ -11,7 +11,6 @@ import java.util.HashMap;
 import java.util.Iterator;
 import java.util.Map;
 import java.util.Map.Entry;
-import java.util.logging.Level;
 
 
 public abstract class MemoryBoard extends Board {
@@ -48,8 +47,8 @@ public abstract class MemoryBoard extends Board {
 
     public void removeAt(FLocation flocation) {
         Faction faction = getFactionAt(flocation);
-        for(LazyLocation loc : faction.getWarps().values()) {
+        for (LazyLocation loc : faction.getWarps().values()) {
-            if(flocation.isInChunk(loc.getLocation())) {
+            if (flocation.isInChunk(loc.getLocation())) {
                 faction.removeWarp(loc);
             }
         }

src/main/java/com/massivecraft/factions/zcore/persist/MemoryFaction.java

@@ -93,7 +93,7 @@ public abstract class MemoryFaction implements Faction, EconomyParticipator {
     }
 
     public boolean removeWarp(LazyLocation loc) {
-        if(warps.containsValue(loc)) {
+        if (warps.containsValue(loc)) {
             warps.remove(loc);
             return true;
         }