Upstream/Factions
1
0
Fork 0
mirror of https://github.com/MassiveCraft/Factions.git synced 2024-12-24 01:27:51 +01:00
Code Issues Projects Releases Wiki Activity

Added dynmap integration. Glory to Arstotzka! Addresses #109

Browse Source
This commit is contained in:
korikisulda 2014-12-05 05:04:00 +00:00 committed by eueln
parent b8f742a588
commit a1ab22554c
9 changed files with 1283 additions and 3 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

18
pom.xml
View File

@ -4,7 +4,7 @@
<groupId>com.massivecraft</groupId>
<artifactId>Factions</artifactId>
<version>1.6.9.5-U0.1.12</version>
<version>1.6.9.5-U0.1.13-SNAPSHOT</version>
<packaging>jar</packaging>
<name>Factions</name>
@ -110,6 +110,18 @@
<artifactId>fanciful</artifactId>
<version>0.2.1-SNAPSHOT</version>
</dependency>
<dependency>
<groupId>org.dynmap</groupId>
<artifactId>dynmap</artifactId>
<version>2.0</version>
<scope>provided</scope>
</dependency>
<dependency>
<groupId>com.google.guava</groupId>
<artifactId>guava</artifactId>
<version>10.0.1</version>
<scope>provided</scope>
</dependency>
<dependency>
<groupId>com.google.code.gson</groupId>
<artifactId>gson</artifactId>
@ -134,5 +146,9 @@
<id>maven.sk89q.com</id>
<url>http://maven.sk89q.com/repo/</url>
</repository>
<repository>
<id>repo.mikeprimm.com</id>
<url>http://repo.mikeprimm.com/</url>
</repository>
</repositories>
</project>

81
src/main/java/com/massivecraft/factions/Conf.java
View File

@ -1,5 +1,7 @@
package com.massivecraft.factions;
import com.google.common.collect.ImmutableMap;
import com.massivecraft.factions.integration.dynmap.DynmapStyle;
import org.bukkit.ChatColor;
import org.bukkit.Material;
import org.bukkit.entity.EntityType;
@ -246,6 +248,85 @@ public class Conf {
public static double econCostNeutral = 0.0;
public static double econCostNoBoom = 0.0;
// -------------------------------------------- //
// INTEGRATION: DYNMAP
// -------------------------------------------- //
// Should the dynmap intagration be used?
public static boolean dynmapUse = false;
// Name of the Factions layer
public static String dynmapLayerName = "Factions";
// Should the layer be visible per default
public static boolean dynmapLayerVisible = true;
// Ordering priority in layer menu (low goes before high - default is 0)
public static int dynmapLayerPriority = 2;
// (optional) set minimum zoom level before layer is visible (0 = default, always visible)
public static int dynmapLayerMinimumZoom = 0;
// Format for popup - substitute values for macros
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>";
// Enable the %money% macro. Only do this if you know your economy manager is thread-safe.
public static boolean dynmapDescriptionMoney = false;
// Allow players in faction to see one another on Dynmap (only relevant if Dynmap has 'player-info-protected' enabled)
public static boolean dynmapVisibilityByFaction = true;
// Optional setting to limit which regions to show.
// If empty all regions are shown.
// Specify Faction either by name or UUID.
// To show all regions on a given world, add 'world:<worldname>' to the list.
public static Set<String> dynmapVisibleFactions = new HashSet<String>();
// Optional setting to hide specific Factions.
// Specify Faction either by name or UUID.
// To hide all regions on a given world, add 'world:<worldname>' to the list.
public static Set<String> dynmapHiddenFactions = new HashSet<String>();
// Region Style
public static final transient String DYNMAP_STYLE_LINE_COLOR = "#00FF00";
public static final transient double DYNMAP_STYLE_LINE_OPACITY = 0.8D;
public static final transient int DYNMAP_STYLE_LINE_WEIGHT = 3;
public static final transient String DYNMAP_STYLE_FILL_COLOR = "#00FF00";
public static final transient double DYNMAP_STYLE_FILL_OPACITY = 0.35D;
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()
.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(
"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
public static boolean bankEnabled = true;
public static boolean bankMembersCanWithdraw = false; //Have to be at least moderator to withdraw or pay money to another faction

3
src/main/java/com/massivecraft/factions/P.java
View File

@ -7,6 +7,7 @@ import com.massivecraft.factions.cmd.FCmdRoot;
import com.massivecraft.factions.integration.Econ;
import com.massivecraft.factions.integration.Essentials;
import com.massivecraft.factions.integration.Worldguard;
import com.massivecraft.factions.integration.dynmap.EngineDynmap;
import com.massivecraft.factions.listeners.*;
import com.massivecraft.factions.struct.ChatMode;
import com.massivecraft.factions.util.*;
@ -107,6 +108,8 @@ public class P extends MPlugin {
Worldguard.init(this);
}
EngineDynmap.getInstance().init();
// start up task which runs the autoLeaveAfterDaysOfInactivity routine
startAutoLeaveTask(false);

67
src/main/java/com/massivecraft/factions/integration/dynmap/DynmapStyle.java Normal file
View File

@ -0,0 +1,67 @@
package com.massivecraft.factions.integration.dynmap;
import com.massivecraft.factions.Conf;
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 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 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 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 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; }
// 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 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; }
// -------------------------------------------- //
// UTIL
// -------------------------------------------- //
@SafeVarargs
public static <T> T coalesce(T... items)
{
for (T item : items)
{
if (item != null) return item;
}
return null;
}
public static int getColor(String string)
{
int ret = 0x00FF00;
try
{
ret = Integer.parseInt(string.substring(1), 16);
}
catch (NumberFormatException ignored) {}
return ret;
}
}

