teamcapes: rewrite to use events

runelite-client/src/main/java/net/runelite/client/plugins/teamcapes/TeamCapesOverlay.java

@@ -39,7 +39,7 @@ import net.runelite.client.ui.overlay.OverlayPriority;
 import net.runelite.client.ui.overlay.components.ComponentOrientation;
 import net.runelite.client.ui.overlay.components.ImageComponent;
 
-public class TeamCapesOverlay extends OverlayPanel
+class TeamCapesOverlay extends OverlayPanel
 {
 	private final TeamCapesPlugin plugin;
 	private final TeamCapesConfig config;

runelite-client/src/main/java/net/runelite/client/plugins/teamcapes/TeamCapesPlugin.java

@@ -25,21 +25,24 @@
 package net.runelite.client.plugins.teamcapes;
 
 import com.google.inject.Provides;
-import java.time.temporal.ChronoUnit;
 import java.util.Comparator;
 import java.util.HashMap;
 import java.util.LinkedHashMap;
-import java.util.List;
 import java.util.Map;
 import java.util.stream.Collectors;
 import javax.inject.Inject;
+import lombok.AccessLevel;
+import lombok.Getter;
+import lombok.extern.slf4j.Slf4j;
 import net.runelite.api.Client;
-import net.runelite.api.GameState;
 import net.runelite.api.Player;
+import net.runelite.api.events.PlayerChanged;
+import net.runelite.api.events.PlayerDespawned;
+import net.runelite.client.callback.ClientThread;
 import net.runelite.client.config.ConfigManager;
+import net.runelite.client.eventbus.Subscribe;
 import net.runelite.client.plugins.Plugin;
 import net.runelite.client.plugins.PluginDescriptor;
-import net.runelite.client.task.Schedule;
 import net.runelite.client.ui.overlay.OverlayManager;
 
 @PluginDescriptor(
@@ -48,19 +51,26 @@ import net.runelite.client.ui.overlay.OverlayManager;
 	tags = {"overlay", "players"},
 	enabledByDefault = false
 )
+@Slf4j
 public class TeamCapesPlugin extends Plugin
 {
 	@Inject
 	private Client client;
 
+	@Inject
+	private ClientThread clientThread;
+
 	@Inject
 	private OverlayManager overlayManager;
 
 	@Inject
 	private TeamCapesOverlay overlay;
 
-	// Hashmap of team capes: Key is the teamCape #, Value is the count of teamcapes in the area.
+	// Team number -> Number of players
-	private Map<Integer, Integer> teams = new HashMap<>();
+	@Getter(AccessLevel.PACKAGE)
+	private Map<Integer, Integer> teams = new LinkedHashMap<>();
+	// Player -> Team number
+	private final Map<Player, Integer> playerTeam = new HashMap<>();
 
 	@Provides
 	TeamCapesConfig provideConfig(ConfigManager configManager)
@@ -72,6 +82,8 @@ public class TeamCapesPlugin extends Plugin
 	protected void startUp() throws Exception
 	{
 		overlayManager.add(overlay);
+
+		clientThread.invokeLater(() -> client.getPlayers().forEach(this::update));
 	}
 
 	@Override
@@ -79,48 +91,61 @@ public class TeamCapesPlugin extends Plugin
 	{
 		overlayManager.remove(overlay);
 		teams.clear();
+		playerTeam.clear();
 	}
 
-	@Schedule(
+	@Subscribe
-		period = 1800,
+	public void onPlayerChanged(PlayerChanged playerChanged)
-		unit = ChronoUnit.MILLIS
-	)
-	public void update()
 	{
-		if (client.getGameState() != GameState.LOGGED_IN)
+		Player player = playerChanged.getPlayer();
+		update(player);
+	}
+
+	private void update(Player player)
+	{
+		int oldTeam = playerTeam.getOrDefault(player, 0);
+		if (oldTeam == player.getTeam())
 		{
 			return;
 		}
-		List<Player> players = client.getPlayers();
+
-		teams.clear();
+		log.debug("{} has changed teams: {} -> {}", player.getName(), oldTeam, player.getTeam());
-		for (Player player : players)
+
+		if (oldTeam > 0)
 		{
-			int team = player.getTeam();
+			teams.computeIfPresent(oldTeam, (key, value) -> value > 1 ? value - 1 : null);
-			if (team > 0)
+			playerTeam.remove(player);
-			{
-				if (teams.containsKey(team))
-				{
-					teams.put(team, teams.get(team) + 1);
-				}
-				else
-				{
-					teams.put(team, 1);
-				}
-			}
 		}
 
+		if (player.getTeam() > 0)
+		{
+			teams.merge(player.getTeam(), 1, Integer::sum);
+			playerTeam.put(player, player.getTeam());
+		}
+
+		sort();
+	}
+
+	@Subscribe
+	public void onPlayerDespawned(PlayerDespawned playerDespawned)
+	{
+		Player player = playerDespawned.getPlayer();
+		Integer team = playerTeam.remove(player);
+		if (team != null)
+		{
+			teams.computeIfPresent(team, (key, value) -> value > 1 ? value - 1 : null);
+			sort();
+		}
+	}
+
+	private void sort()
+	{
 		// Sort teams by value in descending order and then by key in ascending order, limited to 5 entries
 		teams = teams.entrySet().stream()
-					.sorted(
+			.sorted(
-						Comparator.comparing(Map.Entry<Integer, Integer>::getValue, Comparator.reverseOrder())
+				Comparator.comparing(Map.Entry<Integer, Integer>::getValue, Comparator.reverseOrder())
-								.thenComparingInt(Map.Entry::getKey)
+					.thenComparingInt(Map.Entry::getKey)
-					)
+			)
-					.collect(Collectors.toMap(Map.Entry::getKey, Map.Entry::getValue, (e1, e2) -> e1, LinkedHashMap::new));
+			.collect(Collectors.toMap(Map.Entry::getKey, Map.Entry::getValue, (e1, e2) -> e1, LinkedHashMap::new));
 	}
-
-	public Map<Integer, Integer> getTeams()
-	{
-		return teams;
-	}
-
 }