From 1675a7e0a18e6a079b9a2ef0dd96c85668b46444 Mon Sep 17 00:00:00 2001 From: Jordan Atwood Date: Sun, 17 Feb 2019 19:26:56 -0800 Subject: [PATCH 1/5] worldpoint: Add static fromRegion method --- .../main/java/net/runelite/api/coords/WorldPoint.java | 11 +++++++++++ .../plugins/groundmarkers/GroundMarkerPlugin.java | 7 +------ 2 files changed, 12 insertions(+), 6 deletions(-) diff --git a/runelite-api/src/main/java/net/runelite/api/coords/WorldPoint.java b/runelite-api/src/main/java/net/runelite/api/coords/WorldPoint.java index a0a23e6674..e1ab0b0cac 100644 --- a/runelite-api/src/main/java/net/runelite/api/coords/WorldPoint.java +++ b/runelite-api/src/main/java/net/runelite/api/coords/WorldPoint.java @@ -326,4 +326,15 @@ public class WorldPoint { return ((x >> 6) << 8) | (y >> 6); } + + /** + * Converts the passed region ID and coordinates to a world coordinate + */ + public static WorldPoint fromRegion(int regionId, int regionX, int regionY, int plane) + { + return new WorldPoint( + ((regionId >>> 8) << 6) + regionX, + ((regionId & 0xff) << 6) + regionY, + plane); + } } diff --git a/runelite-client/src/main/java/net/runelite/client/plugins/groundmarkers/GroundMarkerPlugin.java b/runelite-client/src/main/java/net/runelite/client/plugins/groundmarkers/GroundMarkerPlugin.java index 2cb7ebf1c2..db848c30f5 100644 --- a/runelite-client/src/main/java/net/runelite/client/plugins/groundmarkers/GroundMarkerPlugin.java +++ b/runelite-client/src/main/java/net/runelite/client/plugins/groundmarkers/GroundMarkerPlugin.java @@ -163,12 +163,7 @@ public class GroundMarkerPlugin extends Plugin int regionY = point.getRegionY(); int z = point.getZ(); - // world point of the tile marker - return new WorldPoint( - ((regionId >>> 8) << 6) + regionX, - ((regionId & 0xff) << 6) + regionY, - z - ); + return WorldPoint.fromRegion(regionId, regionX, regionY, z); }) .flatMap(wp -> WorldPoint.toLocalInstance(client, wp).stream()) .collect(Collectors.toList()); From 39bbf2f259517ce5760210231a9fb9308bccd688 Mon Sep 17 00:00:00 2001 From: Jordan Atwood Date: Mon, 18 Feb 2019 19:11:24 -0800 Subject: [PATCH 2/5] worldpoint: Add getRegionX() and getRegionY() --- .../net/runelite/api/coords/WorldPoint.java | 21 +++++++++++++++++++ .../groundmarkers/GroundMarkerPlugin.java | 2 +- 2 files changed, 22 insertions(+), 1 deletion(-) diff --git a/runelite-api/src/main/java/net/runelite/api/coords/WorldPoint.java b/runelite-api/src/main/java/net/runelite/api/coords/WorldPoint.java index e1ab0b0cac..a6db435a2b 100644 --- a/runelite-api/src/main/java/net/runelite/api/coords/WorldPoint.java +++ b/runelite-api/src/main/java/net/runelite/api/coords/WorldPoint.java @@ -337,4 +337,25 @@ public class WorldPoint ((regionId & 0xff) << 6) + regionY, plane); } + + /** + * Gets the X-axis coordinate of the region coordinate + */ + public int getRegionX() + { + return getRegionOffset(x); + } + + /** + * Gets the Y-axis coordinate of the region coordinate + */ + public int getRegionY() + { + return getRegionOffset(y); + } + + private static int getRegionOffset(final int position) + { + return position & 0x3f; + } } diff --git a/runelite-client/src/main/java/net/runelite/client/plugins/groundmarkers/GroundMarkerPlugin.java b/runelite-client/src/main/java/net/runelite/client/plugins/groundmarkers/GroundMarkerPlugin.java index db848c30f5..71a21e1c7f 100644 --- a/runelite-client/src/main/java/net/runelite/client/plugins/groundmarkers/GroundMarkerPlugin.java +++ b/runelite-client/src/main/java/net/runelite/client/plugins/groundmarkers/GroundMarkerPlugin.java @@ -249,7 +249,7 @@ public class GroundMarkerPlugin extends Plugin WorldPoint worldPoint = WorldPoint.fromLocalInstance(client, localPoint); int regionId = worldPoint.getRegionID(); - GroundMarkerPoint point = new GroundMarkerPoint(regionId, worldPoint.getX() & 0x3f, worldPoint.getY() & 0x3f, client.getPlane()); + GroundMarkerPoint point = new GroundMarkerPoint(regionId, worldPoint.getRegionX(), worldPoint.getRegionY(), client.getPlane()); log.debug("Updating point: {} - {}", point, worldPoint); List points = new ArrayList<>(getPoints(regionId)); From 285926924b8d29f7116a4bcf69b503618470d4a3 Mon Sep 17 00:00:00 2001 From: Jordan Atwood Date: Sat, 16 Feb 2019 23:35:46 -0800 Subject: [PATCH 3/5] ground markers plugin: Clean up legacy code This includes various code quality improvements such as stronger access control, enforcing newlines at EOF, naming magic numbers and strings, and utilizing higher efficiency methods and class constructors. --- .../groundmarkers/GroundMarkerConfig.java | 1 - .../GroundMarkerInputListener.java | 2 +- .../groundmarkers/GroundMarkerOverlay.java | 6 +++-- .../groundmarkers/GroundMarkerPlugin.java | 26 ++++++++++--------- .../groundmarkers/GroundMarkerPoint.java | 5 ++-- 5 files changed, 21 insertions(+), 19 deletions(-) diff --git a/runelite-client/src/main/java/net/runelite/client/plugins/groundmarkers/GroundMarkerConfig.java b/runelite-client/src/main/java/net/runelite/client/plugins/groundmarkers/GroundMarkerConfig.java index d77f3ab9f5..394ffcf81b 100644 --- a/runelite-client/src/main/java/net/runelite/client/plugins/groundmarkers/GroundMarkerConfig.java +++ b/runelite-client/src/main/java/net/runelite/client/plugins/groundmarkers/GroundMarkerConfig.java @@ -23,7 +23,6 @@ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. */ - package net.runelite.client.plugins.groundmarkers; import java.awt.Color; diff --git a/runelite-client/src/main/java/net/runelite/client/plugins/groundmarkers/GroundMarkerInputListener.java b/runelite-client/src/main/java/net/runelite/client/plugins/groundmarkers/GroundMarkerInputListener.java index 3b87dd1802..a097d47d29 100644 --- a/runelite-client/src/main/java/net/runelite/client/plugins/groundmarkers/GroundMarkerInputListener.java +++ b/runelite-client/src/main/java/net/runelite/client/plugins/groundmarkers/GroundMarkerInputListener.java @@ -64,4 +64,4 @@ public class GroundMarkerInputListener implements KeyListener plugin.setHotKeyPressed(false); } } -} \ No newline at end of file +} diff --git a/runelite-client/src/main/java/net/runelite/client/plugins/groundmarkers/GroundMarkerOverlay.java b/runelite-client/src/main/java/net/runelite/client/plugins/groundmarkers/GroundMarkerOverlay.java index ccd6fd7483..d2b64a81d0 100644 --- a/runelite-client/src/main/java/net/runelite/client/plugins/groundmarkers/GroundMarkerOverlay.java +++ b/runelite-client/src/main/java/net/runelite/client/plugins/groundmarkers/GroundMarkerOverlay.java @@ -42,6 +42,8 @@ import net.runelite.client.ui.overlay.OverlayUtil; public class GroundMarkerOverlay extends Overlay { + private static final int MAX_DRAW_DISTANCE = 32; + private final Client client; private final GroundMarkerConfig config; private final GroundMarkerPlugin plugin; @@ -78,7 +80,7 @@ public class GroundMarkerOverlay extends Overlay { WorldPoint playerLocation = client.getLocalPlayer().getWorldLocation(); - if (point.distanceTo(playerLocation) >= 32) + if (point.distanceTo(playerLocation) >= MAX_DRAW_DISTANCE) { return; } @@ -97,4 +99,4 @@ public class GroundMarkerOverlay extends Overlay OverlayUtil.renderPolygon(graphics, poly, config.markerColor()); } -} \ No newline at end of file +} diff --git a/runelite-client/src/main/java/net/runelite/client/plugins/groundmarkers/GroundMarkerPlugin.java b/runelite-client/src/main/java/net/runelite/client/plugins/groundmarkers/GroundMarkerPlugin.java index 71a21e1c7f..a6978c32ae 100644 --- a/runelite-client/src/main/java/net/runelite/client/plugins/groundmarkers/GroundMarkerPlugin.java +++ b/runelite-client/src/main/java/net/runelite/client/plugins/groundmarkers/GroundMarkerPlugin.java @@ -69,8 +69,9 @@ public class GroundMarkerPlugin extends Plugin private static final String CONFIG_GROUP = "groundMarker"; private static final String MARK = "Mark tile"; private static final String WALK_HERE = "Walk here"; + private static final String REGION_PREFIX = "region_"; - private static final Gson gson = new Gson(); + private static final Gson GSON = new Gson(); @Getter(AccessLevel.PACKAGE) @Setter(AccessLevel.PACKAGE) @@ -101,24 +102,26 @@ public class GroundMarkerPlugin extends Plugin { if (points == null || points.isEmpty()) { - configManager.unsetConfiguration(CONFIG_GROUP, "region_" + regionId); + configManager.unsetConfiguration(CONFIG_GROUP, REGION_PREFIX + regionId); return; } - String json = gson.toJson(points); - configManager.setConfiguration(CONFIG_GROUP, "region_" + regionId, json); + String json = GSON.toJson(points); + configManager.setConfiguration(CONFIG_GROUP, REGION_PREFIX + regionId, json); } private Collection getPoints(int regionId) { - String json = configManager.getConfiguration(CONFIG_GROUP, "region_" + regionId); + String json = configManager.getConfiguration(CONFIG_GROUP, REGION_PREFIX + regionId); if (Strings.isNullOrEmpty(json)) { - return Collections.EMPTY_LIST; + return Collections.emptyList(); } - return gson.fromJson(json, new TypeToken>() - { - }.getType()); + return GSON.fromJson(json, new GroundMarkerListTypeToken().getType()); + } + + private static class GroundMarkerListTypeToken extends TypeToken> + { } @Provides @@ -238,8 +241,7 @@ public class GroundMarkerPlugin extends Plugin keyManager.unregisterKeyListener(inputListener); } - - protected void markTile(LocalPoint localPoint) + private void markTile(LocalPoint localPoint) { if (localPoint == null) { @@ -266,4 +268,4 @@ public class GroundMarkerPlugin extends Plugin loadPoints(); } -} \ No newline at end of file +} diff --git a/runelite-client/src/main/java/net/runelite/client/plugins/groundmarkers/GroundMarkerPoint.java b/runelite-client/src/main/java/net/runelite/client/plugins/groundmarkers/GroundMarkerPoint.java index b31db32222..396a2217cb 100644 --- a/runelite-client/src/main/java/net/runelite/client/plugins/groundmarkers/GroundMarkerPoint.java +++ b/runelite-client/src/main/java/net/runelite/client/plugins/groundmarkers/GroundMarkerPoint.java @@ -23,16 +23,15 @@ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. */ - package net.runelite.client.plugins.groundmarkers; import lombok.Value; @Value -public class GroundMarkerPoint +class GroundMarkerPoint { private int regionId; private int regionX; private int regionY; private int z; -} \ No newline at end of file +} From 36fdb620fc3a0a6d2ccc98c1cdb39978ef2d8192 Mon Sep 17 00:00:00 2001 From: Jordan Atwood Date: Sun, 17 Feb 2019 19:43:49 -0800 Subject: [PATCH 4/5] ground markers: Fix startup and shutdown bug When logging in to the game with the plugin disabled, enabling it will not cause points to be filled, as the game state trigger will not be reached. This commit properly loads points on plugin startup and clears them on shutdown. --- .../client/plugins/groundmarkers/GroundMarkerPlugin.java | 8 ++++++++ 1 file changed, 8 insertions(+) diff --git a/runelite-client/src/main/java/net/runelite/client/plugins/groundmarkers/GroundMarkerPlugin.java b/runelite-client/src/main/java/net/runelite/client/plugins/groundmarkers/GroundMarkerPlugin.java index a6978c32ae..37d4f1829f 100644 --- a/runelite-client/src/main/java/net/runelite/client/plugins/groundmarkers/GroundMarkerPlugin.java +++ b/runelite-client/src/main/java/net/runelite/client/plugins/groundmarkers/GroundMarkerPlugin.java @@ -135,6 +135,12 @@ public class GroundMarkerPlugin extends Plugin points.clear(); int[] regions = client.getMapRegions(); + + if (regions == null) + { + return; + } + for (int regionId : regions) { // load points for region @@ -232,6 +238,7 @@ public class GroundMarkerPlugin extends Plugin { overlayManager.add(overlay); keyManager.registerKeyListener(inputListener); + loadPoints(); } @Override @@ -239,6 +246,7 @@ public class GroundMarkerPlugin extends Plugin { overlayManager.remove(overlay); keyManager.unregisterKeyListener(inputListener); + points.clear(); } private void markTile(LocalPoint localPoint) From ad65a9aad912c3b812abd688ee39a3675b3b49ba Mon Sep 17 00:00:00 2001 From: Jordan Atwood Date: Sun, 17 Feb 2019 19:28:16 -0800 Subject: [PATCH 5/5] ground markers: Allow different colored markers This adds a color indicator per marker, saved to config, allowing multiple markers to be different colors. In addition, a configuration option is added to switch between per-tile color display or current configured color display. (that is, new or existing behavior) This change will set a color in config for old markers with null colors when those markers are loaded. Fixes runelite/runelite#3395 --- .../groundmarkers/ColorTileMarker.java | 45 ++++++++ .../groundmarkers/GroundMarkerConfig.java | 10 ++ .../groundmarkers/GroundMarkerOverlay.java | 16 +-- .../groundmarkers/GroundMarkerPlugin.java | 107 +++++++++++++----- .../groundmarkers/GroundMarkerPoint.java | 5 + 5 files changed, 149 insertions(+), 34 deletions(-) create mode 100644 runelite-client/src/main/java/net/runelite/client/plugins/groundmarkers/ColorTileMarker.java diff --git a/runelite-client/src/main/java/net/runelite/client/plugins/groundmarkers/ColorTileMarker.java b/runelite-client/src/main/java/net/runelite/client/plugins/groundmarkers/ColorTileMarker.java new file mode 100644 index 0000000000..8f45e9489a --- /dev/null +++ b/runelite-client/src/main/java/net/runelite/client/plugins/groundmarkers/ColorTileMarker.java @@ -0,0 +1,45 @@ +/* + * Copyright (c) 2019, Jordan Atwood + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are met: + * + * 1. Redistributions of source code must retain the above copyright notice, this + * list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright notice, + * this list of conditions and the following disclaimer in the documentation + * and/or other materials provided with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR + * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; + * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND + * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS + * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ +package net.runelite.client.plugins.groundmarkers; + +import java.awt.Color; +import lombok.Value; +import net.runelite.api.coords.WorldPoint; + +/** + * Used to denote marked tiles and their colors. + * Note: This is not used for serialization of ground markers; see {@link GroundMarkerPoint} + */ +@Value +class ColorTileMarker +{ + private WorldPoint worldPoint; + private Color color; + + boolean sameTile(final ColorTileMarker other) + { + return worldPoint.equals(other.getWorldPoint()); + } +} diff --git a/runelite-client/src/main/java/net/runelite/client/plugins/groundmarkers/GroundMarkerConfig.java b/runelite-client/src/main/java/net/runelite/client/plugins/groundmarkers/GroundMarkerConfig.java index 394ffcf81b..ba8cb98e14 100644 --- a/runelite-client/src/main/java/net/runelite/client/plugins/groundmarkers/GroundMarkerConfig.java +++ b/runelite-client/src/main/java/net/runelite/client/plugins/groundmarkers/GroundMarkerConfig.java @@ -44,4 +44,14 @@ public interface GroundMarkerConfig extends Config { return Color.YELLOW; } + + @ConfigItem( + keyName = "rememberTileColors", + name = "Remember color per tile", + description = "Color tiles using the color from time of placement" + ) + default boolean rememberTileColors() + { + return false; + } } diff --git a/runelite-client/src/main/java/net/runelite/client/plugins/groundmarkers/GroundMarkerOverlay.java b/runelite-client/src/main/java/net/runelite/client/plugins/groundmarkers/GroundMarkerOverlay.java index d2b64a81d0..153fe67154 100644 --- a/runelite-client/src/main/java/net/runelite/client/plugins/groundmarkers/GroundMarkerOverlay.java +++ b/runelite-client/src/main/java/net/runelite/client/plugins/groundmarkers/GroundMarkerOverlay.java @@ -25,10 +25,11 @@ */ package net.runelite.client.plugins.groundmarkers; +import java.awt.Color; import java.awt.Dimension; import java.awt.Graphics2D; import java.awt.Polygon; -import java.util.List; +import java.util.Collection; import javax.inject.Inject; import net.runelite.api.Client; import net.runelite.api.Perspective; @@ -62,21 +63,22 @@ public class GroundMarkerOverlay extends Overlay @Override public Dimension render(Graphics2D graphics) { - List points = plugin.getPoints(); - for (WorldPoint point : points) + final Collection points = plugin.getPoints(); + for (final ColorTileMarker point : points) { - if (point.getPlane() != client.getPlane()) + if (point.getWorldPoint().getPlane() != client.getPlane()) { continue; } - drawTile(graphics, point); + final Color tileColor = config.rememberTileColors() ? point.getColor() : config.markerColor(); + drawTile(graphics, point.getWorldPoint(), tileColor); } return null; } - private void drawTile(Graphics2D graphics, WorldPoint point) + private void drawTile(Graphics2D graphics, WorldPoint point, Color color) { WorldPoint playerLocation = client.getLocalPlayer().getWorldLocation(); @@ -97,6 +99,6 @@ public class GroundMarkerOverlay extends Overlay return; } - OverlayUtil.renderPolygon(graphics, poly, config.markerColor()); + OverlayUtil.renderPolygon(graphics, poly, color); } } diff --git a/runelite-client/src/main/java/net/runelite/client/plugins/groundmarkers/GroundMarkerPlugin.java b/runelite-client/src/main/java/net/runelite/client/plugins/groundmarkers/GroundMarkerPlugin.java index 37d4f1829f..4aa613af7c 100644 --- a/runelite-client/src/main/java/net/runelite/client/plugins/groundmarkers/GroundMarkerPlugin.java +++ b/runelite-client/src/main/java/net/runelite/client/plugins/groundmarkers/GroundMarkerPlugin.java @@ -29,11 +29,12 @@ import com.google.common.base.Strings; import com.google.gson.Gson; import com.google.gson.reflect.TypeToken; import com.google.inject.Provides; -import java.util.ArrayList; import java.util.Arrays; import java.util.Collection; import java.util.Collections; +import java.util.HashSet; import java.util.List; +import java.util.Set; import java.util.stream.Collectors; import javax.inject.Inject; import lombok.AccessLevel; @@ -78,11 +79,14 @@ public class GroundMarkerPlugin extends Plugin private boolean hotKeyPressed; @Getter(AccessLevel.PACKAGE) - private final List points = new ArrayList<>(); + private final Set points = new HashSet<>(); @Inject private Client client; + @Inject + private GroundMarkerConfig config; + @Inject private GroundMarkerInputListener inputListener; @@ -98,6 +102,11 @@ public class GroundMarkerPlugin extends Plugin @Inject private KeyManager keyManager; + private void saveColorTileMarkers(int regionId, Collection points) + { + savePoints(regionId, translateFromColorTileMarker(points)); + } + private void savePoints(int regionId, Collection points) { if (points == null || points.isEmpty()) @@ -117,7 +126,25 @@ public class GroundMarkerPlugin extends Plugin { return Collections.emptyList(); } - return GSON.fromJson(json, new GroundMarkerListTypeToken().getType()); + + Collection configPoints = GSON.fromJson(json, new GroundMarkerListTypeToken().getType()); + + if (configPoints.stream().anyMatch(point -> point.getColor() == null)) + { + log.debug("Adding color to old ground marker(s) of region " + regionId); + configPoints = configPoints.stream() + .map(point -> + { + if (point.getColor() != null) + { + return point; + } + return new GroundMarkerPoint(point.getRegionId(), point.getRegionX(), point.getRegionY(), point.getZ(), config.markerColor()); + }) + .collect(Collectors.toSet()); + savePoints(regionId, configPoints); + } + return configPoints; } private static class GroundMarkerListTypeToken extends TypeToken> @@ -145,37 +172,58 @@ public class GroundMarkerPlugin extends Plugin { // load points for region log.debug("Loading points for region {}", regionId); - Collection regionPoints = getPoints(regionId); - Collection worldPoints = translateToWorld(regionPoints); - points.addAll(worldPoints); + final Collection configPoints = getPoints(regionId); + final Collection colorTileMarkers = translateToColorTileMarker(configPoints); + points.addAll(colorTileMarkers); } } /** - * Translate a collection of ground marker points to world points, accounting for instances + * Translate a collection of ground marker points to color tile markers, accounting for instances * - * @param points - * @return + * @param points {@link GroundMarkerPoint}s to be converted to {@link ColorTileMarker}s + * @return A collection of color tile markers, converted from the passed ground marker points, accounting for local + * instance points. See {@link WorldPoint#toLocalInstance(Client, WorldPoint)} */ - private Collection translateToWorld(Collection points) + private Collection translateToColorTileMarker(Collection points) { - if (points.isEmpty()) + if (points == null || points.isEmpty()) { - return Collections.EMPTY_LIST; + return Collections.emptyList(); + } + + return points.stream() + .map(point -> new ColorTileMarker( + WorldPoint.fromRegion(point.getRegionId(), point.getRegionX(), point.getRegionY(), point.getZ()), + point.getColor())) + .flatMap(colorTile -> + { + final Collection localWorldPoints = WorldPoint.toLocalInstance(client, colorTile.getWorldPoint()); + return localWorldPoints.stream().map(wp -> new ColorTileMarker(wp, colorTile.getColor())); + }) + .collect(Collectors.toSet()); + } + + /** + * Translate a collection of color tile markers to a set of ground marker points + * + * @param points {@link ColorTileMarker}s to be converted to {@link GroundMarkerPoint}s + * @return A set of ground marker points, converted from the passed color tile markers + */ + private static Set translateFromColorTileMarker(Collection points) + { + if (points == null || points.isEmpty()) + { + return Collections.emptySet(); } return points.stream() .map(point -> { - int regionId = point.getRegionId(); - int regionX = point.getRegionX(); - int regionY = point.getRegionY(); - int z = point.getZ(); - - return WorldPoint.fromRegion(regionId, regionX, regionY, z); + final WorldPoint worldPoint = point.getWorldPoint(); + return new GroundMarkerPoint(worldPoint.getRegionID(), worldPoint.getRegionX(), worldPoint.getRegionY(), worldPoint.getPlane(), point.getColor()); }) - .flatMap(wp -> WorldPoint.toLocalInstance(client, wp).stream()) - .collect(Collectors.toList()); + .collect(Collectors.toSet()); } @Subscribe @@ -256,23 +304,28 @@ public class GroundMarkerPlugin extends Plugin return; } - WorldPoint worldPoint = WorldPoint.fromLocalInstance(client, localPoint); - - int regionId = worldPoint.getRegionID(); - GroundMarkerPoint point = new GroundMarkerPoint(regionId, worldPoint.getRegionX(), worldPoint.getRegionY(), client.getPlane()); + final WorldPoint worldPoint = WorldPoint.fromLocalInstance(client, localPoint); + final ColorTileMarker point = new ColorTileMarker(worldPoint, config.markerColor()); log.debug("Updating point: {} - {}", point, worldPoint); - List points = new ArrayList<>(getPoints(regionId)); if (points.contains(point)) { points.remove(point); } else { - points.add(point); + // Remove any points on the same tile but are of a different color + points.removeIf(p -> p.sameTile(point)); + + // Add point back only if we are remembering tile colors, otherwise simply remove it + if (config.rememberTileColors()) + { + points.add(point); + } } - savePoints(regionId, points); + final int regionId = worldPoint.getRegionID(); + saveColorTileMarkers(regionId, points); loadPoints(); } diff --git a/runelite-client/src/main/java/net/runelite/client/plugins/groundmarkers/GroundMarkerPoint.java b/runelite-client/src/main/java/net/runelite/client/plugins/groundmarkers/GroundMarkerPoint.java index 396a2217cb..ca3aaadb6d 100644 --- a/runelite-client/src/main/java/net/runelite/client/plugins/groundmarkers/GroundMarkerPoint.java +++ b/runelite-client/src/main/java/net/runelite/client/plugins/groundmarkers/GroundMarkerPoint.java @@ -25,8 +25,12 @@ */ package net.runelite.client.plugins.groundmarkers; +import java.awt.Color; import lombok.Value; +/** + * Used for serialization of ground marker points. + */ @Value class GroundMarkerPoint { @@ -34,4 +38,5 @@ class GroundMarkerPoint private int regionX; private int regionY; private int z; + private Color color; }