net.runelite.api.GameState Java Examples

@Override
protected void startUp()
{
	clientThread.invoke(() ->
	{
		if (client.getGameState().ordinal() < GameState.LOGIN_SCREEN.ordinal())
		{
			return false;
		}

		BufferedImage healthImg = spriteManager.getSprite(SpriteID.MINIMAP_ORB_HITPOINTS_ICON, 0);
		BufferedImage prayerImg = spriteManager.getSprite(SpriteID.MINIMAP_ORB_PRAYER_ICON, 0);
		BufferedImage energyImg = spriteManager.getSprite(SpriteID.MINIMAP_ORB_RUN_ICON, 0);
		BufferedImage combatImg = spriteManager.getSprite(SpriteID.MINIMAP_ORB_SPECIAL_ICON, 0);
		BufferedImage worldImg = spriteManager.getSprite(SpriteID.MINIMAP_ORB_WORLD_MAP_PLANET, 0);

		infoBoxManager.addInfoBox(new PlayerInfoCustomIndicator(healthImg, this, config, client, IndicatorType.HEALTH));
		infoBoxManager.addInfoBox(new PlayerInfoCustomIndicator(prayerImg, this, config, client, IndicatorType.PRAYER));
		infoBoxManager.addInfoBox(new PlayerInfoCustomIndicator(energyImg, this, config, client, IndicatorType.ENERGY));
		infoBoxManager.addInfoBox(new PlayerInfoCustomIndicator(combatImg, this, config, client, IndicatorType.SPECIAL));
		infoBoxManager.addInfoBox(new PlayerInfoCustomIndicator(worldImg, this, config, client, IndicatorType.WORLD));

		return true;
	});
}
 

@Subscribe
public void onGameStateChanged(GameStateChanged event)
{
	if (client.getGameState() == GameState.LOGGED_IN)
	{
		// skip event while the game decides if the player belongs in a raid or not
		if (client.getLocalPlayer() == null
			|| client.getLocalPlayer().getWorldLocation().equals(TEMP_LOCATION))
		{
			return;
		}

		checkInRaid = true;
	}
	else if (client.getGameState() == GameState.LOGIN_SCREEN
		|| client.getGameState() == GameState.CONNECTION_LOST)
	{
		loggedIn = false;
	}
	else if (client.getGameState() == GameState.HOPPING)
	{
		reset();
	}
}
 

@Subscribe
private void onGameStateChanged(GameStateChanged event)
{
	final GameState gameState = event.getGameState();

	switch (gameState)
	{
		case LOADING:
			abyssObjects.clear();
			break;
		case CONNECTION_LOST:
		case HOPPING:
		case LOGIN_SCREEN:
			darkMage = null;
			break;
		case LOGGED_IN:
			removeSwaps();
			handleSwaps();
			break;
	}
}
 

@Subscribe
public void onGameStateChanged(GameStateChanged event)
{
	if (event.getGameState() != GameState.LOGGED_IN)
	{
		keyManager.unregisterKeyListener(spellOneSwap);
		keyManager.unregisterKeyListener(spellTwoSwap);
		keyManager.unregisterKeyListener(spellThreeSwap);
		keyManager.unregisterKeyListener(spellFourSwap);
		keyManager.unregisterKeyListener(spellFiveSwap);
		keyManager.unregisterKeyListener(spellSixSwap);
		return;
	}
	keyManager.registerKeyListener(spellOneSwap);
	keyManager.registerKeyListener(spellTwoSwap);
	keyManager.registerKeyListener(spellThreeSwap);
	keyManager.registerKeyListener(spellFourSwap);
	keyManager.registerKeyListener(spellFiveSwap);
	keyManager.registerKeyListener(spellSixSwap);
}
 

@Test
public void testGtLt()
{
	when(client.getGameState()).thenReturn(GameState.LOGGED_IN);
	when(client.getModIcons()).thenReturn(new IndexedSprite[0]);
	when(client.createIndexedSprite()).thenReturn(mock(IndexedSprite.class));

	// Trip emoji loading
	GameStateChanged gameStateChanged = new GameStateChanged();
	gameStateChanged.setGameState(GameState.LOGGED_IN);
	emojiPlugin.onGameStateChanged(gameStateChanged);

	MessageNode messageNode = mock(MessageNode.class);
	when(messageNode.getValue()).thenReturn("<gt>:D<lt>");

	ChatMessage chatMessage = new ChatMessage();
	chatMessage.setType(ChatMessageType.PUBLICCHAT);
	chatMessage.setMessageNode(messageNode);

	emojiPlugin.onChatMessage(chatMessage);

	verify(messageNode).setRuneLiteFormatMessage("<img=10>");
}
 

