diff --git a/runelite-api/src/main/java/net/runelite/api/Client.java b/runelite-api/src/main/java/net/runelite/api/Client.java index 681b167856..7bd2742df6 100644 --- a/runelite-api/src/main/java/net/runelite/api/Client.java +++ b/runelite-api/src/main/java/net/runelite/api/Client.java @@ -26,6 +26,7 @@ package net.runelite.api; import java.awt.Canvas; import java.awt.Dimension; +import java.util.EnumSet; import java.util.List; import java.util.Map; import javax.annotation.Nullable; @@ -416,4 +417,6 @@ public interface Client extends GameEngine void setTickCount(int tickCount); void setInventoryDragDelay(int delay); + + EnumSet getWorldType(); } diff --git a/runelite-client/src/main/java/net/runelite/client/game/HiscoreLoader.java b/runelite-client/src/main/java/net/runelite/client/game/HiscoreLoader.java new file mode 100644 index 0000000000..36b6024e35 --- /dev/null +++ b/runelite-client/src/main/java/net/runelite/client/game/HiscoreLoader.java @@ -0,0 +1,88 @@ +/* + * Copyright (c) 2018, Adam + * 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.game; + +import com.google.common.cache.CacheLoader; +import com.google.common.util.concurrent.ListenableFuture; +import com.google.common.util.concurrent.ListeningExecutorService; +import com.google.common.util.concurrent.MoreExecutors; +import java.io.IOException; +import java.util.concurrent.ScheduledExecutorService; +import lombok.extern.slf4j.Slf4j; +import static net.runelite.client.game.HiscoreManager.EMPTY; +import static net.runelite.client.game.HiscoreManager.NONE; +import net.runelite.http.api.hiscore.HiscoreClient; +import net.runelite.http.api.hiscore.HiscoreEndpoint; +import net.runelite.http.api.hiscore.HiscoreResult; + +@Slf4j +class HiscoreLoader extends CacheLoader +{ + private final ListeningExecutorService executorService; + private final HiscoreClient hiscoreClient; + + HiscoreLoader(ScheduledExecutorService executor, HiscoreClient client) + { + this.executorService = MoreExecutors.listeningDecorator(executor); + this.hiscoreClient = client; + } + + @Override + public HiscoreResult load(HiscoreManager.HiscoreKey hiscoreKey) throws Exception + { + return EMPTY; + } + + @Override + public ListenableFuture reload(HiscoreManager.HiscoreKey hiscoreKey, HiscoreResult oldValue) + { + log.debug("Submitting hiscore lookup for {} type {}", hiscoreKey.getUsername(), hiscoreKey.getType()); + + return executorService.submit(() -> fetch(hiscoreKey)); + } + + private HiscoreResult fetch(HiscoreManager.HiscoreKey hiscoreKey) + { + String username = hiscoreKey.getUsername(); + HiscoreEndpoint endpoint = hiscoreKey.getType(); + + try + { + HiscoreResult result = hiscoreClient.lookup(username, endpoint); + if (result == null) + { + return NONE; + } + return result; + } + catch (IOException ex) + { + log.warn("Unable to look up hiscore!", ex); + return NONE; + } + } + +} + diff --git a/runelite-client/src/main/java/net/runelite/client/game/HiscoreManager.java b/runelite-client/src/main/java/net/runelite/client/game/HiscoreManager.java new file mode 100644 index 0000000000..814ef62abf --- /dev/null +++ b/runelite-client/src/main/java/net/runelite/client/game/HiscoreManager.java @@ -0,0 +1,117 @@ +/* + * Copyright (c) 2018, Adam + * 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.game; + +import com.google.common.cache.CacheBuilder; +import com.google.common.cache.LoadingCache; +import java.io.IOException; +import java.util.concurrent.ScheduledExecutorService; +import java.util.concurrent.TimeUnit; +import javax.inject.Inject; +import javax.inject.Singleton; +import lombok.AllArgsConstructor; +import lombok.Data; +import lombok.extern.slf4j.Slf4j; +import net.runelite.api.Client; +import net.runelite.client.callback.ClientThread; +import net.runelite.http.api.hiscore.HiscoreClient; +import net.runelite.http.api.hiscore.HiscoreEndpoint; +import net.runelite.http.api.hiscore.HiscoreResult; + +@Singleton +@Slf4j +public class HiscoreManager +{ + @AllArgsConstructor + @Data + static class HiscoreKey + { + String username; + HiscoreEndpoint type; + } + + static final HiscoreResult EMPTY = new HiscoreResult(); + static final HiscoreResult NONE = new HiscoreResult(); + + private final HiscoreClient hiscoreClient = new HiscoreClient(); + private final LoadingCache hiscoreCache; + + @Inject + public HiscoreManager(Client client, ScheduledExecutorService executor, ClientThread clientThread) + { + hiscoreCache = CacheBuilder.newBuilder() + .maximumSize(128L) + .expireAfterWrite(1, TimeUnit.HOURS) + .build(new HiscoreLoader(executor, hiscoreClient)); + } + + /** + * Synchronously look up a players hiscore from a specified endpoint + * + * @param username Players username + * @param endpoint Hiscore endpoint + * @return HiscoreResult or null + * @throws IOException Upon error in fetching hiscore + */ + public HiscoreResult lookup(String username, HiscoreEndpoint endpoint) throws IOException + { + HiscoreKey hiscoreKey = new HiscoreKey(username, endpoint); + HiscoreResult hiscoreResult = hiscoreCache.getIfPresent(hiscoreKey); + if (hiscoreResult != null && hiscoreResult != EMPTY) + { + return hiscoreResult == NONE ? null : hiscoreResult; + } + + hiscoreResult = hiscoreClient.lookup(username, endpoint); + if (hiscoreResult == null) + { + hiscoreCache.put(hiscoreKey, NONE); + return null; + } + + hiscoreCache.put(hiscoreKey, hiscoreResult); + return hiscoreResult; + } + + /** + * Asynchronously look up a players hiscore from a specified endpoint + * + * @param username Players username + * @param endpoint Hiscore endpoint + * @return HiscoreResult or null + */ + public HiscoreResult lookupAsync(String username, HiscoreEndpoint endpoint) + { + HiscoreKey hiscoreKey = new HiscoreKey(username, endpoint); + HiscoreResult hiscoreResult = hiscoreCache.getIfPresent(hiscoreKey); + if (hiscoreResult != null && hiscoreResult != EMPTY) + { + return hiscoreResult == NONE ? null : hiscoreResult; + } + + hiscoreCache.refresh(hiscoreKey); + return null; + } +} diff --git a/runelite-client/src/main/java/net/runelite/client/plugins/opponentinfo/OpponentInfoOverlay.java b/runelite-client/src/main/java/net/runelite/client/plugins/opponentinfo/OpponentInfoOverlay.java index 5dac2b59b3..8b67fc28ce 100644 --- a/runelite-client/src/main/java/net/runelite/client/plugins/opponentinfo/OpponentInfoOverlay.java +++ b/runelite-client/src/main/java/net/runelite/client/plugins/opponentinfo/OpponentInfoOverlay.java @@ -38,6 +38,7 @@ import net.runelite.api.Client; import net.runelite.api.NPC; import net.runelite.api.Player; import net.runelite.api.Varbits; +import net.runelite.client.game.HiscoreManager; import net.runelite.client.ui.overlay.Overlay; import net.runelite.client.ui.overlay.OverlayPosition; import net.runelite.client.ui.overlay.OverlayPriority; @@ -45,6 +46,7 @@ import net.runelite.client.ui.overlay.components.PanelComponent; import net.runelite.client.ui.overlay.components.ProgressBarComponent; import net.runelite.client.ui.overlay.components.TitleComponent; import net.runelite.client.util.Text; +import net.runelite.http.api.hiscore.HiscoreResult; class OpponentInfoOverlay extends Overlay { @@ -53,6 +55,9 @@ class OpponentInfoOverlay extends Overlay private static final Duration WAIT = Duration.ofSeconds(3); private final Client client; + private final OpponentInfoPlugin opponentInfoPlugin; + private final HiscoreManager hiscoreManager; + private final NPC[] clientNpcs; private final PanelComponent panelComponent = new PanelComponent(); private final Map oppInfoHealth = OpponentInfoPlugin.loadNpcHealth(); @@ -65,9 +70,12 @@ class OpponentInfoOverlay extends Overlay private NPC lastOpponent; @Inject - private OpponentInfoOverlay(Client client) + private OpponentInfoOverlay(Client client, OpponentInfoPlugin opponentInfoPlugin, HiscoreManager hiscoreManager) { this.client = client; + this.opponentInfoPlugin = opponentInfoPlugin; + this.hiscoreManager = hiscoreManager; + this.clientNpcs = client.getCachedNPCs(); setPosition(OverlayPosition.TOP_LEFT); setPriority(OverlayPriority.HIGH); @@ -116,7 +124,24 @@ class OpponentInfoOverlay extends Overlay lastTime = Instant.now(); lastRatio = (float) opponent.getHealthRatio() / (float) opponent.getHealth(); opponentName = Text.removeTags(opponent.getName()); - lastMaxHealth = oppInfoHealth.get(opponentName + "_" + opponent.getCombatLevel()); + + lastMaxHealth = null; + if (opponent instanceof NPC) + { + lastMaxHealth = oppInfoHealth.get(opponentName + "_" + opponent.getCombatLevel()); + } + else if (opponent instanceof Player) + { + HiscoreResult hiscoreResult = hiscoreManager.lookupAsync(opponentName, opponentInfoPlugin.getHiscoreEndpoint()); + if (hiscoreResult != null) + { + int hp = hiscoreResult.getHitpoints().getLevel(); + if (hp > 0) + { + lastMaxHealth = hp; + } + } + } Actor opponentsOpponent = opponent.getInteracting(); if (opponentsOpponent != null diff --git a/runelite-client/src/main/java/net/runelite/client/plugins/opponentinfo/OpponentInfoPlugin.java b/runelite-client/src/main/java/net/runelite/client/plugins/opponentinfo/OpponentInfoPlugin.java index a92d272edb..9d3bd49f24 100644 --- a/runelite-client/src/main/java/net/runelite/client/plugins/opponentinfo/OpponentInfoPlugin.java +++ b/runelite-client/src/main/java/net/runelite/client/plugins/opponentinfo/OpponentInfoPlugin.java @@ -24,31 +24,69 @@ */ package net.runelite.client.plugins.opponentinfo; +import com.google.common.eventbus.Subscribe; import com.google.common.reflect.TypeToken; import com.google.gson.Gson; import java.io.InputStream; import java.io.InputStreamReader; import java.lang.reflect.Type; +import java.util.EnumSet; import java.util.Map; import javax.inject.Inject; +import lombok.AccessLevel; +import lombok.Getter; +import net.runelite.api.Client; +import net.runelite.api.GameState; +import net.runelite.api.WorldType; +import net.runelite.api.events.GameStateChanged; import net.runelite.client.plugins.Plugin; import net.runelite.client.plugins.PluginDescriptor; import net.runelite.client.ui.overlay.Overlay; +import net.runelite.http.api.hiscore.HiscoreEndpoint; @PluginDescriptor( name = "Opponent Information" ) public class OpponentInfoPlugin extends Plugin { + @Inject + private Client client; + @Inject private OpponentInfoOverlay overlay; + @Getter(AccessLevel.PACKAGE) + private HiscoreEndpoint hiscoreEndpoint = HiscoreEndpoint.NORMAL; + @Override public Overlay getOverlay() { return overlay; } + @Subscribe + public void onGameStateChanged(GameStateChanged gameStateChanged) + { + if (gameStateChanged.getGameState() != GameState.LOGGED_IN) + { + return; + } + + EnumSet worldType = client.getWorldType(); + if (worldType.contains(WorldType.DEADMAN)) + { + hiscoreEndpoint = HiscoreEndpoint.DEADMAN; + } + else if (worldType.contains(WorldType.SEASONAL_DEADMAN)) + { + hiscoreEndpoint = HiscoreEndpoint.SEASONAL_DEADMAN; + } + else + { + hiscoreEndpoint = HiscoreEndpoint.NORMAL; + } + } + public static Map loadNpcHealth() { Gson gson = new Gson(); diff --git a/runelite-mixins/src/main/java/net/runelite/mixins/RSClientMixin.java b/runelite-mixins/src/main/java/net/runelite/mixins/RSClientMixin.java index 806bb48d26..9ab7a5ebb4 100644 --- a/runelite-mixins/src/main/java/net/runelite/mixins/RSClientMixin.java +++ b/runelite-mixins/src/main/java/net/runelite/mixins/RSClientMixin.java @@ -25,6 +25,7 @@ package net.runelite.mixins; import java.util.ArrayList; +import java.util.EnumSet; import java.util.List; import javax.annotation.Nullable; import net.runelite.api.ChatMessageType; @@ -59,6 +60,7 @@ import net.runelite.api.Tile; import net.runelite.api.VarPlayer; import net.runelite.api.Varbits; import net.runelite.api.WidgetNode; +import net.runelite.api.WorldType; import net.runelite.api.coords.LocalPoint; import net.runelite.api.coords.WorldPoint; import net.runelite.api.events.BoostedLevelChanged; @@ -977,4 +979,12 @@ public abstract class RSClientMixin implements RSClient { tickCount = tick; } + + @Inject + @Override + public EnumSet getWorldType() + { + int flags = getFlags(); + return WorldType.fromMask(flags); + } } diff --git a/runescape-api/src/main/java/net/runelite/rs/api/RSClient.java b/runescape-api/src/main/java/net/runelite/rs/api/RSClient.java index a4604e2be5..be6811ded1 100644 --- a/runescape-api/src/main/java/net/runelite/rs/api/RSClient.java +++ b/runescape-api/src/main/java/net/runelite/rs/api/RSClient.java @@ -618,4 +618,7 @@ public interface RSClient extends RSGameEngine, Client @Import("itemPressedDuration") void setItemPressedDuration(int duration); + + @Import("flags") + int getFlags(); }