825
src/main/java/com/massivecraft/factions/integration/dynmap/EngineDynmap.java Normal file
View File

@ -0,0 +1,825 @@
package com.massivecraft.factions.integration.dynmap;
import com.massivecraft.factions.*;
import com.massivecraft.factions.integration.Econ;
import com.massivecraft.factions.struct.Role;
import com.massivecraft.factions.zcore.persist.MemoryBoard;
import org.bukkit.Bukkit;
import org.bukkit.ChatColor;
import org.bukkit.Location;
import org.bukkit.plugin.Plugin;
import org.dynmap.DynmapAPI;
import org.dynmap.markers.*;
import org.dynmap.utils.TileFlags;
import java.util.*;
import java.util.Map.Entry;
// This source code is a heavily modified version of mikeprimms plugin Dynmap-Factions.
public class EngineDynmap
{
// -------------------------------------------- //
// CONSTANTS
// -------------------------------------------- //
public final static int BLOCKS_PER_CHUNK = 16;
public final static String DYNMAP_INTEGRATION = "\u00A7dDynmap Integration: \u00A7e";
public final static String FACTIONS = "factions";
public final static String FACTIONS_ = FACTIONS + "_";
public final static String FACTIONS_MARKERSET = FACTIONS_ + "markerset";
public final static String FACTIONS_HOME = FACTIONS_ + "home";
public final static String FACTIONS_HOME_ = FACTIONS_HOME + "_";
public final static String FACTIONS_PLAYERSET = FACTIONS_ + "playerset";
public final static String FACTIONS_PLAYERSET_ = FACTIONS_PLAYERSET + "_";
// -------------------------------------------- //
// INSTANCE & CONSTRUCT
// -------------------------------------------- //
private static EngineDynmap i = new EngineDynmap();
public static EngineDynmap getInstance() { return i; }
private EngineDynmap() {}
public DynmapAPI dynmapApi;
public MarkerAPI markerApi;
public MarkerSet markerset;
public void init()
{
Plugin dynmap = Bukkit.getServer().getPluginManager().getPlugin("dynmap");
if (dynmap == null || !dynmap.isEnabled())
{
return;
}
// Should we even use dynmap?
if (!Conf.dynmapUse)
{
if (this.markerset != null)
{
this.markerset.deleteMarkerSet();
this.markerset = null;
}
return;
}
// Shedule non thread safe sync at the end!
Bukkit.getScheduler().scheduleSyncRepeatingTask(P.p, new Runnable()
{
@Override
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;
// createLayer() is thread safe but it makes use of fields set in updateCore() so we must have it after.
if (!updateLayer(createLayer())) return;
updateHomes(homes);
updateAreas(areas);
updatePlayersets(playerSets);
}
}, 100L, 100L);
}
// Thread Safe / Asynchronous: No
public boolean updateCore()
{
// Get DynmapAPI
this.dynmapApi = (DynmapAPI) Bukkit.getPluginManager().getPlugin("dynmap");
if (this.dynmapApi == null)
{
severe("Could not retrieve the DynmapAPI.");
return false;
}
// Get MarkerAPI
this.markerApi = this.dynmapApi.getMarkerAPI();
if (this.markerApi == null)
{
severe("Could not retrieve the MarkerAPI.");
return false;
}
return true;
}
// Thread Safe / Asynchronous: Yes
public TempMarkerSet createLayer()
{
TempMarkerSet ret = new TempMarkerSet();
ret.label = Conf.dynmapLayerName;
ret.minimumZoom = Conf.dynmapLayerMinimumZoom;
ret.priority = Conf.dynmapLayerPriority;
ret.hideByDefault = !Conf.dynmapLayerVisible;
return ret;
}
// Thread Safe / Asynchronous: No
public boolean updateLayer(TempMarkerSet temp)
{
this.markerset = this.markerApi.getMarkerSet(FACTIONS_MARKERSET);
if (this.markerset == null)
{
this.markerset = temp.create(this.markerApi, FACTIONS_MARKERSET);
if (this.markerset == null)
{
severe("Could not create the Faction Markerset/Layer");
return false;
}
}
else
{
temp.update(this.markerset);
}
return true;
}
// -------------------------------------------- //
// UPDATE: HOMES
// -------------------------------------------- //
// Thread Safe / Asynchronous: Yes
public Map<String, TempMarker> createHomes()
{
Map<String, TempMarker> ret = new HashMap<String, TempMarker>();
// Loop current factions
for (Faction faction : Factions.getInstance().getAllFactions())
{
Location ps = faction.getHome();
if (ps == null) continue;
DynmapStyle style = getStyle(faction);
String markerId = FACTIONS_HOME_ + faction.getId();
TempMarker temp = new TempMarker();
temp.label = ChatColor.stripColor(faction.getTag());
temp.world = ps.getWorld().toString();
temp.x = ps.getX();
temp.y = ps.getY();
temp.z = ps.getZ();
temp.iconName = style.getHomeMarker();
temp.description = getDescription(faction);
ret.put(markerId, temp);
}
return ret;
}
// Thread Safe / Asynchronous: No
// This method places out the faction home markers into the factions markerset.
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())
{
markers.put(marker.getMarkerID(), marker);
}
// Loop homes
for (Entry<String, TempMarker> entry : homes.entrySet())
{
String markerId = entry.getKey();
TempMarker temp = entry.getValue();
// Get Creative
// 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)
{
marker = temp.create(this.markerApi, this.markerset, markerId);
if (marker == null)
{
EngineDynmap.severe("Could not get/create the home marker " + markerId);
}
}
else
{
temp.update(this.markerApi, marker);
}
}
// Delete Deprecated Markers
// Only old markers should now be left
for (Marker marker : markers.values())
{
marker.deleteMarker();
}
}
// -------------------------------------------- //
// UPDATE: AREAS
// -------------------------------------------- //
// Thread Safe: YES
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()
{
// 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())
{
String world = entry.getKey().getWorldName();
Faction chunkOwner = Factions.getInstance().getFactionById(entry.getValue());
Map<Faction, Set<FLocation>> factionChunks = worldFactionChunks.get(world);
if (factionChunks == null)
{
factionChunks = new HashMap<Faction, Set<FLocation>>();
worldFactionChunks.put(world, factionChunks);
}
Set<FLocation> factionTerritory = factionChunks.get(chunkOwner);
if (factionTerritory == null){
factionTerritory = new HashSet<FLocation>();
factionChunks.put(chunkOwner, factionTerritory);
}
factionTerritory.add(entry.getKey());
}
return worldFactionChunks;
}
// Thread Safe: YES
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())
{
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())
{
Faction faction = entry1.getKey();
Set<FLocation> chunks = entry1.getValue();
Map<String, TempAreaMarker> worldFactionMarkers = createAreas(world, faction, chunks);
ret.putAll(worldFactionMarkers);
}
}
return ret;
}
// 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)
{
Map<String, TempAreaMarker> ret = new HashMap<String, TempAreaMarker>();
// If the faction is visible ...
if (!isVisible(faction, world)) return ret;
// ... and has any chunks ...
if (chunks.isEmpty()) return ret;
// Index of polygon for given faction
int markerIndex = 0;
// Create the info window
String description = getDescription(faction);
// Fetch Style
DynmapStyle style = this.getStyle(faction);
// Loop through chunks: set flags on chunk map
TileFlags allChunkFlags = new TileFlags();
LinkedList<FLocation> allChunks = new LinkedList<FLocation>();
for (FLocation chunk : chunks)
{
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)
{
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)
{
int chunkX = (int)chunk.getX();
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))
{
ourChunkFlags = new TileFlags(); // Create map for shape
ourChunks = new LinkedList<FLocation>();
floodFillTarget(allChunkFlags, ourChunkFlags, chunkX, chunkZ); // Copy shape
ourChunks.add(chunk); // Add it to our chunk list
minimumX = chunkX;
minimumZ = chunkZ;
}
// If shape found, and we're in it, add to our node list
else if (ourChunkFlags != null && ourChunkFlags.getFlag(chunkX, chunkZ))
{
ourChunks.add(chunk);
if (chunkX < minimumX)
{
minimumX = chunkX;
minimumZ = chunkZ;
}
else if (chunkX == minimumX && chunkZ < minimumZ)
{
minimumZ = chunkZ;
}
}
// Else, keep it in the list for the next polygon
else
{
if (newChunks == null) newChunks = new LinkedList<FLocation>();
newChunks.add(chunk);
}
}
// Replace list (null if no more to process)
allChunks = newChunks;
if (ourChunkFlags == null) continue;
// Trace outline of blocks - start from minx, minz going to x+
int initialX = minimumX;
int initialZ = minimumZ;
int currentX = minimumX;
int currentZ = minimumZ;
Direction direction = Direction.XPLUS;
ArrayList<int[]> linelist = new ArrayList<int[]>();
linelist.add(new int[]{ initialX, initialZ }); // Add start point
while ((currentX != initialX) || (currentZ != initialZ) || (direction != Direction.ZMINUS))
{
switch (direction)
{
case XPLUS: // Segment in X+ direction
if (!ourChunkFlags.getFlag(currentX + 1, currentZ))
{ // Right turn?
linelist.add(new int[]{ currentX + 1, currentZ }); // Finish line
direction = Direction.ZPLUS; // Change direction
}
else if (!ourChunkFlags.getFlag(currentX + 1, currentZ - 1))
{ // Straight?
currentX++;
}
else
{ // 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))
{ // Right turn?
linelist.add(new int[]{ currentX + 1, currentZ + 1 }); // Finish line
direction = Direction.XMINUS; // Change direction
}
else if (!ourChunkFlags.getFlag(currentX + 1, currentZ + 1))
{ // Straight?
currentZ++;
}
else
{ // 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))
{ // Right turn?
linelist.add(new int[]{ currentX, currentZ + 1 }); // Finish line
direction = Direction.ZMINUS; // Change direction
}
else if (!ourChunkFlags.getFlag(currentX - 1, currentZ + 1))
{ // Straight?
currentX--;
}
else
{ // 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))
{ // Right turn?
linelist.add(new int[]{ currentX, currentZ }); // Finish line
direction = Direction.XPLUS; // Change direction
}
else if (!ourChunkFlags.getFlag(currentX - 1, currentZ - 1))
{ // Straight?
currentZ--;
}
else
{ // Left turn
linelist.add(new int[] { currentX, currentZ }); // Finish line
direction = Direction.XMINUS;
currentX--;
currentZ--;
}
break;
}
}
int sz = linelist.size();
double[] x = new double[sz];
double[] z = new double[sz];
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;
}
// Build information for specific area
String markerId = FACTIONS_ + world + "__" + faction.getId() + "__" + markerIndex;
TempAreaMarker temp = new TempAreaMarker();
temp.label = faction.getTag();
temp.world = world;
temp.x = x;
temp.z = z;
temp.description = description;
temp.lineColor = style.getLineColor();
temp.lineOpacity = style.getLineOpacity();
temp.lineWeight = style.getLineWeight();
temp.fillColor = style.getFillColor();
temp.fillOpacity = style.getFillOpacity();
temp.boost = style.getBoost();
ret.put(markerId, temp);
markerIndex++;
}
return ret;
}
// Thread Safe: NO
public void updateAreas(Map<String, TempAreaMarker> areas)
{
// Map Current
Map<String, AreaMarker> markers = new HashMap<String, AreaMarker>();
for (AreaMarker marker : this.markerset.getAreaMarkers())
{
markers.put(marker.getMarkerID(), marker);
}
// Loop New
for (Entry<String, TempAreaMarker> entry : areas.entrySet())
{
String markerId = entry.getKey();
TempAreaMarker temp = entry.getValue();
// Get Creative
// 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)
{
marker = temp.create(this.markerset, markerId);
if (marker == null)
{
severe("Could not get/create the area marker " + markerId);
}
}
else
{
temp.update(marker);
}
}
// Only old/outdated should now be left. Delete them.
for (AreaMarker marker : markers.values())
{
marker.deleteMarker();
}
}
// -------------------------------------------- //
// UPDATE: PLAYERSET
// -------------------------------------------- //
// Thread Safe / Asynchronous: Yes
public String createPlayersetId(Faction faction)
{
if (faction == null) return null;
if (faction.isNone()) return null;
String factionId = faction.getId();
if (factionId == null) return null;
return FACTIONS_PLAYERSET_ + factionId;
}
// Thread Safe / Asynchronous: Yes
public Set<String> createPlayerset(Faction faction)
{
if (faction == null) return null;
if (faction.isNone()) return null;
Set<String> ret = new HashSet<String>();
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());
}
return ret;
}
// Thread Safe / Asynchronous: Yes
public Map<String, Set<String>> createPlayersets()
{
if (!Conf.dynmapVisibilityByFaction)
{
return null;
}
Map<String, Set<String>> ret = new HashMap<String, Set<String>>();
for (Faction faction : Factions.getInstance().getAllFactions())
{
String playersetId = createPlayersetId(faction);
if (playersetId == null) continue;
Set<String> playerIds = createPlayerset(faction);
if (playerIds == null) continue;
ret.put(playersetId, playerIds);
}
return ret;
}
// Thread Safe / Asynchronous: No
public void updatePlayersets(Map<String, Set<String>> playersets)
{
if (playersets == null)
{
return;
}
// Remove
for (PlayerSet set : this.markerApi.getPlayerSets())
{
if (!set.getSetID().startsWith(FACTIONS_PLAYERSET_)) continue;
// (Null means remove all)
if (playersets.containsKey(set.getSetID())) continue;
set.deleteSet();
}
// Add / Update
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(
setId, // id
true, // symmetric
playerIds, // players
false // persistent
);
if (set == null)
{
severe("Could not get/create the player set " + setId);
continue;
}
// Set Content
set.setPlayers(playerIds);
}
}
// -------------------------------------------- //
// UTIL & SHARED
// -------------------------------------------- //
// Thread Safe / Asynchronous: Yes
private String getDescription(Faction faction)
{
String ret = "<div class=\"regioninfo\">" + Conf.dynmapDescription + "</div>";
// Name
String name = faction.getTag();
name = ChatColor.stripColor(name);
name = escapeHtml(name);
ret = ret.replace("%name%", name);
// Description
String description = faction.getDescription();
description = ChatColor.stripColor(description);
description = escapeHtml(description);
ret = ret.replace("%description%", description);
// Money
String money = "unavailable";
if (Conf.bankEnabled && Conf.dynmapDescriptionMoney)
{
money = String.format("%.2f", Econ.getBalance(faction.getAccountId()));
}
ret = ret.replace("%money%", money);
// Players
Set<FPlayer> playersList = faction.getFPlayers();
String playersCount = String.valueOf(playersList.size());
String players = getHtmlPlayerString(playersList);
FPlayer playersLeaderObject = faction.getFPlayerAdmin();
String playersLeader = getHtmlPlayerName(playersLeaderObject);
ArrayList<FPlayer> playersAdminsList = faction.getFPlayersWhereRole(Role.ADMIN);
String playersAdminsCount = String.valueOf(playersAdminsList.size());
String playersAdmins = getHtmlPlayerString(playersAdminsList);
ArrayList<FPlayer> playersModeratorsList = faction.getFPlayersWhereRole(Role.MODERATOR);
String playersModeratorsCount = String.valueOf(playersModeratorsList.size());
String playersModerators = getHtmlPlayerString(playersModeratorsList);
ArrayList<FPlayer> playersNormalsList = faction.getFPlayersWhereRole(Role.NORMAL);
String playersNormalsCount = String.valueOf(playersNormalsList.size());
String playersNormals = getHtmlPlayerString(playersNormalsList);
ret = ret.replace("%players%", players);
ret = ret.replace("%players.count%", playersCount);
ret = ret.replace("%players.leader%", playersLeader);
ret = ret.replace("%players.admins%", playersAdmins);
ret = ret.replace("%players.admins.count%", playersAdminsCount);
ret = ret.replace("%players.moderators%", playersModerators);
ret = ret.replace("%players.moderators.count%", playersModeratorsCount);
ret = ret.replace("%players.normals%", playersNormals);
ret = ret.replace("%players.normals.count%", playersNormalsCount);
return ret;
}
public static String getHtmlPlayerString(Collection<FPlayer> playersOfficersList)
{
String ret = "";
for (FPlayer fplayer : playersOfficersList)
{
if (ret.length() > 0) ret += ", ";
ret += getHtmlPlayerName(fplayer);
}
return ret;
}
public static String getHtmlPlayerName(FPlayer fplayer)
{
if (fplayer == null) return "none";
return escapeHtml(fplayer.getName());
}
public static String escapeHtml(String string)
{
StringBuilder out = new StringBuilder(Math.max(16, string.length()));
for (int i = 0; i < string.length(); i++)
{
char c = string.charAt(i);
if (c > 127 || c == '"' || c == '<' || c == '>' || c == '&')
{
out.append("&#");
out.append((int) c);
out.append(';');
}
else
{
out.append(c);
}
}
return out.toString();
}
// Thread Safe / Asynchronous: Yes
private boolean isVisible(Faction faction, String world)
{
if (faction == null) return false;
final String factionId = faction.getId();
if (factionId == null) return false;
final String factionName = faction.getTag();
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))
{
return false;
}
if (hidden.contains(factionId) || hidden.contains(factionName) || hidden.contains("world:" + world))
{
return false;
}
return true;
}
// Thread Safe / Asynchronous: Yes
public DynmapStyle getStyle(Faction faction)
{
DynmapStyle ret;
ret = Conf.dynmapFactionStyles.get(faction.getId());
if (ret != null) return ret;
ret = Conf.dynmapFactionStyles.get(faction.getTag());
if (ret != null) return ret;
return Conf.dynmapDefaultStyle;
}
// Thread Safe / Asynchronous: Yes
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)
{
String message = DYNMAP_INTEGRATION + ChatColor.RED.toString() + msg;
System.out.println(message);
}
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)
{
int cnt = 0;
ArrayDeque<int[]> stack = new ArrayDeque<int[]>();
stack.push(new int[] { x, y });
while (!stack.isEmpty())
{
int[] nxt = stack.pop();
x = nxt[0];
y = nxt[1];
if (source.getFlag(x, y))
{ // 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)) 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;
}
}

134
src/main/java/com/massivecraft/factions/integration/dynmap/TempAreaMarker.java Normal file
View File

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

92
src/main/java/com/massivecraft/factions/integration/dynmap/TempMarker.java Normal file
View File

@ -0,0 +1,92 @@
package com.massivecraft.factions.integration.dynmap;
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
{
// -------------------------------------------- //
// FIELDS
// -------------------------------------------- //
public String label;
public String world;
public double x;
public double y;
public double z;
public String iconName;
public String description;
// -------------------------------------------- //
// CREATE
// -------------------------------------------- //
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
);
if (ret == null) return null;
ret.setDescription(this.description);
return ret;
}
// -------------------------------------------- //
// UPDATE
// -------------------------------------------- //
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())
{
marker.setLocation(
this.world,
this.x,
this.y,
this.z
);
}
if (!marker.getLabel().equals(this.label))
{
marker.setLabel(this.label);
}
MarkerIcon icon = getMarkerIcon(markerApi, this.iconName);
if (marker.getMarkerIcon()==null||marker.getMarkerIcon().equals(icon))
{
marker.setMarkerIcon(icon);
}
if (!marker.getDescription().equals(this.description))
{
marker.setDescription(this.description);
}
}
// -------------------------------------------- //
// UTIL
// -------------------------------------------- //
public static MarkerIcon getMarkerIcon(MarkerAPI markerApi, String name)
{
MarkerIcon ret = markerApi.getMarkerIcon(name);
if (ret == null) ret = markerApi.getMarkerIcon(Conf.DYNMAP_STYLE_HOME_MARKER);
return ret;
}
}