@Subscribe
public void onGameStateChanged(GameStateChanged gameStateChanged)
{
	if (gameStateChanged.getGameState() != GameState.LOGGED_IN)
	{
		return;
	}

	spotPoints.clear();
	for (WorldPoint spot : CannonSpots.getCannonSpots())
	{
		if (WorldPoint.isInScene(client, spot.getX(), spot.getY()))
		{
			spotPoints.add(spot);
		}
	}
}
 

@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 onGameStateChanged(GameStateChanged gameStateChanged)
{
	if (gameStateChanged.getGameState() != GameState.LOGGED_IN)
	{
		return;
	}

	final EnumSet<WorldType> worldType = client.getWorldType();
	if (worldType.contains(WorldType.DEADMAN_TOURNAMENT))
	{
		hiscoreEndpoint = HiscoreEndpoint.TOURNAMENT;
	}
	else if (worldType.contains(WorldType.DEADMAN))
	{
		hiscoreEndpoint = HiscoreEndpoint.DEADMAN;
	}
	else if (worldType.contains(WorldType.LEAGUE))
	{
		hiscoreEndpoint = HiscoreEndpoint.LEAGUE;
	}
	else
	{
		hiscoreEndpoint = HiscoreEndpoint.NORMAL;
	}
}
 

@Test
public void checkCombatLogout()
{
	plugin.onInteractingChanged(new InteractingChanged(player, monster));
	when(player.getInteracting()).thenReturn(mock(Actor.class));
	plugin.onGameTick(new GameTick());

	// Logout
	when(client.getGameState()).thenReturn(GameState.LOGIN_SCREEN);
	GameStateChanged gameStateChanged = new GameStateChanged();
	gameStateChanged.setGameState(GameState.LOGIN_SCREEN);
	plugin.onGameStateChanged(gameStateChanged);

	// Log back in
	when(client.getGameState()).thenReturn(GameState.LOGGED_IN);
	gameStateChanged.setGameState(GameState.LOGGED_IN);
	plugin.onGameStateChanged(gameStateChanged);

	// Tick
	plugin.onInteractingChanged(new InteractingChanged(player, null));
	plugin.onGameTick(new GameTick());
	verify(notifier, times(0)).notify(any());
}
 

@Subscribe
private void onClientTick(ClientTick event)
{
	if (!config.raidsTimer()
		|| !client.getGameState().equals(GameState.LOGGED_IN)
		|| tooltip == null)
	{
		return;
	}

	final Point mousePosition = client.getMouseCanvasPosition();
	if (widgetOverlay.getBounds().contains(mousePosition.getX(), mousePosition.getY()))
	{
		tooltipManager.add(new Tooltip(tooltip));
	}
}
 

@Test
public void checkAnimationLogout()
{
	when(player.getAnimation()).thenReturn(AnimationID.WOODCUTTING_BRONZE);
	AnimationChanged animationChanged = new AnimationChanged();
	animationChanged.setActor(player);
	plugin.onAnimationChanged(animationChanged);
	plugin.onGameTick(new GameTick());

	// Logout
	when(client.getGameState()).thenReturn(GameState.LOGIN_SCREEN);
	GameStateChanged gameStateChanged = new GameStateChanged();
	gameStateChanged.setGameState(GameState.LOGIN_SCREEN);
	plugin.onGameStateChanged(gameStateChanged);

	// Log back in
	when(client.getGameState()).thenReturn(GameState.LOGGED_IN);
	gameStateChanged.setGameState(GameState.LOGGED_IN);
	plugin.onGameStateChanged(gameStateChanged);

	// Tick
	when(player.getAnimation()).thenReturn(AnimationID.IDLE);
	plugin.onAnimationChanged(animationChanged);
	plugin.onGameTick(new GameTick());
	verify(notifier, times(0)).notify(any());
}
 

private boolean shouldProcess(final KeyListener keyListener)
{
	if (client == null)
	{
		return true;
	}

	if (!(keyListener instanceof HotkeyListener))
	{
		return true;
	}

	final HotkeyListener hotkeyListener = (HotkeyListener) keyListener;

	if (hotkeyListener.isEnabledOnLogin())
	{
		return true;
	}

	return client.getGameState() != GameState.LOGIN_SCREEN;
}
 

