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 12ad028e42..aa6368c08f 100644 --- a/runelite-api/src/main/java/net/runelite/api/Client.java +++ b/runelite-api/src/main/java/net/runelite/api/Client.java @@ -130,6 +130,8 @@ public interface Client extends GameEngine int[] getWidgetSettings(); + int getSetting(Setting setting); + int getSetting(Varbits varbit); HashTable getComponentTable(); diff --git a/runelite-api/src/test/java/net/runelite/api/VarbitsTest.java b/runelite-api/src/main/java/net/runelite/api/Setting.java similarity index 53% rename from runelite-api/src/test/java/net/runelite/api/VarbitsTest.java rename to runelite-api/src/main/java/net/runelite/api/Setting.java index 4e899f8af7..8d8a124cf5 100644 --- a/runelite-api/src/test/java/net/runelite/api/VarbitsTest.java +++ b/runelite-api/src/main/java/net/runelite/api/Setting.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2017, Adam + * Copyright (c) 2018, Adam * All rights reserved. * * Redistribution and use in source and binary forms, with or without @@ -24,44 +24,17 @@ */ package net.runelite.api; -import org.junit.Assert; -import org.junit.Test; +import lombok.AllArgsConstructor; +import lombok.Getter; -public class VarbitsTest +@AllArgsConstructor +@Getter +public enum Setting { - @Test - public void testGet() - { - // 28 24 20 16 12 8 4 0 - int value = 0b1101_1110_1010_1101_1011_1110_1110_1111; + ATTACK_STYLE(43), - // Bit indexes are inclusive - // Small pouch is bits 0-2 - // Medium pouch is bits 3-8 - // Large pouch is bits 9-17 - // Giant pouch is bits 18-29 - Varbits small = Varbits.POUCH_SMALL; - Varbits med = Varbits.POUCH_MEDIUM; - Varbits large = Varbits.POUCH_LARGE; - Varbits giant = Varbits.POUCH_GIANT; + SPECIAL_ATTACK_PERCENT(300), + SPECIAL_ATTACK_ENABLED(301); - Assert.assertEquals(7, small.get(value)); - Assert.assertEquals(29, med.get(value)); - Assert.assertEquals(223, large.get(value)); - Assert.assertEquals(1963, giant.get(value)); - } - - @Test - public void testSet() - { - // 28 24 20 16 12 8 4 0 - int value = 0b1101_1110_1010_1101_1011_1110_1110_1111; - int mask = 0b0000_0000_0000_0011_1111_1110_0000_0000; // mask for large pouch - - Varbits large = Varbits.POUCH_LARGE; - - int newValue = large.set(value, 42); - int expect = (value & ~mask) | (42 << large.getLeastSignificantBit()); - Assert.assertEquals(expect, newValue); - } + private final int id; } diff --git a/runelite-api/src/main/java/net/runelite/api/Varbits.java b/runelite-api/src/main/java/net/runelite/api/Varbits.java index 006dd56180..72146fba4e 100644 --- a/runelite-api/src/main/java/net/runelite/api/Varbits.java +++ b/runelite-api/src/main/java/net/runelite/api/Varbits.java @@ -24,309 +24,194 @@ */ package net.runelite.api; +import lombok.AllArgsConstructor; +import lombok.Getter; + +@AllArgsConstructor +@Getter public enum Varbits { /* * If chatbox is transparent or not */ - TRANSPARANT_CHATBOX(4608, 1055, 9, 9), - SPLIT_CHAT(287, 0, 0), + TRANSPARANT_CHATBOX(4608), /** * Runecraft pouches */ - POUCH_SMALL(603, 486, 0, 2), - POUCH_MEDIUM(604, 486, 3, 8), - POUCH_LARGE(605, 486, 9, 17), - POUCH_GIANT(606, 486, 18, 29), + POUCH_SMALL(603), + POUCH_MEDIUM(604), + POUCH_LARGE(605), + POUCH_GIANT(606), /** * Runepouch */ - RUNE_POUCH_RUNE1(29, 1139, 0, 5), - RUNE_POUCH_RUNE2(1622, 1139, 6, 11), - RUNE_POUCH_RUNE3(1623, 1139, 12, 17), - RUNE_POUCH_AMOUNT1(1624, 1139, 18, 31), - RUNE_POUCH_AMOUNT2(1625, 1140, 0, 13), - RUNE_POUCH_AMOUNT3(1626, 1140, 14, 27), + RUNE_POUCH_RUNE1(29), + RUNE_POUCH_RUNE2(1622), + RUNE_POUCH_RUNE3(1623), + RUNE_POUCH_AMOUNT1(1624), + RUNE_POUCH_AMOUNT2(1625), + RUNE_POUCH_AMOUNT3(1626), /** * Prayers */ - PRAYER_THICK_SKIN(4104, 83, 0, 0), - PRAYER_BURST_OF_STRENGTH(4105, 83, 1, 1), - PRAYER_CLARITY_OF_THOUGHT(4106, 83, 2, 2), - PRAYER_SHARP_EYE(4122, 83, 18, 18), - PRAYER_MYSTIC_WILL(4123, 83, 19, 19), - PRAYER_ROCK_SKIN(4107, 83, 3, 3), - PRAYER_SUPERHUMAN_STRENGTH(4108, 83, 4, 4), - PRAYER_IMPROVED_REFLEXES(4109, 83, 5, 5), - PRAYER_RAPID_RESTORE(4110, 83, 6, 6), - PRAYER_RAPID_HEAL(4111, 83, 7, 7), - PRAYER_PROTECT_ITEM(4112, 83, 8, 8), - PRAYER_HAWK_EYE(4124, 83, 20, 20), - PRAYER_MYSTIC_LORE(4125, 83, 21, 21), - PRAYER_STEEL_SKIN(4113, 83, 9, 9), - PRAYER_ULTIMATE_STRENGTH(4114, 83, 10, 10), - PRAYER_INCREDIBLE_REFLEXES(4115, 83, 11, 11), - PRAYER_PROTECT_FROM_MAGIC(4116, 83, 12, 12), - PRAYER_PROTECT_FROM_MISSILES(4117, 83, 13, 13), - PRAYER_PROTECT_FROM_MELEE(4118, 83, 14, 14), - PRAYER_EAGLE_EYE(4126, 83, 22, 22), - PRAYER_MYSTIC_MIGHT(4127, 83, 23, 23), - PRAYER_RETRIBUTION(4119, 83, 15, 15), - PRAYER_REDEMPTION(4120, 83, 16, 16), - PRAYER_SMITE(4121, 83, 17, 17), - PRAYER_CHIVALRY(4128, 83, 25, 25), - PRAYER_PIETY(4129, 83, 26, 26), - PRAYER_PRESERVE(5466, 83, 28, 28), - PRAYER_RIGOUR(5464, 83, 24, 24), - PRAYER_AUGURY(5465, 83, 27, 27), + PRAYER_THICK_SKIN(4104), + PRAYER_BURST_OF_STRENGTH(4105), + PRAYER_CLARITY_OF_THOUGHT(4106), + PRAYER_SHARP_EYE(4122), + PRAYER_MYSTIC_WILL(4123), + PRAYER_ROCK_SKIN(4107), + PRAYER_SUPERHUMAN_STRENGTH(4108), + PRAYER_IMPROVED_REFLEXES(4109), + PRAYER_RAPID_RESTORE(4110), + PRAYER_RAPID_HEAL(4111), + PRAYER_PROTECT_ITEM(4112), + PRAYER_HAWK_EYE(4124), + PRAYER_MYSTIC_LORE(4125), + PRAYER_STEEL_SKIN(4113), + PRAYER_ULTIMATE_STRENGTH(4114), + PRAYER_INCREDIBLE_REFLEXES(4115), + PRAYER_PROTECT_FROM_MAGIC(4116), + PRAYER_PROTECT_FROM_MISSILES(4117), + PRAYER_PROTECT_FROM_MELEE(4118), + PRAYER_EAGLE_EYE(4126), + PRAYER_MYSTIC_MIGHT(4127), + PRAYER_RETRIBUTION(4119), + PRAYER_REDEMPTION(4120), + PRAYER_SMITE(4121), + PRAYER_CHIVALRY(4128), + PRAYER_PIETY(4129), + PRAYER_PRESERVE(5466), + PRAYER_RIGOUR(5464), + PRAYER_AUGURY(5465), /** * Diary Entries */ - DIARY_ARDOUGNE_EASY(4458, 1188, 10, 10), - DIARY_ARDOUGNE_MEDIUM(4459, 1188, 11, 11), - DIARY_ARDOUGNE_HARD(4460, 1188, 12, 12), - DIARY_ARDOUGNE_ELITE(4461, 1188, 13, 13), + DIARY_ARDOUGNE_EASY(4458), + DIARY_ARDOUGNE_MEDIUM(4459), + DIARY_ARDOUGNE_HARD(4460), + DIARY_ARDOUGNE_ELITE(4461), - DIARY_DESERT_EASY(4483, 1189, 2, 2), - DIARY_DESERT_MEDIUM(4484, 1189, 3, 3), - DIARY_DESERT_HARD(4485, 1189, 4, 4), - DIARY_DESERT_ELITE(4486, 1189, 5, 5), + DIARY_DESERT_EASY(4483), + DIARY_DESERT_MEDIUM(4484), + DIARY_DESERT_HARD(4485), + DIARY_DESERT_ELITE(4486), - DIARY_FALADOR_EASY(4462, 1188, 14, 14), - DIARY_FALADOR_MEDIUM(4463, 1188, 15, 15), - DIARY_FALADOR_HARD(4464, 1188, 16, 16), - DIARY_FALADOR_ELITE(4465, 1188, 17, 17), + DIARY_FALADOR_EASY(4462), + DIARY_FALADOR_MEDIUM(4463), + DIARY_FALADOR_HARD(4464), + DIARY_FALADOR_ELITE(4465), - DIARY_FREMENNIK_EASY(4491, 1189, 10, 10), - DIARY_FREMENNIK_MEDIUM(4492, 1189, 11, 11), - DIARY_FREMENNIK_HARD(4493, 1189, 12, 12), - DIARY_FREMENNIK_ELITE(4494, 1189, 13, 13), + DIARY_FREMENNIK_EASY(4491), + DIARY_FREMENNIK_MEDIUM(4492), + DIARY_FREMENNIK_HARD(4493), + DIARY_FREMENNIK_ELITE(4494), - DIARY_KANDARIN_EASY(4475, 1188, 26, 26), - DIARY_KANDARIN_MEDIUM(4476, 1188, 27, 27), - DIARY_KANDARIN_HARD(4477, 1188, 28, 28), - DIARY_KANDARIN_ELITE(4478, 1188, 29, 29), + DIARY_KANDARIN_EASY(4475), + DIARY_KANDARIN_MEDIUM(4476), + DIARY_KANDARIN_HARD(4477), + DIARY_KANDARIN_ELITE(4478), - DIARY_KARAMJA_EASY(3578, 1000, 30, 31), - DIARY_KARAMJA_MEDIUM(3599, 1001, 30, 31), - DIARY_KARAMJA_HARD(3611, 1002, 29, 30), - DIARY_KARAMJA_ELITE(4566, 1200, 7, 7), + DIARY_KARAMJA_EASY(3578), + DIARY_KARAMJA_MEDIUM(3599), + DIARY_KARAMJA_HARD(3611), + DIARY_KARAMJA_ELITE(4566), - DIARY_LUMBRIDGE_EASY(4495, 1189, 14, 14), - DIARY_LUMBRIDGE_MEDIUM(4496, 1189, 15, 15), - DIARY_LUMBRIDGE_HARD(4497, 1189, 16, 16), - DIARY_LUMBRIDGE_ELITE(4498, 1189, 17, 17), + DIARY_LUMBRIDGE_EASY(4495), + DIARY_LUMBRIDGE_MEDIUM(4496), + DIARY_LUMBRIDGE_HARD(4497), + DIARY_LUMBRIDGE_ELITE(4498), - DIARY_MORYTANIA_EASY(4487, 1189, 6, 6), - DIARY_MORYTANIA_MEDIUM(4488, 1189, 7, 7), - DIARY_MORYTANIA_HARD(4489, 1189, 8, 8), - DIARY_MORYTANIA_ELITE(4490, 1189, 9, 9), + DIARY_MORYTANIA_EASY(4487), + DIARY_MORYTANIA_MEDIUM(4488), + DIARY_MORYTANIA_HARD(4489), + DIARY_MORYTANIA_ELITE(4490), - DIARY_VARROCK_EASY(4479, 1188, 30, 30), - DIARY_VARROCK_MEDIUM(4480, 1188, 31, 31), - DIARY_VARROCK_HARD(4481, 1189, 0, 0), - DIARY_VARROCK_ELITE(4482, 1189, 1, 1), + DIARY_VARROCK_EASY(4479), + DIARY_VARROCK_MEDIUM(4480), + DIARY_VARROCK_HARD(4481), + DIARY_VARROCK_ELITE(4482), - DIARY_WESTERN_EASY(4471, 1188, 22, 22), - DIARY_WESTERN_MEDIUM(4472, 1188, 23, 23), - DIARY_WESTERN_HARD(4473, 1188, 24, 24), - DIARY_WESTERN_ELITE(4474, 1188, 25, 25), + DIARY_WESTERN_EASY(4471), + DIARY_WESTERN_MEDIUM(4472), + DIARY_WESTERN_HARD(4473), + DIARY_WESTERN_ELITE(4474), - DIARY_WILDERNESS_EASY(4466, 1188, 18, 18), - DIARY_WILDERNESS_MEDIUM(4467, 1188, 19, 19), - DIARY_WILDERNESS_HARD(4468, 1188, 20, 20), - DIARY_WILDERNESS_ELITE(4469, 1188, 21, 21), - - /** - * Special Attack - */ - SPECIAL_ATTACK_PERCENT(300, 0, 16), - SPECIAL_ATTACK_ENABLED(301, 0, 0), - - /** - * Poison - * Venom - 1,000,000 (6dmg/hit) - 1,000,008 (20 dmg/hit) - */ - POISON(102, 0, 5), - VENOM(102, 6, 9), - - /** - * Attack Style - */ - ATTACK_STYLE(43, 0, 7), + DIARY_WILDERNESS_EASY(4466), + DIARY_WILDERNESS_MEDIUM(4467), + DIARY_WILDERNESS_HARD(4468), + DIARY_WILDERNESS_ELITE(4469), /** * Equipped weapon type */ - EQUIPPED_WEAPON_TYPE(357, 843, 0, 5), + EQUIPPED_WEAPON_TYPE(357), /** * Defensive casting mode */ - DEFENSIVE_CASTING_MODE(2668, 439, 8, 8), + DEFENSIVE_CASTING_MODE(2668), /** * Options */ - SIDE_PANELS(4607, 1055, 8, 8), + SIDE_PANELS(4607), /** * Barbarian Assault */ - IN_GAME_BA(3923, 638, 12, 12), + IN_GAME_BA(3923), /** * Motherlode mine sack */ - SACK_NUMBER(5558, 375, 8, 15), + SACK_NUMBER(5558), /** * Experience drop color */ - EXPERIENCE_DROP_COLOR(4695, 1227, 6, 8), + EXPERIENCE_DROP_COLOR(4695), /** * Raids */ - IN_RAID(5432, 1431, 31, 31), + IN_RAID(5432), /** * Nightmare Zone */ - NMZ_ABSORPTION(3956, 1067, 5, 14), - NMZ_POINTS(3949, 1059, 0, 19), + NMZ_ABSORPTION(3956), + NMZ_POINTS(3949), /** * Blast Furnace */ - BLAST_FURNACE_COPPER_ORE(959, 549, 16, 23), - BLAST_FURNACE_TIN_ORE(950, 547, 8, 15), - BLAST_FURNACE_IRON_ORE(951, 547, 16, 23), - BLAST_FURNACE_COAL(949, 547, 0, 7), - BLAST_FURNACE_MITHRIL_ORE(952, 547, 24, 31), - BLAST_FURNACE_ADAMANTITE_ORE(953, 548, 0, 7), - BLAST_FURNACE_RUNITE_ORE(954, 548, 8, 15), - BLAST_FURNACE_SILVER_ORE(955, 548, 24, 31), - BLAST_FURNACE_GOLD_ORE(955, 548, 16, 23), + BLAST_FURNACE_COPPER_ORE(959), + BLAST_FURNACE_TIN_ORE(950), + BLAST_FURNACE_IRON_ORE(951), + BLAST_FURNACE_COAL(949), + BLAST_FURNACE_MITHRIL_ORE(952), + BLAST_FURNACE_ADAMANTITE_ORE(953), + BLAST_FURNACE_RUNITE_ORE(954), + BLAST_FURNACE_SILVER_ORE(956), + BLAST_FURNACE_GOLD_ORE(955), - BLAST_FURNACE_BRONZE_BAR(941, 545, 0, 7), - BLAST_FURNACE_IRON_BAR(942, 545, 8, 15), - BLAST_FURNACE_STEEL_BAR(943, 545, 16, 23), - BLAST_FURNACE_MITHRIL_BAR(944, 545, 24, 31), - BLAST_FURNACE_ADAMANTITE_BAR(945, 546, 0, 7), - BLAST_FURNACE_RUNITE_BAR(946, 546, 8, 15), - BLAST_FURNACE_SILVER_BAR(948, 546, 24, 31), - BLAST_FURNACE_GOLD_BAR(947, 546, 16, 23), + BLAST_FURNACE_BRONZE_BAR(941), + BLAST_FURNACE_IRON_BAR(942), + BLAST_FURNACE_STEEL_BAR(943), + BLAST_FURNACE_MITHRIL_BAR(944), + BLAST_FURNACE_ADAMANTITE_BAR(945), + BLAST_FURNACE_RUNITE_BAR(946), + BLAST_FURNACE_SILVER_BAR(948), + BLAST_FURNACE_GOLD_BAR(947), - BLAST_FURNACE_COFFER(5357, 795, 1, 31); + BLAST_FURNACE_COFFER(5357); /** * varbit id */ private final int id; - - /** - * index into settings - */ - private final int index; - private final int leastSignificantBit; - private final int mostSignificantBit; - - private Varbits(int index, int leastSignificantBit, int mostSignificantBit) - { - this(-1, index, leastSignificantBit, mostSignificantBit); - } - - private Varbits(int id, int index, int leastSignificantBit, int mostSignificantBit) - { - if (mostSignificantBit < leastSignificantBit) - { - throw new IllegalStateException("MSB < LSB"); - } - - this.id = id; - this.index = index; - this.leastSignificantBit = leastSignificantBit; - this.mostSignificantBit = mostSignificantBit; - } - - public int getId() - { - return id; - } - - public int getIndex() - { - return index; - } - - public int getLeastSignificantBit() - { - return leastSignificantBit; - } - - public int getMostSignificantBit() - { - return mostSignificantBit; - } - - /** - * Get the value of this varbit from the given int - * - * @param value - * @return - */ - public int get(int value) - { - int mask = getMax() - 1; - - return (value >> leastSignificantBit) & mask; - } - - /** - * Set the value of this varbit to a given int - * - * @param varbit The int to set the value on - * @param value The value to set - * @return - */ - public int set(int varbit, int value) - { - int mask = getMax() - 1; - - value &= mask; // Ensure new value is in range - - mask <<= leastSignificantBit; // Align mask to the correct place - - varbit &= ~mask; // And off existing value - - value <<= leastSignificantBit; // Align new value - varbit |= value; - return varbit; - } - - /** - * Get the maximum possible value for this varbit - * - * @return - */ - public int getMax() - { - return 1 << getNumberOfBits(); - } - - /** - * Get the number of bits of storage in this varbit - * - * @return - */ - public int getNumberOfBits() - { - // leastSignificantBit and mostSignificantBit are inclusive - return (mostSignificantBit - leastSignificantBit) + 1; - } } diff --git a/runelite-client/src/main/java/net/runelite/client/plugins/attackindicator/AttackIndicatorPlugin.java b/runelite-client/src/main/java/net/runelite/client/plugins/attackindicator/AttackIndicatorPlugin.java index c45edfd325..5a55256af3 100644 --- a/runelite-client/src/main/java/net/runelite/client/plugins/attackindicator/AttackIndicatorPlugin.java +++ b/runelite-client/src/main/java/net/runelite/client/plugins/attackindicator/AttackIndicatorPlugin.java @@ -35,6 +35,7 @@ import javax.inject.Inject; import lombok.extern.slf4j.Slf4j; import net.runelite.api.Client; import net.runelite.api.GameState; +import net.runelite.api.Setting; import net.runelite.api.Skill; import net.runelite.api.Varbits; import net.runelite.api.events.ConfigChanged; @@ -104,7 +105,7 @@ public class AttackIndicatorPlugin extends Plugin updateWarnedSkills(config.warnForMagic(), Skill.MAGIC); updateAttackStyle( client.getSetting(Varbits.EQUIPPED_WEAPON_TYPE), - client.getSetting(Varbits.ATTACK_STYLE), + client.getSetting(Setting.ATTACK_STYLE), client.getSetting(Varbits.DEFENSIVE_CASTING_MODE)); updateWarning(false); } @@ -160,9 +161,9 @@ public class AttackIndicatorPlugin extends Plugin @Subscribe public void onAttackStyleChange(VarbitChanged event) { - if (attackStyleVarbit == -1 || attackStyleVarbit != client.getSetting(Varbits.ATTACK_STYLE)) + if (attackStyleVarbit == -1 || attackStyleVarbit != client.getSetting(Setting.ATTACK_STYLE)) { - attackStyleVarbit = client.getSetting(Varbits.ATTACK_STYLE); + attackStyleVarbit = client.getSetting(Setting.ATTACK_STYLE); updateAttackStyle(client.getSetting(Varbits.EQUIPPED_WEAPON_TYPE), attackStyleVarbit, client.getSetting(Varbits.DEFENSIVE_CASTING_MODE)); updateWarning(false); @@ -175,7 +176,7 @@ public class AttackIndicatorPlugin extends Plugin if (equippedWeaponTypeVarbit == -1 || equippedWeaponTypeVarbit != client.getSetting(Varbits.EQUIPPED_WEAPON_TYPE)) { equippedWeaponTypeVarbit = client.getSetting(Varbits.EQUIPPED_WEAPON_TYPE); - updateAttackStyle(equippedWeaponTypeVarbit, client.getSetting(Varbits.ATTACK_STYLE), + updateAttackStyle(equippedWeaponTypeVarbit, client.getSetting(Setting.ATTACK_STYLE), client.getSetting(Varbits.DEFENSIVE_CASTING_MODE)); updateWarning(true); } @@ -187,7 +188,7 @@ public class AttackIndicatorPlugin extends Plugin if (castingModeVarbit == -1 || castingModeVarbit != client.getSetting(Varbits.DEFENSIVE_CASTING_MODE)) { castingModeVarbit = client.getSetting(Varbits.DEFENSIVE_CASTING_MODE); - updateAttackStyle(client.getSetting(Varbits.EQUIPPED_WEAPON_TYPE), client.getSetting(Varbits.ATTACK_STYLE), + updateAttackStyle(client.getSetting(Varbits.EQUIPPED_WEAPON_TYPE), client.getSetting(Setting.ATTACK_STYLE), castingModeVarbit); updateWarning(false); } diff --git a/runelite-client/src/main/java/net/runelite/client/plugins/specorb/SpecOrbOverlay.java b/runelite-client/src/main/java/net/runelite/client/plugins/specorb/SpecOrbOverlay.java index 7ad1a64a32..12de89e773 100644 --- a/runelite-client/src/main/java/net/runelite/client/plugins/specorb/SpecOrbOverlay.java +++ b/runelite-client/src/main/java/net/runelite/client/plugins/specorb/SpecOrbOverlay.java @@ -31,7 +31,7 @@ import javax.annotation.Nullable; import javax.inject.Inject; import net.runelite.api.Client; import net.runelite.api.Point; -import net.runelite.api.Varbits; +import net.runelite.api.Setting; import net.runelite.api.events.GameTick; import net.runelite.api.events.VarbitChanged; import net.runelite.api.widgets.Widget; @@ -133,14 +133,14 @@ public class SpecOrbOverlay extends Overlay graphics.setColor(SPECIAL_ORB_BACKGROUND_COLOR); - boolean specialAttackEnabled = client.getSetting(Varbits.SPECIAL_ATTACK_ENABLED) == 1; + boolean specialAttackEnabled = client.getSetting(Setting.SPECIAL_ATTACK_ENABLED) == 1; // draw relative to run orb Point runOrbPoint = runOrb.getCanvasLocation(); Point specOrbPoint = new Point(runOrbPoint.getX() + (client.isResized() ? SPEC_ORB_X_RESIZABLE : SPEC_ORB_X_FIXED), runOrbPoint.getY() + (client.isResized() ? SPEC_ORB_Y_RESIZABLE : SPEC_ORB_Y_FIXED)); - double specialPercent = client.getSetting(Varbits.SPECIAL_ATTACK_PERCENT) / 1000.0; + double specialPercent = client.getSetting(Setting.SPECIAL_ATTACK_PERCENT) / 1000.0; double specialRechargePercent = tickCounter / (double) RECHARGE_TIME_TICKS; OverlayUtil.drawMinimapOrb(graphics, specOrbPoint, specialPercent, @@ -153,7 +153,7 @@ public class SpecOrbOverlay extends Overlay public void onVarbitChanged(VarbitChanged event) { - int specialPercent = client.getSetting(Varbits.SPECIAL_ATTACK_PERCENT); + int specialPercent = client.getSetting(Setting.SPECIAL_ATTACK_PERCENT); if (lastSpecialPercent != specialPercent) { int diff = specialPercent - lastSpecialPercent; @@ -175,7 +175,7 @@ public class SpecOrbOverlay extends Overlay public void onTick(GameTick event) { // 1000 = 100%, 500 = 50%, 0 = 0% - int specialPercent = client.getSetting(Varbits.SPECIAL_ATTACK_PERCENT); + int specialPercent = client.getSetting(Setting.SPECIAL_ATTACK_PERCENT); // The recharge doesn't tick when at 100% if (specialPercent == 1000) { 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 8ff40aad6f..73a909e4f1 100644 --- a/runelite-mixins/src/main/java/net/runelite/mixins/RSClientMixin.java +++ b/runelite-mixins/src/main/java/net/runelite/mixins/RSClientMixin.java @@ -39,6 +39,7 @@ import net.runelite.api.Player; import net.runelite.api.Point; import net.runelite.api.Prayer; import net.runelite.api.Projectile; +import net.runelite.api.Setting; import net.runelite.api.Skill; import net.runelite.api.Varbits; import net.runelite.api.events.ExperienceChanged; @@ -210,11 +211,10 @@ public abstract class RSClientMixin implements RSClient @Inject @Override - public int getSetting(Varbits varbit) + public int getSetting(Setting setting) { int[] settings = getSettings(); - int value = settings[varbit.getIndex()]; - return varbit.get(value); + return settings[setting.getId()]; } @Inject diff --git a/runelite-mixins/src/main/java/net/runelite/mixins/VarbitMixin.java b/runelite-mixins/src/main/java/net/runelite/mixins/VarbitMixin.java new file mode 100644 index 0000000000..7df5e3dbb8 --- /dev/null +++ b/runelite-mixins/src/main/java/net/runelite/mixins/VarbitMixin.java @@ -0,0 +1,74 @@ +/* + * 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.mixins; + +import com.google.common.cache.Cache; +import com.google.common.cache.CacheBuilder; +import net.runelite.api.Varbits; +import net.runelite.api.mixins.Inject; +import net.runelite.api.mixins.Mixin; +import net.runelite.api.mixins.Shadow; +import net.runelite.rs.api.RSClient; +import net.runelite.rs.api.RSNodeCache; +import net.runelite.rs.api.RSVarbit; + +@Mixin(RSClient.class) +public abstract class VarbitMixin implements RSClient +{ + @Shadow("clientInstance") + private static RSClient client; + + @Inject + private Cache varbitCache = CacheBuilder.newBuilder() + .maximumSize(128) + .build(); + + @Inject + VarbitMixin() + { + } + + @Inject + @Override + public int getSetting(Varbits varbit) + { + int varbitId = varbit.getId(); + RSVarbit v = varbitCache.getIfPresent(varbitId); + if (v == null) + { + client.getVarbit(varbitId); // load varbit into cache + RSNodeCache varbits = client.getVarbitCache(); + v = (RSVarbit) varbits.get(varbitId); // get from cache + varbitCache.put(varbitId, v); + } + + int[] settings = getWidgetSettings(); + int value = settings[v.getIndex()]; + int lsb = v.getLeastSignificantBit(); + int msb = v.getMostSignificantBit(); + int mask = (1 << ((msb - lsb) + 1)) - 1; + return (value >> lsb) & mask; + } +} 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 26d686b6c1..8c951b5d53 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 @@ -451,4 +451,10 @@ public interface RSClient extends RSGameEngine, Client @Construct RSName createName(String name, RSJagexLoginType type); + + @Import("getVarbit") + int getVarbit(int varbitId); + + @Import("varbits") + RSNodeCache getVarbitCache(); } diff --git a/runescape-api/src/main/java/net/runelite/rs/api/RSNodeCache.java b/runescape-api/src/main/java/net/runelite/rs/api/RSNodeCache.java new file mode 100644 index 0000000000..88eb2b4cec --- /dev/null +++ b/runescape-api/src/main/java/net/runelite/rs/api/RSNodeCache.java @@ -0,0 +1,33 @@ +/* + * 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.rs.api; + +import net.runelite.mapping.Import; + +public interface RSNodeCache +{ + @Import("get") + RSCacheableNode get(long id); +} diff --git a/runescape-api/src/main/java/net/runelite/rs/api/RSVarbit.java b/runescape-api/src/main/java/net/runelite/rs/api/RSVarbit.java new file mode 100644 index 0000000000..94990d561e --- /dev/null +++ b/runescape-api/src/main/java/net/runelite/rs/api/RSVarbit.java @@ -0,0 +1,39 @@ +/* + * 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.rs.api; + +import net.runelite.mapping.Import; + +public interface RSVarbit extends RSCacheableNode +{ + @Import("configId") + int getIndex(); + + @Import("leastSignificantBit") + int getLeastSignificantBit(); + + @Import("mostSignificantBit") + int getMostSignificantBit(); +}