From 512d0f5ff14eee1314c611e9069f5386b86baf62 Mon Sep 17 00:00:00 2001 From: Adam Date: Fri, 21 Apr 2017 11:00:00 -0400 Subject: [PATCH] cache: add varbit definition and loader --- .../cache/definitions/VarbitDefinition.java | 73 +++++++++++++++++ .../definitions/loaders/VarbitLoader.java | 57 +++++++++++++ .../net/runelite/cache/UnderlayDumper.java | 2 +- .../java/net/runelite/cache/VarbitDumper.java | 80 +++++++++++++++++++ 4 files changed, 211 insertions(+), 1 deletion(-) create mode 100644 cache/src/main/java/net/runelite/cache/definitions/VarbitDefinition.java create mode 100644 cache/src/main/java/net/runelite/cache/definitions/loaders/VarbitLoader.java create mode 100644 cache/src/test/java/net/runelite/cache/VarbitDumper.java diff --git a/cache/src/main/java/net/runelite/cache/definitions/VarbitDefinition.java b/cache/src/main/java/net/runelite/cache/definitions/VarbitDefinition.java new file mode 100644 index 0000000000..8eac206d6e --- /dev/null +++ b/cache/src/main/java/net/runelite/cache/definitions/VarbitDefinition.java @@ -0,0 +1,73 @@ +/* + * Copyright (c) 2017, 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.cache.definitions; + +public class VarbitDefinition +{ + private int id; + private int index; + private int leastSignificantBit; + private int mostSignificantBit; + + public int getId() + { + return id; + } + + public void setId(int id) + { + this.id = id; + } + + public int getIndex() + { + return index; + } + + public void setIndex(int index) + { + this.index = index; + } + + public int getLeastSignificantBit() + { + return leastSignificantBit; + } + + public void setLeastSignificantBit(int leastSignificantBit) + { + this.leastSignificantBit = leastSignificantBit; + } + + public int getMostSignificantBit() + { + return mostSignificantBit; + } + + public void setMostSignificantBit(int mostSignificantBit) + { + this.mostSignificantBit = mostSignificantBit; + } +} diff --git a/cache/src/main/java/net/runelite/cache/definitions/loaders/VarbitLoader.java b/cache/src/main/java/net/runelite/cache/definitions/loaders/VarbitLoader.java new file mode 100644 index 0000000000..05d91afa90 --- /dev/null +++ b/cache/src/main/java/net/runelite/cache/definitions/loaders/VarbitLoader.java @@ -0,0 +1,57 @@ +/* + * Copyright (c) 2017, 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.cache.definitions.loaders; + +import net.runelite.cache.definitions.VarbitDefinition; +import net.runelite.cache.io.InputStream; + +public class VarbitLoader +{ + public VarbitDefinition load(int id, byte[] b) + { + VarbitDefinition def = new VarbitDefinition(); + InputStream is = new InputStream(b); + + def.setId(id); + + for (;;) + { + int opcode = is.readUnsignedByte(); + if (opcode == 0) + { + break; + } + + if (opcode == 1) + { + def.setIndex(is.readUnsignedShort()); + def.setLeastSignificantBit(is.readUnsignedByte()); + def.setMostSignificantBit(is.readUnsignedByte()); + } + } + + return def; + } +} diff --git a/cache/src/test/java/net/runelite/cache/UnderlayDumper.java b/cache/src/test/java/net/runelite/cache/UnderlayDumper.java index 909d95b6be..57d1545722 100644 --- a/cache/src/test/java/net/runelite/cache/UnderlayDumper.java +++ b/cache/src/test/java/net/runelite/cache/UnderlayDumper.java @@ -54,7 +54,7 @@ public class UnderlayDumper public void extract() throws IOException { java.io.File base = StoreLocation.LOCATION, - outDir = folder.newFile(); + outDir = folder.newFolder(); int count = 0; diff --git a/cache/src/test/java/net/runelite/cache/VarbitDumper.java b/cache/src/test/java/net/runelite/cache/VarbitDumper.java new file mode 100644 index 0000000000..433f367cdb --- /dev/null +++ b/cache/src/test/java/net/runelite/cache/VarbitDumper.java @@ -0,0 +1,80 @@ +/* + * Copyright (c) 2017, 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.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 net.runelite.cache.definitions.VarbitDefinition; +import net.runelite.cache.definitions.loaders.VarbitLoader; +import net.runelite.cache.fs.Archive; +import net.runelite.cache.fs.Index; +import net.runelite.cache.fs.Store; +import org.junit.Rule; +import org.junit.Test; +import org.junit.rules.TemporaryFolder; +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; + +public class VarbitDumper +{ + private static final Logger logger = LoggerFactory.getLogger(VarbitDumper.class); + + @Rule + public TemporaryFolder folder = StoreLocation.getTemporaryFolder(); + + private final Gson gson = new GsonBuilder().setPrettyPrinting().create(); + + @Test + public void extract() throws IOException + { + File base = StoreLocation.LOCATION, + outDir = folder.newFolder(); + + int count = 0; + + try (Store store = new Store(base)) + { + store.load(); + + Index index = store.getIndex(IndexType.CONFIGS); + Archive archive = index.getArchive(ConfigType.VARBIT.getId()); + + for (net.runelite.cache.fs.File file : archive.getFiles()) + { + VarbitLoader loader = new VarbitLoader(); + VarbitDefinition varbit = loader.load(file.getFileId(), file.getContents()); + + Files.write(gson.toJson(varbit), new File(outDir, file.getFileId() + ".json"), Charset.defaultCharset()); + ++count; + } + } + + logger.info("Dumped {} varbits to {}", count, outDir); + } +}