@Override
public void startUp()
{
	addSwaps();
	loadCustomSwaps(config.customSwaps(), customSwaps);

	updateBuySellEntries();
	addBuySellEntries();

	updateWithdrawEntries();
	addWithdrawEntries();

	updateRemovedObjects();

	if (client.getGameState() == GameState.LOGGED_IN)
	{
		keyManager.registerKeyListener(ctrlHotkey);
		keyManager.registerKeyListener(hotkey);
	}
}
 

@Test
public void checkAnimationLogout()
{
	when(player.getAnimation()).thenReturn(AnimationID.WOODCUTTING_BRONZE);
	AnimationChanged animationChanged = new AnimationChanged();
	animationChanged.setActor(player);
	plugin.onAnimationChanged(animationChanged);
	plugin.onGameTick(GameTick.INSTANCE);

	// Logout
	when(client.getGameState()).thenReturn(GameState.LOGIN_SCREEN);
	GameStateChanged gameStateChanged = new GameStateChanged();
	gameStateChanged.setGameState(GameState.LOGIN_SCREEN);
	plugin.onGameStateChanged(gameStateChanged);

	// Log back in
	when(client.getGameState()).thenReturn(GameState.LOGGED_IN);
	gameStateChanged.setGameState(GameState.LOGGED_IN);
	plugin.onGameStateChanged(gameStateChanged);

	// Tick
	when(player.getAnimation()).thenReturn(AnimationID.IDLE);
	plugin.onAnimationChanged(animationChanged);
	plugin.onGameTick(GameTick.INSTANCE);
	verify(notifier, times(0)).notify(any());
}
 

@Override
protected void startUp()
{
	onLeagueWorld = false;

	clientThread.invoke(() ->
	{
		if (client.getGameState() == GameState.LOGGED_IN)
		{
			loadLeagueIcon();
			onLeagueWorld = isLeagueWorld(client.getWorld());
			if (onLeagueWorld)
			{
				setChatboxName(getNameChatbox());
			}
		}
	});
}
 

/**
 * Ping the current world for the ping overlay
 */
private void pingCurrentWorld()
{
	WorldResult worldResult = worldService.getWorlds();
	// There is no reason to ping the current world if not logged in, as the overlay doesn't draw
	if (worldResult == null || !config.displayPing() || client.getGameState() != GameState.LOGGED_IN)
	{
		return;
	}

	final World currentWorld = worldResult.findWorld(client.getWorld());
	if (currentWorld == null)
	{
		log.debug("unable to find current world: {}", client.getWorld());
		return;
	}

	currentPing = ping(currentWorld);
	log.trace("Ping for current world is: {}", currentPing);

	SwingUtilities.invokeLater(() -> panel.updatePing(currentWorld.getId(), currentPing));
}
 

private void checkRaidPresence(boolean force)
{
	if (client.getGameState() != GameState.LOGGED_IN)
	{
		return;
	}

	boolean setting = client.getVar(Varbits.IN_RAID) == 1;

	if (force || inRaidChambers != setting)
	{
		//A new instance is created when leaving the raid chambers instead of entering the raid chambers.
		//Entering the raid chambers will change the IN_RAID varbit but game objects spawn before the varbit change.
		if (!setting)
		{
			batsLocator = new BatsLocator(client);
		}

		inRaidChambers = setting;
	}
}
 

@Test
public void testOnChatMessage()
{
	when(client.getGameState()).thenReturn(GameState.LOGGED_IN);
	when(client.getModIcons()).thenReturn(new IndexedSprite[0]);
	when(client.createIndexedSprite()).thenReturn(mock(IndexedSprite.class));

	// Trip emoji loading
	GameStateChanged gameStateChanged = new GameStateChanged();
	gameStateChanged.setGameState(GameState.LOGGED_IN);
	emojiPlugin.onGameStateChanged(gameStateChanged);

	MessageNode messageNode = mock(MessageNode.class);
	// With chat recolor, message may be wrapped in col tags
	when(messageNode.getValue()).thenReturn("<col=ff0000>:) :) :)</col>");

	ChatMessage chatMessage = new ChatMessage();
	chatMessage.setType(ChatMessageType.PUBLICCHAT);
	chatMessage.setMessageNode(messageNode);

	emojiPlugin.onChatMessage(chatMessage);

	verify(messageNode).setRuneLiteFormatMessage("<col=ff0000><img=0> <img=0> <img=0></col>");
}
 

