From 6c21b2e21b289afb2a59526017503533600faf12 Mon Sep 17 00:00:00 2001 From: Lotto <8920674+devLotto@users.noreply.github.com> Date: Wed, 25 Apr 2018 00:24:56 +0200 Subject: [PATCH] Add entity hider plugin --- .../main/java/net/runelite/api/Client.java | 22 +++ .../entityhider/EntityHiderConfig.java | 148 +++++++++++++++++ .../entityhider/EntityHiderPlugin.java | 109 +++++++++++++ .../mixins/EntityHiderBridgeMixin.java | 143 ++++++++++++++++ .../net/runelite/mixins/EntityHiderMixin.java | 152 ++++++++++++++++++ 5 files changed, 574 insertions(+) create mode 100644 runelite-client/src/main/java/net/runelite/client/plugins/entityhider/EntityHiderConfig.java create mode 100644 runelite-client/src/main/java/net/runelite/client/plugins/entityhider/EntityHiderPlugin.java create mode 100644 runelite-mixins/src/main/java/net/runelite/mixins/EntityHiderBridgeMixin.java create mode 100644 runelite-mixins/src/main/java/net/runelite/mixins/EntityHiderMixin.java 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 fbfe0d86e0..01c92b393f 100644 --- a/runelite-api/src/main/java/net/runelite/api/Client.java +++ b/runelite-api/src/main/java/net/runelite/api/Client.java @@ -389,4 +389,26 @@ public interface Client extends GameEngine void setInterpolateObjectAnimations(boolean interpolate); boolean isInInstancedRegion(); + + void setIsHidingEntities(boolean state); + + void setPlayersHidden(boolean state); + + void setPlayersHidden2D(boolean state); + + void setFriendsHidden(boolean state); + + void setClanMatesHidden(boolean state); + + void setLocalPlayerHidden(boolean state); + + void setLocalPlayerHidden2D(boolean state); + + void setNPCsHidden(boolean state); + + void setNPCsHidden2D(boolean state); + + void setAttackersHidden(boolean state); + + void setProjectilesHidden(boolean state); } diff --git a/runelite-client/src/main/java/net/runelite/client/plugins/entityhider/EntityHiderConfig.java b/runelite-client/src/main/java/net/runelite/client/plugins/entityhider/EntityHiderConfig.java new file mode 100644 index 0000000000..5703895eb7 --- /dev/null +++ b/runelite-client/src/main/java/net/runelite/client/plugins/entityhider/EntityHiderConfig.java @@ -0,0 +1,148 @@ +/* + * Copyright (c) 2018, Lotto + * 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 HOLDER 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.entityhider; + +import net.runelite.client.config.Config; +import net.runelite.client.config.ConfigGroup; +import net.runelite.client.config.ConfigItem; + +@ConfigGroup( + keyName = "entityhider", + name = "Entity Hider", + description = "Hides various entities such as players and NPCs" +) +public interface EntityHiderConfig extends Config +{ + @ConfigItem( + position = 1, + keyName = "hidePlayers", + name = "Hide Players", + description = "Configures whether or not players are hidden" + ) + default boolean hidePlayers() + { + return true; + } + + @ConfigItem( + position = 2, + keyName = "hidePlayers2D", + name = "Hide Players 2D", + description = "Configures whether or not players 2D elements are hidden" + ) + default boolean hidePlayers2D() + { + return true; + } + + @ConfigItem( + position = 3, + keyName = "hideFriends", + name = "Hide Friends", + description = "Configures whether or not friends are hidden" + ) + default boolean hideFriends() + { + return false; + } + + @ConfigItem( + position = 4, + keyName = "hideClanMates", + name = "Hide Clan Mates", + description = "Configures whether or not clan mates are hidden" + ) + default boolean hideClanMates() + { + return false; + } + + @ConfigItem( + position = 5, + keyName = "hideLocalPlayer", + name = "Hide Local Player", + description = "Configures whether or not the local player is hidden" + ) + default boolean hideLocalPlayer() + { + return false; + } + + @ConfigItem( + position = 6, + keyName = "hideLocalPlayer2D", + name = "Hide Local Player 2D", + description = "Configures whether or not the local player's 2D elements are hidden" + ) + default boolean hideLocalPlayer2D() + { + return false; + } + + @ConfigItem( + position = 7, + keyName = "hideNPCs", + name = "Hide NPCs", + description = "Configures whether or not NPCs are hidden" + ) + default boolean hideNPCs() + { + return true; + } + + @ConfigItem( + position = 8, + keyName = "hideNPCs2D", + name = "Hide NPCs 2D", + description = "Configures whether or not NPCs 2D elements are hidden" + ) + default boolean hideNPCs2D() + { + return true; + } + + @ConfigItem( + position = 9, + keyName = "hideAttackers", + name = "Hide Attackers", + description = "Configures whether or not NPCs/players attacking you are hidden" + ) + default boolean hideAttackers() + { + return false; + } + + @ConfigItem( + position = 10, + keyName = "hideProjectiles", + name = "Hide Projectiles", + description = "Configures whether or not projectiles are hidden" + ) + default boolean hideProjectiles() + { + return false; + } +} diff --git a/runelite-client/src/main/java/net/runelite/client/plugins/entityhider/EntityHiderPlugin.java b/runelite-client/src/main/java/net/runelite/client/plugins/entityhider/EntityHiderPlugin.java new file mode 100644 index 0000000000..be96f494af --- /dev/null +++ b/runelite-client/src/main/java/net/runelite/client/plugins/entityhider/EntityHiderPlugin.java @@ -0,0 +1,109 @@ +/* + * Copyright (c) 2018, Lotto + * 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 HOLDER 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.entityhider; + +import com.google.common.eventbus.Subscribe; +import com.google.inject.Provides; +import javax.inject.Inject; +import net.runelite.api.Client; +import net.runelite.api.events.ConfigChanged; +import net.runelite.client.config.ConfigManager; +import net.runelite.client.plugins.Plugin; +import net.runelite.client.plugins.PluginDescriptor; + +@PluginDescriptor( + name = "Entity Hider", + enabledByDefault = false +) +public class EntityHiderPlugin extends Plugin +{ + @Inject + private Client client; + + @Inject + private EntityHiderConfig config; + + @Provides + EntityHiderConfig provideConfig(ConfigManager configManager) + { + return configManager.getConfig(EntityHiderConfig.class); + } + + @Override + protected void startUp() + { + updateConfig(); + } + + @Subscribe + public void onConfigChanged(ConfigChanged e) + { + updateConfig(); + } + + private void updateConfig() + { + client.setIsHidingEntities(true); + + client.setPlayersHidden(config.hidePlayers()); + client.setPlayersHidden2D(config.hidePlayers2D()); + + client.setFriendsHidden(config.hideFriends()); + client.setClanMatesHidden(config.hideClanMates()); + + client.setLocalPlayerHidden(config.hideLocalPlayer()); + client.setLocalPlayerHidden2D(config.hideLocalPlayer2D()); + + client.setNPCsHidden(config.hideNPCs()); + client.setNPCsHidden2D(config.hideNPCs2D()); + + client.setAttackersHidden(config.hideAttackers()); + + client.setProjectilesHidden(config.hideProjectiles()); + } + + @Override + protected void shutDown() throws Exception + { + client.setIsHidingEntities(false); + + client.setPlayersHidden(false); + client.setPlayersHidden2D(false); + + client.setFriendsHidden(false); + client.setClanMatesHidden(false); + + client.setLocalPlayerHidden(false); + client.setLocalPlayerHidden2D(false); + + client.setNPCsHidden(false); + client.setNPCsHidden2D(false); + + client.setAttackersHidden(false); + + client.setProjectilesHidden(false); + } +} diff --git a/runelite-mixins/src/main/java/net/runelite/mixins/EntityHiderBridgeMixin.java b/runelite-mixins/src/main/java/net/runelite/mixins/EntityHiderBridgeMixin.java new file mode 100644 index 0000000000..959e9c41bc --- /dev/null +++ b/runelite-mixins/src/main/java/net/runelite/mixins/EntityHiderBridgeMixin.java @@ -0,0 +1,143 @@ +/* + * Copyright (c) 2018, Lotto + * 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.mixins; + +import net.runelite.api.mixins.Inject; +import net.runelite.api.mixins.Mixin; +import net.runelite.rs.api.RSClient; + +@Mixin(RSClient.class) +public abstract class EntityHiderBridgeMixin implements RSClient +{ + @Inject + public static boolean isHidingEntities; + + @Inject + public static boolean hidePlayers; + + @Inject + public static boolean hidePlayers2D; + + @Inject + public static boolean hideFriends; + + @Inject + public static boolean hideClanMates; + + @Inject + public static boolean hideLocalPlayer; + + @Inject + public static boolean hideLocalPlayer2D; + + @Inject + public static boolean hideNPCs; + + @Inject + public static boolean hideNPCs2D; + + @Inject + public static boolean hideAttackers; + + @Inject + public static boolean hideProjectiles; + + @Inject + @Override + public void setIsHidingEntities(boolean state) + { + isHidingEntities = state; + } + + @Inject + @Override + public void setPlayersHidden(boolean state) + { + hidePlayers = state; + } + + @Inject + @Override + public void setPlayersHidden2D(boolean state) + { + hidePlayers2D = state; + } + + @Inject + @Override + public void setFriendsHidden(boolean state) + { + hideFriends = state; + } + + @Inject + @Override + public void setClanMatesHidden(boolean state) + { + hideClanMates = state; + } + + @Inject + @Override + public void setLocalPlayerHidden(boolean state) + { + hideLocalPlayer = state; + } + + @Inject + @Override + public void setLocalPlayerHidden2D(boolean state) + { + hideLocalPlayer2D = state; + } + + @Inject + @Override + public void setNPCsHidden(boolean state) + { + hideNPCs = state; + } + + @Inject + @Override + public void setNPCsHidden2D(boolean state) + { + hideNPCs2D = state; + } + + @Inject + @Override + public void setAttackersHidden(boolean state) + { + hideAttackers = state; + } + + @Inject + @Override + public void setProjectilesHidden(boolean state) + { + hideProjectiles = state; + } +} diff --git a/runelite-mixins/src/main/java/net/runelite/mixins/EntityHiderMixin.java b/runelite-mixins/src/main/java/net/runelite/mixins/EntityHiderMixin.java new file mode 100644 index 0000000000..13719b1cbf --- /dev/null +++ b/runelite-mixins/src/main/java/net/runelite/mixins/EntityHiderMixin.java @@ -0,0 +1,152 @@ +/* + * Copyright (c) 2018, Lotto + * 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.mixins; + +import net.runelite.api.mixins.Copy; +import net.runelite.api.mixins.Inject; +import net.runelite.api.mixins.Mixin; +import net.runelite.api.mixins.Replace; +import net.runelite.api.mixins.Shadow; +import net.runelite.rs.api.RSActor; +import net.runelite.rs.api.RSClient; +import net.runelite.rs.api.RSNPC; +import net.runelite.rs.api.RSPlayer; +import net.runelite.rs.api.RSProjectile; +import net.runelite.rs.api.RSRegion; +import net.runelite.rs.api.RSRenderable; + +@Mixin(RSRegion.class) +public abstract class EntityHiderMixin implements RSRegion +{ + @Shadow("clientInstance") + private static RSClient client; + + @Shadow("isHidingEntities") + private static boolean isHidingEntities; + + @Shadow("hidePlayers") + private static boolean hidePlayers; + + @Shadow("hidePlayers2D") + private static boolean hidePlayers2D; + + @Shadow("hideFriends") + private static boolean hideFriends; + + @Shadow("hideClanMates") + private static boolean hideClanMates; + + @Shadow("hideLocalPlayer") + private static boolean hideLocalPlayer; + + @Shadow("hideLocalPlayer2D") + private static boolean hideLocalPlayer2D; + + @Shadow("hideNPCs") + private static boolean hideNPCs; + + @Shadow("hideNPCs2D") + private static boolean hideNPCs2D; + + @Shadow("hideAttackers") + private static boolean hideAttackers; + + @Shadow("hideProjectiles") + private static boolean hideProjectiles; + + @Copy("addEntityMarker") + abstract boolean addEntityMarker(int var1, int var2, int var3, int var4, int var5, int var6, int var7, int var8, RSRenderable renderable, int var10, boolean var11, int var12, int var13); + + @Replace("addEntityMarker") + boolean rl$addEntityMarker(int var1, int var2, int var3, int var4, int var5, int var6, int var7, int var8, RSRenderable renderable, int var10, boolean var11, int var12, int var13) + { + return shouldDraw(renderable, false) && addEntityMarker(var1, var2, var3, var4, var5, var6, var7, var8, renderable, var10, var11, var12, var13); + } + + @Copy("draw2DExtras") + private static void draw2DExtras(RSActor actor, int var1, int var2, int var3, int var4, int var5) + { + throw new RuntimeException(); + } + + @Replace("draw2DExtras") + private static void rl$draw2DExtras(RSActor actor, int var1, int var2, int var3, int var4, int var5) + { + if (shouldDraw(actor, true)) + { + draw2DExtras(actor, var1, var2, var3, var4, var5); + } + } + + @Inject + private static boolean shouldDraw(Object renderable, boolean drawingUI) + { + if (!isHidingEntities) + { + return true; + } + + if (renderable instanceof RSPlayer) + { + boolean local = drawingUI ? hideLocalPlayer2D : hideLocalPlayer; + boolean other = drawingUI ? hidePlayers2D : hidePlayers; + + if (renderable == client.getLocalPlayer() ? local : other) + { + RSPlayer player = (RSPlayer) renderable; + + if (!hideAttackers) + { + if (player.getInteracting() == client.getLocalPlayer()) + { + return true; + } + } + + return (!hideFriends && player.isFriend()) || (!hideClanMates && player.isClanMember()); + } + } + else if (renderable instanceof RSNPC) + { + RSNPC npc = (RSNPC) renderable; + + if (!hideAttackers) + { + if (npc.getInteracting() == client.getLocalPlayer()) + { + return true; + } + } + + return drawingUI ? !hideNPCs2D : !hideNPCs; + } + else if (renderable instanceof RSProjectile) + { + return !hideProjectiles; + } + + return true; + } +}