ra/runelite
1
0
Fork 0
Code Issues Pull Requests Actions 3 Packages Projects Releases Wiki Activity

Do not count local player in nearby clan member counter

Browse Source 
Signed-off-by: Tomas Slusny <slusnucky@gmail.com>
This commit is contained in:
Tomas Slusny
2019-04-20 13:45:27 +02:00
committed by Ganom
parent faad960f10
commit 0f3d7e8877
1 changed files with 413 additions and 218 deletions
Download Patch File Download Diff File Expand all files Collapse all files

631
runelite-client/src/main/java/net/runelite/client/plugins/clanchat/ClanChatPlugin.java
View File

@@ -1,30 +1,89 @@
/*
* Copyright (c) 2017, Devin French <https://github.com/devinfrench>
* Copyright (c) 2019, Adam <Adam@sigterm.info>
* Copyright (c) 2018, trimbe <github.com/trimbe>
* 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.clanchat; package net.runelite.client.plugins.clanchat;
import net.runelite.client.plugins.*; import com.google.common.base.Strings;
import net.runelite.client.game.*; import com.google.common.collect.Lists;
import net.runelite.client.callback.*; import com.google.inject.Provides;
import java.awt.Color;
import java.awt.image.BufferedImage;
import java.util.ArrayDeque;
import java.util.ArrayList;
import java.util.Deque;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List; import java.util.List;
import java.util.Objects; import java.util.Map;
import java.util.concurrent.*; import javax.inject.Inject;
import net.runelite.client.config.*; import net.runelite.api.ChatLineBuffer;
import com.google.inject.*; import net.runelite.api.ChatMessageType;
import net.runelite.client.util.*; import net.runelite.api.ClanMember;
import net.runelite.client.eventbus.*; import net.runelite.api.ClanMemberRank;
import com.google.common.base.*; import net.runelite.api.Client;
import net.runelite.api.widgets.*; import net.runelite.api.GameState;
import net.runelite.client.ui.*; import net.runelite.api.MessageNode;
import net.runelite.client.chat.*; import net.runelite.api.Player;
import java.awt.*; import net.runelite.api.ScriptID;
import net.runelite.api.*; import net.runelite.api.SpriteID;
import net.runelite.api.events.*; import net.runelite.api.VarClientStr;
import com.google.common.collect.*; import net.runelite.api.Varbits;
import java.util.*; import net.runelite.api.events.ChatMessage;
import java.util.function.*; import net.runelite.api.events.ClanChanged;
import net.runelite.client.ui.overlay.infobox.*; import net.runelite.api.events.ClanMemberJoined;
import java.awt.image.*; import net.runelite.api.events.ClanMemberLeft;
import net.runelite.api.events.ConfigChanged;
import net.runelite.api.events.GameStateChanged;
import net.runelite.api.events.GameTick;
import net.runelite.api.events.PlayerDespawned;
import net.runelite.api.events.PlayerSpawned;
import net.runelite.api.events.VarClientStrChanged;
import net.runelite.api.widgets.Widget;
import net.runelite.api.widgets.WidgetInfo;
import net.runelite.api.widgets.WidgetType;
import net.runelite.client.callback.ClientThread;
import net.runelite.client.chat.ChatMessageBuilder;
import net.runelite.client.config.ConfigManager;
import net.runelite.client.eventbus.Subscribe;
import net.runelite.client.game.ClanManager;
import net.runelite.client.game.SpriteManager;
import net.runelite.client.plugins.Plugin;
import net.runelite.client.plugins.PluginDescriptor;
import static net.runelite.client.ui.JagexColors.CHAT_CLAN_NAME_OPAQUE_BACKGROUND;
import static net.runelite.client.ui.JagexColors.CHAT_CLAN_NAME_TRANSPARENT_BACKGROUND;
import static net.runelite.client.ui.JagexColors.CHAT_CLAN_TEXT_OPAQUE_BACKGROUND;
import static net.runelite.client.ui.JagexColors.CHAT_CLAN_TEXT_TRANSPARENT_BACKGROUND;
import net.runelite.client.ui.overlay.infobox.InfoBoxManager;
import net.runelite.client.util.Text;
@PluginDescriptor(name = "Clan Chat", description = "Add rank icons to users talking in clan chat", tags = { "icons", "rank", "recent" }) @PluginDescriptor(
name = "Clan Chat",
description = "Add rank icons to users talking in clan chat",
tags = {"icons", "rank", "recent"}
)
public class ClanChatPlugin extends Plugin public class ClanChatPlugin extends Plugin
{ {
private static final int MAX_CHATS = 10; private static final int MAX_CHATS = 10;
@@ -32,376 +91,512 @@ public class ClanChatPlugin extends Plugin
private static final String RECENT_TITLE = "Recent Clan Chats"; private static final String RECENT_TITLE = "Recent Clan Chats";
private static final int JOIN_LEAVE_DURATION = 20; private static final int JOIN_LEAVE_DURATION = 20;
private static final int MESSAGE_DELAY = 10; private static final int MESSAGE_DELAY = 10;
@Inject @Inject
private Client client; private Client client;
@Inject @Inject
private ClanManager clanManager; private ClanManager clanManager;
@Inject @Inject
private ClanChatConfig config; private ClanChatConfig config;
@Inject @Inject
private InfoBoxManager infoBoxManager; private InfoBoxManager infoBoxManager;
@Inject @Inject
private SpriteManager spriteManager; private SpriteManager spriteManager;
@Inject @Inject
private ClientThread clientThread; private ClientThread clientThread;
private List<String> chats;
private static CopyOnWriteArrayList<Player> clanMembers; private List<String> chats = new ArrayList<>();
private List<Player> clanMembers = new ArrayList<>();
private ClanChatIndicator clanMemberCounter; private ClanChatIndicator clanMemberCounter;
private final Deque<ClanJoinMessage> clanJoinMessages; /**
private Map<String, ClanMemberActivity> activityBuffer; * queue of temporary messages added to the client
*/
private final Deque<ClanJoinMessage> clanJoinMessages = new ArrayDeque<>();
private Map<String, ClanMemberActivity> activityBuffer = new HashMap<>();
private int clanJoinedTick; private int clanJoinedTick;
public ClanChatPlugin() {
this.chats = new ArrayList<String>();
this.clanJoinMessages = new ArrayDeque<ClanJoinMessage>();
this.activityBuffer = new HashMap<String, ClanMemberActivity>();
}
public static CopyOnWriteArrayList<Player> getClanMembers() {
return (CopyOnWriteArrayList<Player>)ClanChatPlugin.clanMembers.clone();
}
@Provides @Provides
ClanChatConfig getConfig(final ConfigManager configManager) { ClanChatConfig getConfig(ConfigManager configManager)
{
return configManager.getConfig(ClanChatConfig.class); return configManager.getConfig(ClanChatConfig.class);
} }
public void startUp() { @Override
this.chats = new ArrayList<String>(Text.fromCSV(this.config.chatsData())); public void startUp()
{
chats = new ArrayList<>(Text.fromCSV(config.chatsData()));
} }
public void shutDown() { @Override
ClanChatPlugin.clanMembers.clear(); public void shutDown()
this.removeClanCounter(); {
this.resetClanChats(); clanMembers.clear();
removeClanCounter();
resetClanChats();
} }
@Subscribe @Subscribe
public void onConfigChanged(final ConfigChanged configChanged) { public void onConfigChanged(ConfigChanged configChanged)
if (configChanged.getGroup().equals("clanchat")) { {
if (!this.config.recentChats()) { if (configChanged.getGroup().equals("clanchat"))
this.resetClanChats(); {
if (!config.recentChats())
{
resetClanChats();
} }
if (this.config.showClanCounter()) {
this.clientThread.invoke(this::addClanCounter); if (config.showClanCounter())
{
clientThread.invoke(this::addClanCounter);
} }
else { else
this.removeClanCounter(); {
removeClanCounter();
} }
} }
} }
@Subscribe @Subscribe
public void onClanMemberJoined(final ClanMemberJoined event) { public void onClanMemberJoined(ClanMemberJoined event)
{
final ClanMember member = event.getMember(); final ClanMember member = event.getMember();
if (member.getWorld() == this.client.getWorld()) {
if (member.getWorld() == client.getWorld())
{
final Player local = client.getLocalPlayer();
final String memberName = Text.toJagexName(member.getUsername()); final String memberName = Text.toJagexName(member.getUsername());
for (final Player player : this.client.getPlayers()) {
if (player != null && memberName.equals(Text.toJagexName(player.getName()))) { for (final Player player : client.getPlayers())
ClanChatPlugin.clanMembers.add(player); {
this.addClanCounter(); if (player != null && player != local && memberName.equals(Text.toJagexName(player.getName())))
{
clanMembers.add(player);
addClanCounter();
break; break;
} }
} }
} }
if (this.clanJoinedTick == this.client.getTickCount()) {
// clan members getting initialized isn't relevant
if (clanJoinedTick == client.getTickCount())
{
return; return;
} }
if (!this.config.showJoinLeave() || member.getRank().getValue() < this.config.joinLeaveRank().getValue()) {
if (!config.showJoinLeave() ||
member.getRank().getValue() < config.joinLeaveRank().getValue())
{
return; return;
} }
if (!this.activityBuffer.containsKey(member.getUsername())) {
final ClanMemberActivity joinActivity = new ClanMemberActivity(ClanActivityType.JOINED, member, this.client.getTickCount()); // attempt to filter out world hopping joins
this.activityBuffer.put(member.getUsername(), joinActivity); if (!activityBuffer.containsKey(member.getUsername()))
{
ClanMemberActivity joinActivity = new ClanMemberActivity(ClanActivityType.JOINED,
member, client.getTickCount());
activityBuffer.put(member.getUsername(), joinActivity);
} }
else { else
this.activityBuffer.remove(member.getUsername()); {
activityBuffer.remove(member.getUsername());
} }
} }
@Subscribe @Subscribe
public void onClanMemberLeft(final ClanMemberLeft event) { public void onClanMemberLeft(ClanMemberLeft event)
{
final ClanMember member = event.getMember(); final ClanMember member = event.getMember();
if (member.getWorld() == this.client.getWorld()) {
if (member.getWorld() == client.getWorld())
{
final String memberName = Text.toJagexName(member.getUsername()); final String memberName = Text.toJagexName(member.getUsername());
final Iterator<Player> each = ClanChatPlugin.clanMembers.iterator(); final Iterator<Player> each = clanMembers.iterator();
while (each.hasNext()) {
if (memberName.equals(Text.toJagexName(each.next().getName()))) { while (each.hasNext())
{
if (memberName.equals(Text.toJagexName(each.next().getName())))
{
each.remove(); each.remove();
if (ClanChatPlugin.clanMembers.isEmpty()) {
this.removeClanCounter(); if (clanMembers.isEmpty())
break; {
removeClanCounter();
} }
break; break;
} }
} }
} }
if (!this.config.showJoinLeave() || member.getRank().getValue() < this.config.joinLeaveRank().getValue()) {
if (!config.showJoinLeave() ||
member.getRank().getValue() < config.joinLeaveRank().getValue())
{
return; return;
} }
if (!this.activityBuffer.containsKey(member.getUsername())) {
final ClanMemberActivity leaveActivity = new ClanMemberActivity(ClanActivityType.LEFT, member, this.client.getTickCount()); if (!activityBuffer.containsKey(member.getUsername()))
this.activityBuffer.put(member.getUsername(), leaveActivity); {
ClanMemberActivity leaveActivity = new ClanMemberActivity(ClanActivityType.LEFT,
member, client.getTickCount());
activityBuffer.put(member.getUsername(), leaveActivity);
} }
else { else
this.activityBuffer.remove(member.getUsername()); {
activityBuffer.remove(member.getUsername());
} }
} }
@Subscribe @Subscribe
public void onGameTick(final GameTick gameTick) { public void onGameTick(GameTick gameTick)
if (this.client.getGameState() != GameState.LOGGED_IN) { {
if (client.getGameState() != GameState.LOGGED_IN)
{
return; return;
} }
final Widget clanChatTitleWidget = this.client.getWidget(WidgetInfo.CLAN_CHAT_TITLE);
if (clanChatTitleWidget != null) { Widget clanChatTitleWidget = client.getWidget(WidgetInfo.CLAN_CHAT_TITLE);
final Widget clanChatList = this.client.getWidget(WidgetInfo.CLAN_CHAT_LIST); if (clanChatTitleWidget != null)
final Widget owner = this.client.getWidget(WidgetInfo.CLAN_CHAT_OWNER); {
if (this.client.getClanChatCount() > 0) { Widget clanChatList = client.getWidget(WidgetInfo.CLAN_CHAT_LIST);
clanChatTitleWidget.setText("Clan Chat (" + this.client.getClanChatCount() + "/100)"); Widget owner = client.getWidget(WidgetInfo.CLAN_CHAT_OWNER);
if (client.getClanChatCount() > 0)
{
clanChatTitleWidget.setText(CLAN_CHAT_TITLE + " (" + client.getClanChatCount() + "/100)");
} }
else if (this.config.recentChats() && clanChatList.getChildren() == null && !Strings.isNullOrEmpty(owner.getText())) { else if (config.recentChats() && clanChatList.getChildren() == null && !Strings.isNullOrEmpty(owner.getText()))
clanChatTitleWidget.setText("Recent Clan Chats"); {
this.loadClanChats(); clanChatTitleWidget.setText(RECENT_TITLE);
loadClanChats();
} }
} }
if (!this.config.showJoinLeave()) {
if (!config.showJoinLeave())
{
return; return;
} }
this.timeoutClanMessages();
this.addClanActivityMessages(); timeoutClanMessages();
addClanActivityMessages();
} }
private void timeoutClanMessages() { private void timeoutClanMessages()
if (this.clanJoinMessages.isEmpty()) { {
if (clanJoinMessages.isEmpty())
{
return; return;
} }
boolean removed = false; boolean removed = false;
final Iterator<ClanJoinMessage> it = this.clanJoinMessages.iterator();
while (it.hasNext()) { for (Iterator<ClanJoinMessage> it = clanJoinMessages.iterator(); it.hasNext(); )
final ClanJoinMessage clanJoinMessage = it.next(); {
final MessageNode messageNode = clanJoinMessage.getMessageNode(); ClanJoinMessage clanJoinMessage = it.next();
MessageNode messageNode = clanJoinMessage.getMessageNode();
final int createdTick = clanJoinMessage.getTick(); final int createdTick = clanJoinMessage.getTick();
if (this.client.getTickCount() <= createdTick + 20) {
if (client.getTickCount() > createdTick + JOIN_LEAVE_DURATION)
{
it.remove();
// If this message has been reused since, it will get a different id
if (clanJoinMessage.getGetMessageId() == messageNode.getId())
{
ChatLineBuffer ccInfoBuffer = client.getChatLineMap().get(ChatMessageType.FRIENDSCHATNOTIFICATION.getType());
if (ccInfoBuffer != null)
{
ccInfoBuffer.removeMessageNode(messageNode);
removed = true;
}
}
}
else
{
// Everything else in the deque is newer
break; break;
} }
it.remove();
if (clanJoinMessage.getGetMessageId() != messageNode.getId()) {
continue;
}
final ChatLineBuffer ccInfoBuffer = this.client.getChatLineMap().get(ChatMessageType.FRIENDSCHATNOTIFICATION.getType());
if (ccInfoBuffer == null) {
continue;
}
ccInfoBuffer.removeMessageNode(messageNode);
removed = true;
} }
if (removed) {
this.clientThread.invoke(() -> this.client.runScript(216, new Object[0])); if (removed)
{
clientThread.invoke(() -> client.runScript(ScriptID.BUILD_CHATBOX));
} }
} }
private void addClanActivityMessages() { private void addClanActivityMessages()
final Iterator<ClanMemberActivity> activityIt = this.activityBuffer.values().iterator(); {
while (activityIt.hasNext()) { Iterator<ClanMemberActivity> activityIt = activityBuffer.values().iterator();
final ClanMemberActivity activity = activityIt.next();
if (activity.getTick() < this.client.getTickCount() - 10) { while (activityIt.hasNext())
{
ClanMemberActivity activity = activityIt.next();
if (activity.getTick() < client.getTickCount() - MESSAGE_DELAY)
{
activityIt.remove(); activityIt.remove();
this.addActivityMessage(activity.getMember(), activity.getActivityType()); addActivityMessage(activity.getMember(), activity.getActivityType());
} }
} }
} }
private void addActivityMessage(final ClanMember member, final ClanActivityType activityType) { private void addActivityMessage(ClanMember member, ClanActivityType activityType)
final String activityMessage = (activityType == ClanActivityType.JOINED) ? " has joined." : " has left."; {
final String activityMessage = activityType == ClanActivityType.JOINED ? " has joined." : " has left.";
final ClanMemberRank rank = member.getRank(); final ClanMemberRank rank = member.getRank();
Color textColor = JagexColors.CHAT_CLAN_TEXT_OPAQUE_BACKGROUND; Color textColor = CHAT_CLAN_TEXT_OPAQUE_BACKGROUND;
Color channelColor = JagexColors.CHAT_CLAN_NAME_OPAQUE_BACKGROUND; Color channelColor = CHAT_CLAN_NAME_OPAQUE_BACKGROUND;
int rankIcon = -1; int rankIcon = -1;
if (this.client.isResized() && this.client.getVar(Varbits.TRANSPARENT_CHATBOX) == 1) {
textColor = JagexColors.CHAT_CLAN_TEXT_TRANSPARENT_BACKGROUND; if (client.isResized() && client.getVar(Varbits.TRANSPARENT_CHATBOX) == 1)
channelColor = JagexColors.CHAT_CLAN_NAME_TRANSPARENT_BACKGROUND; {
textColor = CHAT_CLAN_TEXT_TRANSPARENT_BACKGROUND;
channelColor = CHAT_CLAN_NAME_TRANSPARENT_BACKGROUND;
} }
if (this.config.clanChatIcons() && rank != null && rank != ClanMemberRank.UNRANKED) {
rankIcon = this.clanManager.getIconNumber(rank); if (config.clanChatIcons() && rank != null && rank != ClanMemberRank.UNRANKED)
{
rankIcon = clanManager.getIconNumber(rank);
} }
final ChatMessageBuilder message = new ChatMessageBuilder().append("[").append(channelColor, this.client.getClanChatName());
if (rankIcon > -1) { ChatMessageBuilder message = new ChatMessageBuilder()
message.append(" ").img(rankIcon); .append("[")
.append(channelColor, client.getClanChatName());
if (rankIcon > -1)
{
message
.append(" ")
.img(rankIcon);
} }
message.append("] ").append(textColor, member.getUsername() + activityMessage); message
.append("] ")
.append(textColor, member.getUsername() + activityMessage);
final String messageString = message.build(); final String messageString = message.build();
this.client.addChatMessage(ChatMessageType.FRIENDSCHATNOTIFICATION, "", messageString, ""); client.addChatMessage(ChatMessageType.FRIENDSCHATNOTIFICATION, "", messageString, "");
final ChatLineBuffer chatLineBuffer = this.client.getChatLineMap().get(ChatMessageType.FRIENDSCHATNOTIFICATION.getType());
final ChatLineBuffer chatLineBuffer = client.getChatLineMap().get(ChatMessageType.FRIENDSCHATNOTIFICATION.getType());
final MessageNode[] lines = chatLineBuffer.getLines(); final MessageNode[] lines = chatLineBuffer.getLines();
final MessageNode line = lines[0]; final MessageNode line = lines[0];
final ClanJoinMessage clanJoinMessage = new ClanJoinMessage(line, line.getId(), this.client.getTickCount());
this.clanJoinMessages.addLast(clanJoinMessage); ClanJoinMessage clanJoinMessage = new ClanJoinMessage(line, line.getId(), client.getTickCount());
clanJoinMessages.addLast(clanJoinMessage);
} }
@Subscribe @Subscribe
public void onVarClientStrChanged(final VarClientStrChanged strChanged) { public void onVarClientStrChanged(VarClientStrChanged strChanged)
if (strChanged.getIndex() == VarClientStr.RECENT_CLAN_CHAT.getIndex() && this.config.recentChats()) { {
this.updateRecentChat(this.client.getVar(VarClientStr.RECENT_CLAN_CHAT)); if (strChanged.getIndex() == VarClientStr.RECENT_CLAN_CHAT.getIndex() && config.recentChats())
{
updateRecentChat(client.getVar(VarClientStr.RECENT_CLAN_CHAT));
} }
} }
@Subscribe @Subscribe
public void onChatMessage(final ChatMessage chatMessage) { public void onChatMessage(ChatMessage chatMessage)
if (this.client.getGameState() != GameState.LOADING && this.client.getGameState() != GameState.LOGGED_IN) { {
if (client.getGameState() != GameState.LOADING && client.getGameState() != GameState.LOGGED_IN)
{
return; return;
} }
if (this.client.getClanChatCount() <= 0) {
if (client.getClanChatCount() <= 0)
{
return; return;
} }
switch (chatMessage.getType()) {
switch (chatMessage.getType())
{
case PRIVATECHAT: case PRIVATECHAT:
case MODPRIVATECHAT: { case MODPRIVATECHAT:
if (!this.config.privateMessageIcons()) { if (!config.privateMessageIcons())
{
return; return;
} }
break; break;
}
case PUBLICCHAT: case PUBLICCHAT:
case MODCHAT: { case MODCHAT:
if (!this.config.publicChatIcons()) { if (!config.publicChatIcons())
{
return; return;
} }
break; break;
} case FRIENDSCHAT:
case FRIENDSCHAT: { if (!config.clanChatIcons())
if (!this.config.clanChatIcons()) { {
return; return;
} }
break; break;
} default:
default: {
return; return;
}
} }
this.insertClanRankIcon(chatMessage);
insertClanRankIcon(chatMessage);
} }
@Subscribe @Subscribe
public void onGameStateChanged(final GameStateChanged state) { public void onGameStateChanged(GameStateChanged state)
final GameState gameState = state.getGameState(); {
if (gameState == GameState.LOGIN_SCREEN || gameState == GameState.CONNECTION_LOST || gameState == GameState.HOPPING) { GameState gameState = state.getGameState();
ClanChatPlugin.clanMembers.clear();
this.removeClanCounter(); if (gameState == GameState.LOGIN_SCREEN || gameState == GameState.CONNECTION_LOST || gameState == GameState.HOPPING)
this.clanJoinMessages.clear(); {
clanMembers.clear();
removeClanCounter();
clanJoinMessages.clear();
} }
} }
@Subscribe @Subscribe
public void onPlayerSpawned(final PlayerSpawned event) { public void onPlayerSpawned(PlayerSpawned event)
if (event.getPlayer().isClanMember()) { {
ClanChatPlugin.clanMembers.add(event.getPlayer()); final Player local = client.getLocalPlayer();
this.addClanCounter(); final Player player = event.getPlayer();
if (player != local && player.isClanMember())
{
clanMembers.add(player);
addClanCounter();
} }
} }
@Subscribe @Subscribe
public void onPlayerDespawned(final PlayerDespawned event) { public void onPlayerDespawned(PlayerDespawned event)
if (ClanChatPlugin.clanMembers.remove(event.getPlayer()) && ClanChatPlugin.clanMembers.isEmpty()) { {
this.removeClanCounter(); if (clanMembers.remove(event.getPlayer()) && clanMembers.isEmpty())
{
removeClanCounter();
} }
} }
@Subscribe @Subscribe
public void onClanChanged(final ClanChanged event) { public void onClanChanged(ClanChanged event)
if (event.isJoined()) { {
this.clanJoinedTick = this.client.getTickCount(); if (event.isJoined())
{
clanJoinedTick = client.getTickCount();
} }
else { else
ClanChatPlugin.clanMembers.clear(); {
this.removeClanCounter(); clanMembers.clear();
removeClanCounter();
} }
this.activityBuffer.clear();
activityBuffer.clear();
} }
int getClanAmount() { int getClanAmount()
return ClanChatPlugin.clanMembers.size(); {
return clanMembers.size();
} }
private void insertClanRankIcon(final ChatMessage message) { private void insertClanRankIcon(final ChatMessage message)
final ClanMemberRank rank = this.clanManager.getRank(message.getName()); {
if (rank != null && rank != ClanMemberRank.UNRANKED) { final ClanMemberRank rank = clanManager.getRank(message.getName());
final int iconNumber = this.clanManager.getIconNumber(rank);
if (rank != null && rank != ClanMemberRank.UNRANKED)
{
int iconNumber = clanManager.getIconNumber(rank);
final String img = "<img=" + iconNumber + ">"; final String img = "<img=" + iconNumber + ">";
if (message.getType() == ChatMessageType.FRIENDSCHAT) { if (message.getType() == ChatMessageType.FRIENDSCHAT)
message.getMessageNode().setSender(message.getMessageNode().getSender() + " " + img); {
message.getMessageNode()
.setSender(message.getMessageNode().getSender() + " " + img);
} }
else { else
message.getMessageNode().setName(img + message.getMessageNode().getName()); {
message.getMessageNode()
.setName(img + message.getMessageNode().getName());
} }
this.client.refreshChat(); client.refreshChat();
} }
} }
private void resetClanChats() { private void resetClanChats()
final Widget clanChatList = this.client.getWidget(WidgetInfo.CLAN_CHAT_LIST); {
final Widget clanChatTitleWidget = this.client.getWidget(WidgetInfo.CLAN_CHAT_TITLE); Widget clanChatList = client.getWidget(WidgetInfo.CLAN_CHAT_LIST);
if (clanChatList == null) { Widget clanChatTitleWidget = client.getWidget(WidgetInfo.CLAN_CHAT_TITLE);
if (clanChatList == null)
{
return; return;
} }
if (this.client.getClanChatCount() == 0) {
if (client.getClanChatCount() == 0)
{
clanChatList.setChildren(null); clanChatList.setChildren(null);
} }
clanChatTitleWidget.setText("Clan Chat");
clanChatTitleWidget.setText(CLAN_CHAT_TITLE);
} }
private void loadClanChats() { private void loadClanChats()
final Widget clanChatList = this.client.getWidget(WidgetInfo.CLAN_CHAT_LIST); {
if (clanChatList == null) { Widget clanChatList = client.getWidget(WidgetInfo.CLAN_CHAT_LIST);
if (clanChatList == null)
{
return; return;
} }
int y = 2; int y = 2;
clanChatList.setChildren(null); clanChatList.setChildren(null);
for (final String chat : Lists.reverse(this.chats)) { for (String chat : Lists.reverse(chats))
final Widget widget = clanChatList.createChild(-1, 4); {
Widget widget = clanChatList.createChild(-1, WidgetType.TEXT);
widget.setFontId(494); widget.setFontId(494);
widget.setTextColor(16777215); widget.setTextColor(0xffffff);
widget.setText(chat); widget.setText(chat);
widget.setOriginalHeight(14); widget.setOriginalHeight(14);
widget.setOriginalWidth(142); widget.setOriginalWidth(142);
widget.setOriginalY(y); widget.setOriginalY(y);
widget.setOriginalX(20); widget.setOriginalX(20);
widget.revalidate(); widget.revalidate();
y += 14; y += 14;
} }
} }
private void updateRecentChat(String s) { private void updateRecentChat(String s)
if (Strings.isNullOrEmpty(s)) { {
if (Strings.isNullOrEmpty(s))
{
return; return;
} }
s = Text.toJagexName(s); s = Text.toJagexName(s);
final List<String> chats = this.chats;
final String s2 = s; chats.removeIf(s::equalsIgnoreCase);
Objects.requireNonNull(s2); chats.add(s);
chats.removeIf(s2::equalsIgnoreCase);
this.chats.add(s); while (chats.size() > MAX_CHATS)
while (this.chats.size() > 10) { {
this.chats.remove(0); chats.remove(0);
} }
this.config.chatsData(Text.toCSV(this.chats));
config.chatsData(Text.toCSV(chats));
} }
private void removeClanCounter() { private void removeClanCounter()
this.infoBoxManager.removeInfoBox(this.clanMemberCounter); {
this.clanMemberCounter = null; infoBoxManager.removeInfoBox(clanMemberCounter);
clanMemberCounter = null;
} }
private void addClanCounter() { private void addClanCounter()
if (!this.config.showClanCounter() || this.clanMemberCounter != null || ClanChatPlugin.clanMembers.isEmpty()) { {
if (!config.showClanCounter() || clanMemberCounter != null || clanMembers.isEmpty())
{
return; return;
} }
final BufferedImage image = this.spriteManager.getSprite(904, 0);
this.clanMemberCounter = new ClanChatIndicator(image, this);
this.infoBoxManager.addInfoBox(this.clanMemberCounter);
}
static { final BufferedImage image = spriteManager.getSprite(SpriteID.TAB_CLAN_CHAT, 0);
ClanChatPlugin.clanMembers = new CopyOnWriteArrayList<Player>(); clanMemberCounter = new ClanChatIndicator(image, this);
infoBoxManager.addInfoBox(clanMemberCounter);
} }
} }