private void resetTimers()
{
	final Player local = client.getLocalPlayer();

	// Reset animation idle timer
	lastAnimating = null;
	if (client.getGameState() == GameState.LOGIN_SCREEN || local == null || local.getAnimation() != lastAnimation)
	{
		lastAnimation = IDLE;
	}

	// Reset interaction idle timer
	lastInteracting = null;
	if (client.getGameState() == GameState.LOGIN_SCREEN || local == null || local.getInteracting() != lastInteract)
	{
		lastInteract = null;
	}
}
 

@Override
protected void startUp() throws Exception
{
	if (client.getGameState() == GameState.LOGGED_IN)
	{
		clientThread.invokeLater(() ->
		{
			inPvp = client.getVar(Varbits.PVP_SPEC_ORB) == 1;
			if (!config.onShiftOnly() && !inPvp)
			{
				setDragDelay();
			}
		});
	}

	keyManager.registerKeyListener(this);
}
 

@Subscribe
public void onGrandExchangeOfferChanged(GrandExchangeOfferChanged offerEvent)
{
	final int slot = offerEvent.getSlot();
	final GrandExchangeOffer offer = offerEvent.getOffer();

	if (offer.getState() == GrandExchangeOfferState.EMPTY && client.getGameState() != GameState.LOGGED_IN)
	{
		// Trades are cleared by the client during LOGIN_SCREEN/HOPPING/LOGGING_IN, ignore those so we don't
		// zero and re-submit the trade on login as an update
		return;
	}

	log.debug("GE offer updated: state: {}, slot: {}, item: {}, qty: {}, login: {}",
		offer.getState(), slot, offer.getItemId(), offer.getQuantitySold(), loginBurstGeUpdates);

	ItemComposition offerItem = itemManager.getItemComposition(offer.getItemId());
	boolean shouldStack = offerItem.isStackable() || offer.getTotalQuantity() > 1;
	BufferedImage itemImage = itemManager.getImage(offer.getItemId(), offer.getTotalQuantity(), shouldStack);
	SwingUtilities.invokeLater(() -> panel.getOffersPanel().updateOffer(offerItem, itemImage, offer, slot));

	submitTrade(slot, offer);

	updateConfig(slot, offer);

	if (loginBurstGeUpdates && slot == GE_SLOTS - 1) // slots are sent sequentially on login; this is the last one
	{
		loginBurstGeUpdates = false;
	}
}
 

@Subscribe
public void onGameStateChanged(GameStateChanged event)
{
	// When the client starts it initializes the texture size based on the memory mode setting.
	// Don't set low memory before the login screen is ready to prevent loading the low detail textures,
	// which breaks the gpu plugin due to it requiring the 128x128px textures
	if (event.getGameState() == GameState.LOGIN_SCREEN)
	{
		client.changeMemoryMode(true);
	}
}
 

@Before
public void before()
{
	Guice.createInjector(BoundFieldModule.of(this)).injectMembers(this);

	when(client.getGameState()).thenReturn(GameState.LOGGED_IN);
	when(client.getMapRegions()).thenReturn(new int[]{14679});
}
 

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

@Before
public void setUp()
{
	Guice.createInjector(BoundFieldModule.of(this)).injectMembers(this);

	when(client.getGameState()).thenReturn(GameState.LOGGED_IN);
}
 

@Subscribe
public void onGameStateChanged(GameStateChanged e)
{
	if (e.getGameState() == GameState.LOGGING_IN)
	{
		currentFilterState = QuestState.ALL;
	}
}
 

@Subscribe
public void onGameStateChanged(final GameStateChanged event)
{
	if (event.getGameState() == GameState.LOADING && !client.isInInstancedRegion())
	{
		chestLooted = false;
	}
}
 

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

@Subscribe
private void onGameStateChanged(GameStateChanged ev)
{
	if (ev.getGameState() == GameState.HOPPING || ev.getGameState() == GameState.LOGIN_SCREEN)
	{
		ticksSinceHPRegen = -2; // For some reason this makes this accurate
		ticksSinceSpecRegen = 0;
		ticksSinceRunRegen = -1;
	}
}
 

@Subscribe
public void onGameStateChanged(GameStateChanged state)
{
	GameState gameState = state.getGameState();

	if (gameState == GameState.LOGIN_SCREEN || gameState == GameState.CONNECTION_LOST || gameState == GameState.HOPPING)
	{
		members.clear();
		resetCounter();

		joinMessages.clear();
	}
}