net.runelite.client.eventbus.Subscribe Java Examples

@Subscribe
private void onGameObjectSpawned(GameObjectSpawned event)
{
	final GameObject gameObject = event.getGameObject();
	BlastMineRockType blastMineRockType = BlastMineRockType.getRockType(gameObject.getId());
	if (blastMineRockType == null)
	{
		return;
	}

	final BlastMineRock newRock = new BlastMineRock(gameObject, blastMineRockType);
	final BlastMineRock oldRock = rocks.get(gameObject.getWorldLocation());

	if (oldRock == null || oldRock.getType() != newRock.getType())
	{
		rocks.put(gameObject.getWorldLocation(), newRock);
	}
}
 

@Subscribe
private void onGameStateChanged(GameStateChanged gameStateChanged)
{
	GameState gameState = gameStateChanged.getGameState();
	if (gameState == GameState.LOADING)
	{
		// Reload points with new map regions

		points.clear();
		for (int regionId : client.getMapRegions())
		{
			// load points for region
			final Set<ObjectPoint> regionPoints = loadPoints(regionId);
			if (regionPoints != null)
			{
				points.put(regionId, regionPoints);
			}
		}
	}

	if (gameStateChanged.getGameState() != GameState.LOGGED_IN)
	{
		objects.clear();
	}
}
 

@Subscribe
private void onAnimationChanged(final AnimationChanged event)
{
	Player local = client.getLocalPlayer();

	if (event.getActor() != local)
	{
		return;
	}

	int animId = local.getAnimation();
	Axe axe = Axe.findAxeByAnimId(animId);
	if (axe != null)
	{
		this.axe = axe;
	}
}
 

@Subscribe
private void onSkillUpdate(final SkillUpdate event)
{
	final PartyData partyData = getPartyData(event.getMemberId());

	if (partyData == null)
	{
		return;
	}

	if (event.getSkill() == Skill.HITPOINTS)
	{
		partyData.setHitpoints(event.getValue());
		partyData.setMaxHitpoints(event.getMax());
	}
	else if (event.getSkill() == Skill.PRAYER)
	{
		partyData.setPrayer(event.getValue());
		partyData.setMaxPrayer(event.getMax());
	}
}
 

@Subscribe
private void onConfigChanged(ConfigChanged event)
{
	if (!event.getGroup().equals("slayer"))
	{
		return;
	}

	if (event.getKey().equals("infobox"))
	{
		if (config.showInfobox())
		{
			clientThread.invoke(this::addCounter);
		}
		else
		{
			removeCounter();
		}
	}
}
 

@Subscribe
private void onItemSpawned(ItemSpawned itemSpawned)
{
	TileItem item = itemSpawned.getItem();
	Tile tile = itemSpawned.getTile();

	GroundItem groundItem = buildGroundItem(tile, item);

	GroundItem.GroundItemKey groundItemKey = new GroundItem.GroundItemKey(item.getId(), tile.getWorldLocation());
	GroundItem existing = collectedGroundItems.putIfAbsent(groundItemKey, groundItem);
	if (existing != null)
	{
		existing.setQuantity(existing.getQuantity() + groundItem.getQuantity());
		// The spawn time remains set at the oldest spawn
	}

	if (!config.onlyShowLoot())
	{
		notifyHighlightedItem(groundItem);
	}
}
 

@Subscribe
private void onHitsplatApplied(HitsplatApplied hitsplatApplied)
{
	Actor actor = hitsplatApplied.getActor();

	if (actor != corp)
	{
		return;
	}

	int myDamage = client.getVar(Varbits.CORP_DAMAGE);
	// sometimes hitsplats are applied after the damage counter has been reset
	if (myDamage > 0)
	{
		yourDamage = myDamage;
	}
	totalDamage += hitsplatApplied.getHitsplat().getAmount();
}
 

