From 23997a814f0f7c35f62ad36d9b249f56f3ed7595 Mon Sep 17 00:00:00 2001 From: Trevor Date: Sat, 13 Jun 2020 10:18:28 -0400 Subject: [PATCH] cache: add healthbar dumper --- .../java/net/runelite/cache/ConfigType.java | 1 + .../definitions/HealthBarDefinition.java | 43 ++++++++ .../definitions/loaders/HealthBarLoader.java | 99 +++++++++++++++++++ .../net/runelite/cache/HealthBarDumper.java | 91 +++++++++++++++++ 4 files changed, 234 insertions(+) create mode 100644 cache/src/main/java/net/runelite/cache/definitions/HealthBarDefinition.java create mode 100644 cache/src/main/java/net/runelite/cache/definitions/loaders/HealthBarLoader.java create mode 100644 cache/src/test/java/net/runelite/cache/HealthBarDumper.java diff --git a/cache/src/main/java/net/runelite/cache/ConfigType.java b/cache/src/main/java/net/runelite/cache/ConfigType.java index 4ca51a0b33..971c9154d6 100644 --- a/cache/src/main/java/net/runelite/cache/ConfigType.java +++ b/cache/src/main/java/net/runelite/cache/ConfigType.java @@ -44,6 +44,7 @@ public enum ConfigType VARCLIENTSTRING(15), VARPLAYER(16), HITSPLAT(32), + HEALTHBAR(33), STRUCT(34), AREA(35); diff --git a/cache/src/main/java/net/runelite/cache/definitions/HealthBarDefinition.java b/cache/src/main/java/net/runelite/cache/definitions/HealthBarDefinition.java new file mode 100644 index 0000000000..970d9e8745 --- /dev/null +++ b/cache/src/main/java/net/runelite/cache/definitions/HealthBarDefinition.java @@ -0,0 +1,43 @@ +/* + * Copyright (c) 2020, Trevor + * 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.cache.definitions; + +import lombok.Data; + +@Data +public class HealthBarDefinition +{ + public int id; + public int field3276; + public int field3277; + public int field3278; + public int field3283; + public int field3272; + public int field3275; + public int healthBarFrontSpriteId; + public int healthBarBackSpriteId; + public int healthScale; + public int healthBarPadding; +} diff --git a/cache/src/main/java/net/runelite/cache/definitions/loaders/HealthBarLoader.java b/cache/src/main/java/net/runelite/cache/definitions/loaders/HealthBarLoader.java new file mode 100644 index 0000000000..c6e49ea88f --- /dev/null +++ b/cache/src/main/java/net/runelite/cache/definitions/loaders/HealthBarLoader.java @@ -0,0 +1,99 @@ +/* + * Copyright (c) 2020, Trevor + * 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.cache.definitions.loaders; + +import net.runelite.cache.definitions.HealthBarDefinition; +import net.runelite.cache.io.InputStream; + +public class HealthBarLoader +{ + public HealthBarDefinition load(int id, byte[] b) + { + HealthBarDefinition def = new HealthBarDefinition(); + InputStream is = new InputStream(b); + def.id = id; + + while (true) + { + int opcode = is.readUnsignedByte(); + if (opcode == 0) + { + break; + } + + this.decodeValues(opcode, def, is); + } + + return def; + } + + private void decodeValues(int opcode, HealthBarDefinition def, InputStream stream) + { + if (opcode == 1) + { + stream.readUnsignedShort(); + } + else if (opcode == 2) + { + def.field3277 = stream.readUnsignedByte(); + } + else if (opcode == 3) + { + def.field3278 = stream.readUnsignedByte(); + } + else if (opcode == 4) + { + def.field3283 = 0; + } + else if (opcode == 5) + { + def.field3275 = stream.readUnsignedShort(); + } + else if (opcode == 6) + { + stream.readUnsignedByte(); + } + else if (opcode == 7) + { + def.healthBarFrontSpriteId = stream.readBigSmart2(); + } + else if (opcode == 8) + { + def.healthBarBackSpriteId = stream.readBigSmart2(); + } + else if (opcode == 11) + { + def.field3283 = stream.readUnsignedShort(); + } + else if (opcode == 14) + { + def.healthScale = stream.readUnsignedByte(); + } + else if (opcode == 15) + { + def.healthBarPadding = stream.readUnsignedByte(); + } + } +} diff --git a/cache/src/test/java/net/runelite/cache/HealthBarDumper.java b/cache/src/test/java/net/runelite/cache/HealthBarDumper.java new file mode 100644 index 0000000000..3b27fc193e --- /dev/null +++ b/cache/src/test/java/net/runelite/cache/HealthBarDumper.java @@ -0,0 +1,91 @@ +/* + * Copyright (c) 2020, Trevor + * 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.cache; + +import com.google.common.io.Files; +import com.google.gson.Gson; +import com.google.gson.GsonBuilder; +import java.io.File; +import java.io.IOException; +import java.nio.charset.Charset; +import lombok.extern.slf4j.Slf4j; +import net.runelite.cache.definitions.HealthBarDefinition; +import net.runelite.cache.definitions.loaders.HealthBarLoader; +import net.runelite.cache.fs.Archive; +import net.runelite.cache.fs.ArchiveFiles; +import net.runelite.cache.fs.FSFile; +import net.runelite.cache.fs.Index; +import net.runelite.cache.fs.Storage; +import net.runelite.cache.fs.Store; +import org.junit.Ignore; +import org.junit.Rule; +import org.junit.Test; +import org.junit.rules.TemporaryFolder; + +@Slf4j +public class HealthBarDumper +{ + private final Gson gson = new GsonBuilder().setPrettyPrinting().create(); + + @Rule + public TemporaryFolder folder = StoreLocation.getTemporaryFolder(); + + @Test + @Ignore + public void test() throws IOException + { + File dumpDir = folder.newFolder("healthbars"); + int count = 0; + + try (Store store = new Store(StoreLocation.LOCATION)) + { + store.load(); + + Storage storage = store.getStorage(); + Index index = store.getIndex(IndexType.CONFIGS); + Archive archive = index.getArchive(ConfigType.HEALTHBAR.getId()); + + byte[] archiveData = storage.loadArchive(archive); + ArchiveFiles files = archive.getFiles(archiveData); + + HealthBarLoader loader = new HealthBarLoader(); + + for (FSFile file : files.getFiles()) + { + byte[] b = file.getContents(); + + HealthBarDefinition def = loader.load(file.getFileId(), b); + + if (def != null) + { + Files.asCharSink(new File(dumpDir, file.getFileId() + ".json"), Charset.defaultCharset()).write(gson.toJson(def)); + ++count; + } + } + } + + log.info("Dumped {} healthbars to {}", count, dumpDir); + } +}