62
src/main/java/com/massivecraft/factions/integration/dynmap/TempMarkerSet.java Normal file
View File

@ -0,0 +1,62 @@
package com.massivecraft.factions.integration.dynmap;
import org.dynmap.markers.MarkerAPI;
import org.dynmap.markers.MarkerSet;
public class TempMarkerSet
{
public String label;
public int minimumZoom;
public int priority;
public boolean hideByDefault;
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;
// Minimum Zoom
if (this.minimumZoom > 0)
{
ret.setMinZoom(this.minimumZoom);
}
// Priority
ret.setLayerPriority(this.priority);
// Hide by Default
ret.setHideByDefault(this.hideByDefault);
return ret;
}
public void update(MarkerSet markerset)
{
// Name
if (!markerset.getMarkerSetLabel().equals(this.label))
{
markerset.setMarkerSetLabel(this.label);
}
if (this.minimumZoom > 0)
{
if (markerset.getMinZoom()!=this.minimumZoom)
{
markerset.setMinZoom(this.minimumZoom);
}
}
if (markerset.getLayerPriority()!=this.priority)
{
markerset.setLayerPriority(this.priority);
}
if (markerset.getHideByDefault()!=this.hideByDefault)
{
markerset.setHideByDefault(this.hideByDefault);
}
}
}

4
src/main/resources/plugin.yml
View File

@ -2,7 +2,7 @@ name: Factions
version: ${project.version}
main: com.massivecraft.factions.P
authors: [Olof Larsson, Brett Flannigan, drtshock]
softdepend: [PermissionsEx, Permissions, Essentials, EssentialsChat, HeroChat, iChat, LocalAreaChat, LWC, nChat, ChatManager, CAPI, AuthMe, Vault, Spout, WorldEdit, WorldGuard, AuthDB, CaptureThePoints, CombatTag]
softdepend: [PermissionsEx, Permissions, Essentials, EssentialsChat, HeroChat, iChat, LocalAreaChat, LWC, nChat, ChatManager, CAPI, AuthMe, Vault, Spout, WorldEdit, WorldGuard, AuthDB, CaptureThePoints, CombatTag, Dynmap]
commands:
factions:
description: Reference command for Factions.
@ -240,4 +240,4 @@ permissions:
factions.warp:
description: access your faction warps
factions.modifypower:
description: modify other player's power
description: modify other player's power