@Subscribe
private void onTilePing(TilePing event)
{
	if (config.pings())
	{
		final PartyData partyData = getPartyData(event.getMemberId());
		final Color color = partyData != null ? partyData.getColor() : Color.RED;
		pendingTilePings.add(new PartyTilePingData(event.getPoint(), color));
	}

	if (config.sounds())
	{
		WorldPoint point = event.getPoint();

		if (point.getPlane() != client.getPlane() || !WorldPoint.isInScene(client, point.getX(), point.getY()))
		{
			return;
		}

		clientThread.invoke(() -> client.playSoundEffect(SoundEffectID.SMITH_ANVIL_TINK));
	}
}
 

@Subscribe
public void onMenuOptionClicked(MenuOptionClicked menuOpt)
{
	if (!inHerbiboarArea || started || MenuOpcode.GAME_OBJECT_FIRST_OPTION != menuOpt.getMenuOpcode())
	{
		return;
	}

	switch (Text.removeTags(menuOpt.getTarget()))
	{
		case "Rock":
		case "Mushroom":
		case "Driftwood":
			startPoint = WorldPoint.fromScene(client, menuOpt.getParam0(), menuOpt.getParam1(), client.getPlane());
	}
}
 

@Subscribe
private void onStatChanged(StatChanged event)
{
	Skill skill = event.getSkill();

	if (skill != Skill.MAGIC || !config.showImbuedHeart() || !imbuedHeartClicked)
	{
		return;
	}

	int magicLvl = client.getRealSkillLevel(skill);
	int magicBoost = client.getBoostedSkillLevel(skill);
	int heartBoost = 1 + (int) (magicLvl * 0.1);

	if (magicBoost - magicLvl != heartBoost)
	{
		return;
	}

	imbuedHeartClicked = false;
	createGameTimer(IMBUEDHEART);
}
 

@Subscribe
private void onGameObjectSpawned(GameObjectSpawned event)
{
	final GameObject gameObject = event.getGameObject();

	if (!BURNER_LIT.contains(gameObject.getId()) && !BURNER_UNLIT.contains(gameObject.getId()))
	{
		if (PohIcons.getIcon(gameObject.getId()) != null)
		{
			pohObjects.put(gameObject, event.getTile());
		}

		return;
	}

	final double countdownTimer = 130.0; // Minimum amount of seconds a burner will light
	final double randomTimer = 30.0; // Minimum amount of seconds a burner will light
	incenseBurners.put(event.getTile(), new IncenseBurner(gameObject.getId(), countdownTimer, randomTimer, null));
}
 

@Subscribe
private void onConfigChanged(ConfigChanged event)
{
	if (event.getGroup().equals("statusorbs"))
	{
		switch (event.getKey())
		{
			case "replaceOrbText":
				if (!config.replaceOrbText())
				{
					resetRunOrbText();
				}
				break;
			case "dynamicHpHeart":
				if (config.dynamicHpHeart())
				{
					checkHealthIcon();
				}
				else
				{
					resetHealthIcon();
				}
				break;
		}
	}
}
 

@Subscribe
private void onWidgetLoaded(WidgetLoaded event)
{
	if (event.getGroupId() == WidgetID.BARROWS_PUZZLE_GROUP_ID)
	{
		final int answer = client.getWidget(WidgetInfo.BARROWS_FIRST_PUZZLE).getModelId() - 3;
		puzzleAnswer = null;

		for (WidgetInfo puzzleNode : POSSIBLE_SOLUTIONS)
		{
			final Widget widgetToCheck = client.getWidget(puzzleNode);

			if (widgetToCheck != null && widgetToCheck.getModelId() == answer)
			{
				puzzleAnswer = client.getWidget(puzzleNode);
				break;
			}
		}
	}
}
 

@Subscribe
private void onGameTick(GameTick event)
{
	if (isNotAtInfirmary())
	{
		return;
	}

	unhealedSoldiers.clear();

	for (NPC npc : client.getNpcs())
	{
		if (isUnhealedSoldierId(npc.getId()))
		{
			unhealedSoldiers.add(npc);
		}
	}
}
 

@Subscribe
private void onGameStateChanged(GameStateChanged event)
{
	switch (event.getGameState())
	{
		case LOGIN_SCREEN:
			checkForGameStateUpdate();
			return;
		case LOGGING_IN:
			loginFlag = true;
			break;
		case LOGGED_IN:
			if (loginFlag)
			{
				loginFlag = false;
				checkForGameStateUpdate();
			}

			break;
	}

	checkForAreaUpdate();
}
 

@Subscribe
public void onGameTick(GameTick event)
{
	if (client.getGameState() != GameState.LOGGED_IN)
	{
		return;
	}

	final Player player = client.getLocalPlayer();

	if (player == null
		|| player.getPlayerAppearance() == null
		|| client.getWidget(WidgetInfo.LOGIN_CLICK_TO_PLAY_SCREEN) != null
		|| client.getViewportWidget() == null)
	{
		return;
	}

	updateGear(panelMorph, player);
	updateGear(NEWLINE_SPLITTER.withKeyValueSeparator(':').split(config.set1()), player);
	updateGear(NEWLINE_SPLITTER.withKeyValueSeparator(':').split(config.set2()), player);
	updateGear(NEWLINE_SPLITTER.withKeyValueSeparator(':').split(config.set3()), player);
}
 

@Subscribe
private void onGameObjectChanged(GameObjectChanged event)
{
	if (!inMlm)
	{
		return;
	}

	GameObject previous = event.getPrevious();
	GameObject gameObject = event.getGameObject();

	rocks.remove(previous);
	if (ROCK_OBSTACLES.contains(gameObject.getId()))
	{
		rocks.add(gameObject);
	}

}
 

@Subscribe
void onItemContainerChanged(ItemContainerChanged event)
{
	final ItemContainer container = event.getItemContainer();

	if (!inMlm || !shouldUpdateOres || inventorySnapshot == null || container != client.getItemContainer(InventoryID.INVENTORY))
	{
		return;
	}

	// Build set of current inventory
	Multiset<Integer> current = HashMultiset.create();
	Arrays.stream(container.getItems())
		.filter(item -> MLM_ORE_TYPES.contains(item.getId()))
		.forEach(item -> current.add(item.getId(), item.getQuantity()));

	// Take the difference
	Multiset<Integer> delta = Multisets.difference(current, inventorySnapshot);

	// Update the session
	delta.forEachEntry(session::updateOreFound);
	inventorySnapshot = null;
	shouldUpdateOres = false;
}
 

/**
 * Loads players unlocks on login
 **/
@Subscribe
public void onGameStateChanged(GameStateChanged e)
{
	if (e.getGameState() == GameState.LOGGED_IN)
	{
		loadPlayerUnlocks();
		setupImages();
	}
	if (e.getGameState() == GameState.LOGIN_SCREEN)
	{
		itemEntries = null;
	}
}
 

@Subscribe
private void onInteractingChanged(InteractingChanged event)
{
	if (!isInGame() || getRole() != Role.HEALER)
	{
		return;
	}

	Actor source = event.getSource();

	if (source != client.getLocalPlayer())
	{
		return;
	}

	Actor opponent = event.getTarget();

	if (opponent == null)
	{
		if (lastInteracted != -1 && StringUtils.equalsIgnoreCase(poisonUsed, getRole().getListen(client)) && healers.containsKey(lastInteracted))
		{
			Healer healer = healers.get(lastInteracted);
			healer.setFoodRemaining(healer.getFoodRemaining() - 1);
			healer.setTimeLastPoisoned(Instant.now());
		}

		lastInteracted = -1;
		poisonUsed = null;
	}
	else if (StringUtils.equals(opponent.getName(), "Penance Healer"))
	{
		lastInteracted = ((NPC) opponent).getIndex();
	}

}
 

@Subscribe
public void onGameStateChanged(GameStateChanged event)
{
	if (event.getGameState() == GameState.LOGIN_SCREEN ||
		event.getGameState() == GameState.HOPPING)
	{
		npcsToMark.clear();
	}
}
 

@Subscribe
private void onUserSync(final UserSync event)
{
	final PartyMember localMember = partyService.getLocalMember();

	if (localMember != null && discordService.getCurrentUser() != null)
	{
		final DiscordUserInfo userInfo = new DiscordUserInfo(
			discordService.getCurrentUser().userId,
			discordService.getCurrentUser().avatar);

		userInfo.setMemberId(localMember.getMemberId());
		wsClient.send(userInfo);
	}
}
 

@Subscribe
public void onNpcSpawned(NpcSpawned event)
{
	if (isLibraryCustomer(event.getNpc().getId()))
	{
		npcsToMark.add(event.getNpc());
	}
}
 

@Subscribe
private void onConfigChanged(ConfigChanged event)
{
	if (event.getGroup().equals("banlist") && event.getKey().equals("bannedPlayers"))
	{
		manualBans.clear();

		String newValue = event.getNewValue();

		manualBans.addAll(Text.fromCSV(Text.standardize(newValue)));
	}
}
 

@Subscribe
private void onNpcSpawned(NpcSpawned npcSpawned)
{
	NPC npc = npcSpawned.getNpc();
	if (isTarget(npc, targetNames))
	{
		highlightedTargets.add(npc);
	}
}
 

@Subscribe
private void onNameableNameChanged(NameableNameChanged event)
{
	final Nameable nameable = event.getNameable();

	if (nameable instanceof Friend)
	{
		// Migrate a friend's note to their new display name
		final Friend friend = (Friend) nameable;
		if (friend.getName() != null && friend.getPrevName() != null)
		{
			migrateFriendTag(friend.getName(), friend.getPrevName());
		}
	}
}
 

@Subscribe
private void onMenuEntryAdded(MenuEntryAdded menuEntry)
{
	// At the moment, if the user disables quick lookup, the input listener gets disabled. Thus, isHotKeyPressed()
	// should always return false when quick lookup is disabled.
	// Replace the default option with "Search ..." when holding alt
	if (client.getGameState() != GameState.LOGGED_IN || !hotKeyPressed)
	{
		return;
	}

	final int widgetId = menuEntry.getParam1();
	final int groupId = WidgetInfo.TO_GROUP(widgetId);

	switch (groupId)
	{
		case WidgetID.BANK_GROUP_ID:
			// Don't show for view tabs and such
			if (WidgetInfo.TO_CHILD(widgetId) != WidgetInfo.BANK_ITEM_CONTAINER.getChildId())
			{
				break;
			}
		case WidgetID.INVENTORY_GROUP_ID:
		case WidgetID.BANK_INVENTORY_GROUP_ID:
		case WidgetID.GRAND_EXCHANGE_INVENTORY_GROUP_ID:
		case WidgetID.SHOP_INVENTORY_GROUP_ID:
			menuEntry.setOption(SEARCH_GRAND_EXCHANGE);
			menuEntry.setOpcode(MenuOpcode.RUNELITE.getId());
			menuEntry.setModified();
	}
}
 

@Subscribe
private void onDiscordJoinRequest(DiscordJoinRequest request)
{
	log.debug("Got discord join request {}", request);
	if (partyService.isOwner() && partyService.getMembers().isEmpty())
	{
		// First join, join also yourself
		partyService.changeParty(partyService.getLocalPartyId());
		updatePresence();
	}
}
 

@Subscribe
private void onScriptPostFired(ScriptPostFired event)
{
	if (event.getScriptId() != ScriptID.QUESTLIST_PROGRESS_LIST_SHOW)
	{
		return;
	}

	addQuestButtons();
}
 

@Subscribe
private void onGameStateChanged(GameStateChanged event)
{
	if (event.getGameState() == GameState.LOGIN_SCREEN || event.getGameState() == GameState.HOPPING)
	{
		implings.clear();
		implingCounterMap.clear();
	}
}