diff --git a/src/main/java/net/runelite/cache/IndexType.java b/src/main/java/net/runelite/cache/IndexType.java new file mode 100644 index 0000000000..51e12c8ae8 --- /dev/null +++ b/src/main/java/net/runelite/cache/IndexType.java @@ -0,0 +1,18 @@ +package net.runelite.cache; + +public enum IndexType +{ + SPRITE(8); + + private int id; + + IndexType(int id) + { + this.id = id; + } + + public int getNumber() + { + return id; + } +} \ No newline at end of file diff --git a/src/main/java/net/runelite/cache/definitions/Definition.java b/src/main/java/net/runelite/cache/definitions/Definition.java new file mode 100644 index 0000000000..6e52de526c --- /dev/null +++ b/src/main/java/net/runelite/cache/definitions/Definition.java @@ -0,0 +1,38 @@ +package net.runelite.cache.definitions; + +import net.runelite.cache.io.InputStream; + + +/** + * Created by Allen Kinzalow on 3/14/2015. + */ +public abstract class Definition { + + int definitionID; + + public Definition(int definitionID) { + this.definitionID = definitionID; + } + + //abstract OutputStream encode(OutputStream stream); + + public void decode(InputStream stream) { + while(true) { + int opcode = stream.readUnsignedByte(); + if(opcode == 0) { + return; + } + + this.decodeValues(opcode, stream); + } + } + + abstract void decodeValues(int opcode, InputStream stream); + + //public abstract void printDefinition(); + + public int getDefinitionID() { + return this.definitionID; + } + +} diff --git a/src/main/java/net/runelite/cache/definitions/ItemDefinition.java b/src/main/java/net/runelite/cache/definitions/ItemDefinition.java new file mode 100644 index 0000000000..133cf79497 --- /dev/null +++ b/src/main/java/net/runelite/cache/definitions/ItemDefinition.java @@ -0,0 +1,191 @@ +//package net.runelite.cache.definitions; +// +//import net.runelite.cache.io.InputStream; +//import net.runelite.cache.utils.StringUtilities; +// +///** +// * Created by Allen Kinzalow on 3/14/2015. +// */ +//public class ItemDefinition extends Definition { +// +// public final static int INDEX_ID = 2; +// public final static int ARCHIVE_ID = 10; +// +// public int resizeY; +// public int xan2d = 0; +// public int cost = 1; +// public int inventoryModel; +// public int resizeZ; +// public short[] colorFind; +// public short[] colorReplace; +// public short[] textureFind; +// public String name = "null"; +// public int zoom2d = 200000; +// public int yan2d = 0; +// public int zan2d = 0; +// public int maleOffset; +// public int yOffset2d = 0; +// public int stackable = 0; +// public int[] countCo; +// public boolean members = false; +// public String[] options; +// public String[] interfaceOptions; +// public int maleModel0; +// public int maleModel1; +// public short[] textureReplace; +// public int femaleModel1; +// public int femaleOffset; +// public int maleModel2; +// public int xOffset2d = 0; +// public int maleHeadModel; +// public int maleHeadModel2; +// public int femaleHeadModel; +// public int femaleHeadModel2; +// public int[] countObj; +// public int femaleModel2; +// public int notedID; +// public int femaleModel0; +// public int resizeX; +// public int notedTemplate; +// public int ambient; +// public int contrast; +// public int team; +// +// public ItemDefinition(int definitionID) { +// super(definitionID); +// this.options = new String[]{null, null, "Take", null, null}; +// this.interfaceOptions = new String[]{null, null, null, null, "Drop"}; +// this.maleModel0 = -1; +// this.maleModel1 = -1; +// this.maleOffset = 0; +// this.femaleModel0 = -1; +// this.femaleModel1 = -1; +// this.femaleOffset = 0; +// this.maleModel2 = -1; +// this.femaleModel2 = -1; +// this.maleHeadModel = -1; +// this.maleHeadModel2 = -1; +// this.femaleHeadModel = -1; +// this.femaleHeadModel2 = -1; +// this.notedID = -1; +// this.notedTemplate = -1; +// this.resizeX = 0; +// this.resizeY = 0; +// this.resizeZ = 0; +// this.ambient = 0; +// this.contrast = 0; +// this.team = 0; +// } +// +// @Override +// void decodeValues(int opcode, InputStream stream) { +// if (opcode == 1) { +// this.inventoryModel = stream.readUnsignedShort(); +// } else if (opcode == 2) { +// this.name = StringUtilities.readString_2(stream); +// } else if (opcode == 4) { +// this.zoom2d = stream.readUnsignedShort(); +// } else if (opcode == 5) { +// this.xan2d = stream.readUnsignedShort(); +// } else if (opcode == 6) { +// this.yan2d = stream.readUnsignedShort(); +// } else if (7 == opcode) { +// this.xOffset2d = stream.readUnsignedShort(); +// if (this.xOffset2d > 32767) { +// this.xOffset2d -= 65536; +// } +// } else if (8 == opcode) { +// this.yOffset2d = stream.readUnsignedShort(); +// if (this.yOffset2d > 32767) { +// this.yOffset2d -= 65536; +// } +// } else if (11 == opcode) { +// this.stackable = 1; +// } else if (opcode == 12) { +// this.cost = stream.readInt(); +// } else if (16 == opcode) { +// this.members = true; +// } else if (opcode == 23) { +// this.maleModel0 = stream.readUnsignedShort(); +// this.maleOffset = stream.readUnsignedByte(); +// } else if (opcode == 24) { +// this.maleModel1 = stream.readUnsignedShort(); +// } else if (25 == opcode) { +// this.femaleModel0 = stream.readUnsignedShort(); +// this.femaleOffset = stream.readUnsignedByte(); +// } else if (26 == opcode) { +// this.femaleModel1 = stream.readUnsignedShort(); +// } else if (opcode >= 30 && opcode < 35) { +// this.options[opcode - 30] = StringUtilities.readString_2(stream); +// if (this.options[opcode - 30].equalsIgnoreCase("Hidden")) { +// this.options[opcode - 30] = null; +// } +// } else if (opcode >= 35 && opcode < 40) { +// this.interfaceOptions[opcode - 35] = StringUtilities.readString_2(stream); +// } else { +// int var4; +// int var5; +// if (opcode == 40) { +// var5 = stream.readUnsignedByte(); +// this.colorFind = new short[var5]; +// this.colorReplace = new short[var5]; +// +// for (var4 = 0; var4 < var5; ++var4) { +// this.colorFind[var4] = (short) stream.readUnsignedShort(); +// this.colorReplace[var4] = (short) stream.readUnsignedShort(); +// } +// +// } else if (41 != opcode) { +// if (opcode == 78) { +// this.maleModel2 = stream.readUnsignedShort(); +// } else if (opcode == 79) { +// this.femaleModel2 = stream.readUnsignedShort(); +// } else if (90 == opcode) { +// this.maleHeadModel = stream.readUnsignedShort(); +// } else if (91 == opcode) { +// this.femaleHeadModel = stream.readUnsignedShort(); +// } else if (92 == opcode) { +// this.maleHeadModel2 = stream.readUnsignedShort(); +// } else if (opcode == 93) { +// this.femaleHeadModel2 = stream.readUnsignedShort(); +// } else if (opcode == 95) { +// this.zan2d = stream.readUnsignedShort(); +// } else if (97 == opcode) { +// this.notedID = stream.readUnsignedShort(); +// } else if (98 == opcode) { +// this.notedTemplate = stream.readUnsignedShort(); +// } else if (opcode >= 100 && opcode < 110) { +// if (this.countObj == null) { +// this.countObj = new int[10]; +// this.countCo = new int[10]; +// } +// +// this.countObj[opcode - 100] = stream.readUnsignedShort(); +// this.countCo[opcode - 100] = stream.readUnsignedShort(); +// } else if (110 == opcode) { +// this.resizeX = stream.readUnsignedShort(); +// } else if (opcode == 111) { +// this.resizeY = stream.readUnsignedShort(); +// } else if (opcode == 112) { +// this.resizeZ = stream.readUnsignedShort(); +// } else if (opcode == 113) { +// this.ambient = stream.readByte(); +// } else if (114 == opcode) { +// this.contrast = stream.readByte(); +// } else if (115 == opcode) { +// this.team = stream.readUnsignedByte(); +// } +// } else { +// var5 = stream.readUnsignedByte(); +// this.textureFind = new short[var5]; +// this.textureReplace = new short[var5]; +// +// for (var4 = 0; var4 < var5; ++var4) { +// this.textureFind[var4] = (short) stream.readUnsignedShort(); +// this.textureReplace[var4] = (short) stream.readUnsignedShort(); +// } +// +// } +// } +// } +//} diff --git a/src/main/java/net/runelite/cache/definitions/NPCDefinition.java b/src/main/java/net/runelite/cache/definitions/NPCDefinition.java new file mode 100644 index 0000000000..b0a9b4a8e6 --- /dev/null +++ b/src/main/java/net/runelite/cache/definitions/NPCDefinition.java @@ -0,0 +1,164 @@ +//package net.runelite.cache.definitions; +// +//import net.runelite.cache.io.InputStream; +//import net.runelite.cache.utils.StringUtilities; +// +///** +// * Created by Allen Kinzalow on 3/15/2015. +// */ +//public class NPCDefinition extends Definition { +// +// public final static int INDEX_ID = 2; +// public final static int ARCHIVE_ID = 9; +// +// public short[] recolorToFind; +// public int anInt2156 = 32; +// public String name = "null"; +// public short[] recolorToReplace; +// public int[] models; +// public int[] models_2; +// public int stanceAnimation = -1; +// public int anInt2165 = -1; +// public int tileSpacesOccupied = 1; +// public int walkAnimation = -1; +// public short[] retextureToReplace; +// public int rotate90RightAnimation = -1; +// public boolean aBool2170 = true; +// public int resizeX = 128; +// public int contrast = 0; +// public int rotate180Animation = -1; +// public int anInt2174 = -1; +// public String[] options = new String[5]; +// public boolean renderOnMinimap = true; +// public int combatLevel = -1; +// public int rotate90LeftAnimation = -1; +// public int resizeY = 128; +// public boolean hasRenderPriority = false; +// public int ambient = 0; +// public int headIcon = -1; +// public int anInt2184 = 30; +// public int[] anIntArray2185; +// public short[] retextureToFind; +// public int anInt2187 = -1; +// public boolean isClickable = true; +// public int anInt2189 = -1; +// public boolean aBool2190 = false; +// +// public NPCDefinition(int definitionID) { +// super(definitionID); +// } +// +// @Override +// void decodeValues(int opcode, InputStream stream) { +// int length; +// int index; +// if(1 == opcode) { +// length = stream.readUnsignedByte(); +// this.models = new int[length]; +// +// for(index = 0; index < length; ++index) { +// this.models[index] = stream.readUnsignedShort(); +// } +// +// } else if(2 == opcode) { +// this.name = StringUtilities.readString_2(stream); +// } else if(12 == opcode) { +// this.tileSpacesOccupied = stream.readUnsignedShort(); +// } else if(opcode == 13) { +// this.stanceAnimation = stream.readUnsignedShort(); +// } else if(opcode == 14) { +// this.walkAnimation = stream.readUnsignedShort(); +// } else if(15 == opcode) { +// this.anInt2165 = stream.readUnsignedShort(); +// } else if(opcode == 16) { +// this.anInt2189 = stream.readUnsignedShort(); +// } else if(17 == opcode) { +// this.walkAnimation = stream.readUnsignedShort(); +// this.rotate180Animation = stream.readUnsignedShort(); +// this.rotate90RightAnimation = stream.readUnsignedShort(); +// this.rotate90LeftAnimation = stream.readUnsignedShort(); +// } else if(opcode >= 30 && opcode < 35) { +// this.options[opcode - 30] = StringUtilities.readString_2(stream); +// if(this.options[opcode - 30].equalsIgnoreCase("Hidden")) { +// this.options[opcode - 30] = null; +// } +// } else if(opcode == 40) { +// length = stream.readUnsignedByte(); +// this.recolorToFind = new short[length]; +// this.recolorToReplace = new short[length]; +// +// for(index = 0; index < length; ++index) { +// this.recolorToFind[index] = (short)stream.readUnsignedShort(); +// this.recolorToReplace[index] = (short)stream.readUnsignedShort(); +// } +// +// } else if(opcode == 41) { +// length = stream.readUnsignedByte(); +// this.retextureToFind = new short[length]; +// this.retextureToReplace = new short[length]; +// +// for(index = 0; index < length; ++index) { +// this.retextureToFind[index] = (short)stream.readUnsignedShort(); +// this.retextureToReplace[index] = (short)stream.readUnsignedShort(); +// } +// +// } else if(60 != opcode) { +// if(opcode == 93) { +// this.renderOnMinimap = false; +// } else if(95 == opcode) { +// this.combatLevel = stream.readUnsignedShort(); +// } else if(97 == opcode) { +// this.resizeX = stream.readUnsignedShort(); +// } else if(98 == opcode) { +// this.resizeY = stream.readUnsignedShort(); +// } else if(opcode == 99) { +// this.hasRenderPriority = true; +// } else if(100 == opcode) { +// this.ambient = stream.readByte(); +// } else if(101 == opcode) { +// this.contrast = stream.readByte(); +// } else if(opcode == 102) { +// this.headIcon = stream.readUnsignedShort(); +// } else if(103 == opcode) { +// this.anInt2156 = stream.readUnsignedShort(); +// } else if(opcode == 106) { +// this.anInt2174 = stream.readUnsignedShort(); +// if('\uffff' == this.anInt2174) { +// this.anInt2174 = -1; +// } +// +// this.anInt2187 = stream.readUnsignedShort(); +// if('\uffff' == this.anInt2187) { +// this.anInt2187 = -40212193; +// } +// +// length = stream.readUnsignedByte(); +// this.anIntArray2185 = new int[length + 1]; +// +// for(index = 0; index <= length; ++index) { +// this.anIntArray2185[index] = stream.readUnsignedShort(); +// if(this.anIntArray2185[index] == '\uffff') { +// this.anIntArray2185[index] = -1; +// } +// } +// +// } else if(107 == opcode) { +// this.isClickable = false; +// } else if(opcode == 109) { +// this.aBool2170 = false; +// } else if(opcode == 111) { +// this.aBool2190 = true; +// } else if(opcode == 112) { +// this.anInt2184 = stream.readUnsignedByte(); +// } +// } else { +// length = stream.readUnsignedByte(); +// this.models_2 = new int[length]; +// +// for(index = 0; index < length; ++index) { +// this.models_2[index] = stream.readUnsignedShort(); +// } +// +// } +// } +//} diff --git a/src/main/java/net/runelite/cache/definitions/SpriteDefinition.java b/src/main/java/net/runelite/cache/definitions/SpriteDefinition.java new file mode 100644 index 0000000000..e06115880a --- /dev/null +++ b/src/main/java/net/runelite/cache/definitions/SpriteDefinition.java @@ -0,0 +1,141 @@ +package net.runelite.cache.definitions; + +import net.runelite.cache.io.InputStream; + +/** + * Created by Allen Kinzalow on 3/15/2015. + */ +public class SpriteDefinition extends Definition { + + int offsetX; + int offsetY; + int width; + int height; + int[] palette; + byte[] pixels; + int maxWidth; + int maxHeight; + + public static int paletteChildCount; + public static int[] loadedSpriteOffsetX; + public static int[] loadedSpriteOffsetY; + public static int[] loadedSpriteWidth; + public static int[] loadedSpriteHeight; + public static byte[][] loadedSpritePixels; + public static int[] loadedPalette; + public static int loadedSpriteMaxWidth; + public static int loadedSpriteMaxHeight; + + public SpriteDefinition(int definitionID) { + super(definitionID); + } + + @Override + public void decode(InputStream stream) { + stream.setOffset(stream.getLength() - 2); + paletteChildCount = stream.readUnsignedShort(); + loadedSpriteOffsetX = new int[paletteChildCount ]; + loadedSpriteOffsetY = new int[paletteChildCount]; + loadedSpriteWidth = new int[paletteChildCount]; + loadedSpriteHeight = new int[paletteChildCount]; + loadedSpritePixels = new byte[paletteChildCount][]; + stream.setOffset(stream.getLength() - 7 - paletteChildCount * 8); + loadedSpriteMaxWidth = stream.readUnsignedShort(); + loadedSpriteMaxHeight = stream.readUnsignedShort(); + int var3 = (stream.readUnsignedByte() & 255) + 1; + + int spriteIndex; + for(spriteIndex = 0; spriteIndex < paletteChildCount; ++spriteIndex) { + loadedSpriteOffsetX[spriteIndex] = stream.readUnsignedShort(); + } + + for(spriteIndex = 0; spriteIndex < paletteChildCount; ++spriteIndex) { + loadedSpriteOffsetY[spriteIndex] = stream.readUnsignedShort(); + } + + for(spriteIndex = 0; spriteIndex < paletteChildCount; ++spriteIndex) { + loadedSpriteWidth[spriteIndex] = stream.readUnsignedShort(); + } + + for(spriteIndex = 0; spriteIndex < paletteChildCount; ++spriteIndex) { + loadedSpriteHeight[spriteIndex] = stream.readUnsignedShort(); + } + + stream.setOffset(stream.getLength() - 7 - paletteChildCount * 8 - (var3 - 1) * 3); + loadedPalette = new int[var3]; + + for(spriteIndex = 1; spriteIndex < var3; ++spriteIndex) { + loadedPalette[spriteIndex] = stream.read24BitInt(); + if(0 == loadedPalette[spriteIndex]) { + loadedPalette[spriteIndex] = 1; + } + } + + stream.setOffset(0); + + for(spriteIndex = 0; spriteIndex < paletteChildCount; ++spriteIndex) { + int width = loadedSpriteWidth[spriteIndex]; + int height = loadedSpriteHeight[spriteIndex]; + int dimmension = width * height; + byte[] loadPixels = new byte[dimmension]; + loadedSpritePixels[spriteIndex] = loadPixels; + int var4 = stream.readUnsignedByte(); + int var5; + if(var4 == 0) { + for(var5 = 0; var5 < dimmension; ++var5) { + loadPixels[var5] = (byte)stream.readByte(); + } + } else if(1 == var4) { + for(var5 = 0; var5 < width; ++var5) { + for(int var8 = 0; var8 < height; ++var8) { + loadPixels[width * var8 + var5] = (byte)stream.readByte(); + } + } + } + } + } + + public static SpriteDefinition getLastLoadedPaletteSprite() { + SpriteDefinition paletteSprite = new SpriteDefinition(0); + paletteSprite.maxWidth = loadedSpriteMaxWidth; + paletteSprite.maxHeight = loadedSpriteMaxHeight; + paletteSprite.offsetX = loadedSpriteOffsetX[0]; + paletteSprite.offsetY = loadedSpriteOffsetY[0]; + paletteSprite.width = loadedSpriteWidth[0]; + paletteSprite.height = loadedSpriteHeight[0]; + paletteSprite.palette = loadedPalette; + paletteSprite.pixels = loadedSpritePixels[0]; + resetLastPaletteValues(); + return paletteSprite; + } + + public static void resetLastPaletteValues() { + loadedSpriteOffsetX = null; + loadedSpriteOffsetY = null; + loadedSpriteWidth = null; + loadedSpriteHeight = null; + loadedPalette = null; + loadedSpritePixels = null; + } + + public static SpriteDefinition[] loadPaletteSpriteSet() { + SpriteDefinition[] palettes = new SpriteDefinition[paletteChildCount]; + for (int paletteIndex = 0; paletteIndex < paletteChildCount; ++paletteIndex) { + SpriteDefinition palette = palettes[paletteIndex] = new SpriteDefinition(0); + palette.maxWidth = loadedSpriteMaxWidth; + palette.maxHeight = loadedSpriteMaxHeight; + palette.offsetX = loadedSpriteOffsetX[paletteIndex]; + palette.offsetY = loadedSpriteOffsetY[paletteIndex]; + palette.width = loadedSpriteWidth[paletteIndex]; + palette.height = loadedSpriteHeight[paletteIndex]; + palette.palette = loadedPalette; + palette.pixels = loadedSpritePixels[paletteIndex]; + } + + resetLastPaletteValues(); + return palettes; + } + + @Override + void decodeValues(int opcode, InputStream stream) { } +} diff --git a/src/main/java/net/runelite/cache/definitions/loaders/SpriteLoader.java b/src/main/java/net/runelite/cache/definitions/loaders/SpriteLoader.java new file mode 100644 index 0000000000..c94aabe88b --- /dev/null +++ b/src/main/java/net/runelite/cache/definitions/loaders/SpriteLoader.java @@ -0,0 +1,6 @@ +package net.runelite.cache.definitions.loaders; + +public class SpriteLoader +{ +fff +} diff --git a/src/main/java/net/runelite/cache/fs/Archive.java b/src/main/java/net/runelite/cache/fs/Archive.java index 0a6843b462..812872e7e7 100644 --- a/src/main/java/net/runelite/cache/fs/Archive.java +++ b/src/main/java/net/runelite/cache/fs/Archive.java @@ -4,7 +4,7 @@ import java.util.ArrayList; import java.util.Arrays; import java.util.List; import java.util.Objects; -import net.runelite.cache.fs.io.InputStream; +import net.runelite.cache.io.InputStream; public class Archive { diff --git a/src/main/java/net/runelite/cache/fs/DataFile.java b/src/main/java/net/runelite/cache/fs/DataFile.java index dfdd37466d..0beb220514 100644 --- a/src/main/java/net/runelite/cache/fs/DataFile.java +++ b/src/main/java/net/runelite/cache/fs/DataFile.java @@ -9,8 +9,8 @@ import java.io.RandomAccessFile; import java.nio.ByteBuffer; import java.util.Arrays; import java.util.Objects; -import net.runelite.cache.fs.io.InputStream; -import net.runelite.cache.fs.io.OutputStream; +import net.runelite.cache.io.InputStream; +import net.runelite.cache.io.OutputStream; import net.runelite.cache.fs.util.BZipDecompressor; import net.runelite.cache.fs.util.CRC32HGenerator; import net.runelite.cache.fs.util.GZip; diff --git a/src/main/java/net/runelite/cache/fs/Index.java b/src/main/java/net/runelite/cache/fs/Index.java index 4e4d1c807a..a5a616ec14 100644 --- a/src/main/java/net/runelite/cache/fs/Index.java +++ b/src/main/java/net/runelite/cache/fs/Index.java @@ -7,8 +7,8 @@ import java.util.ArrayList; import java.util.Arrays; import java.util.List; import java.util.Objects; -import net.runelite.cache.fs.io.InputStream; -import net.runelite.cache.fs.io.OutputStream; +import net.runelite.cache.io.InputStream; +import net.runelite.cache.io.OutputStream; import org.slf4j.Logger; import org.slf4j.LoggerFactory; diff --git a/src/main/java/net/runelite/cache/fs/Store.java b/src/main/java/net/runelite/cache/fs/Store.java index c9c1aab7b4..8dc718d4d8 100644 --- a/src/main/java/net/runelite/cache/fs/Store.java +++ b/src/main/java/net/runelite/cache/fs/Store.java @@ -7,6 +7,7 @@ import java.io.IOException; import java.util.ArrayList; import java.util.List; import java.util.Objects; +import net.runelite.cache.IndexType; public class Store implements Closeable { @@ -127,4 +128,9 @@ public class Store implements Closeable { return indexes; } + + public Index getIndex(IndexType type) + { + return indexes.get(type.getNumber()); + } } diff --git a/src/main/java/net/runelite/cache/fs/util/GZip.java b/src/main/java/net/runelite/cache/fs/util/GZip.java index b4111bd957..cbfeee4fe4 100644 --- a/src/main/java/net/runelite/cache/fs/util/GZip.java +++ b/src/main/java/net/runelite/cache/fs/util/GZip.java @@ -4,7 +4,7 @@ import java.io.ByteArrayOutputStream; import java.io.IOException; import java.util.zip.GZIPOutputStream; import java.util.zip.Inflater; -import net.runelite.cache.fs.io.Stream; +import net.runelite.cache.io.Stream; public class GZip { private static final Inflater inflaterInstance = new Inflater(true); diff --git a/src/main/java/net/runelite/cache/fs/io/InputStream.java b/src/main/java/net/runelite/cache/io/InputStream.java similarity index 98% rename from src/main/java/net/runelite/cache/fs/io/InputStream.java rename to src/main/java/net/runelite/cache/io/InputStream.java index 840289d77a..11361b559c 100644 --- a/src/main/java/net/runelite/cache/fs/io/InputStream.java +++ b/src/main/java/net/runelite/cache/io/InputStream.java @@ -1,6 +1,6 @@ -package net.runelite.cache.fs.io; +package net.runelite.cache.io; -import net.runelite.cache.fs.io.Stream; +import net.runelite.cache.io.Stream; public final class InputStream extends Stream { private static final int[] BIT_MASK = new int[]{0, 1, 3, 7, 15, 31, 63, 127, 255, 511, 1023, 2047, 4095, 8191, 16383, 32767, '\uffff', 131071, 262143, 524287, 1048575, 2097151, 4194303, 8388607, 16777215, 33554431, 67108863, 134217727, 268435455, 536870911, 1073741823, Integer.MAX_VALUE, -1}; diff --git a/src/main/java/net/runelite/cache/fs/io/OutputStream.java b/src/main/java/net/runelite/cache/io/OutputStream.java similarity index 99% rename from src/main/java/net/runelite/cache/fs/io/OutputStream.java rename to src/main/java/net/runelite/cache/io/OutputStream.java index 66eda169e1..034ccd9db4 100644 --- a/src/main/java/net/runelite/cache/fs/io/OutputStream.java +++ b/src/main/java/net/runelite/cache/io/OutputStream.java @@ -1,6 +1,6 @@ -package net.runelite.cache.fs.io; +package net.runelite.cache.io; -import net.runelite.cache.fs.io.Stream; +import net.runelite.cache.io.Stream; import java.math.BigInteger; public final class OutputStream extends Stream { diff --git a/src/main/java/net/runelite/cache/fs/io/Stream.java b/src/main/java/net/runelite/cache/io/Stream.java similarity index 98% rename from src/main/java/net/runelite/cache/fs/io/Stream.java rename to src/main/java/net/runelite/cache/io/Stream.java index c140af5fd1..72c1960755 100644 --- a/src/main/java/net/runelite/cache/fs/io/Stream.java +++ b/src/main/java/net/runelite/cache/io/Stream.java @@ -1,4 +1,4 @@ -package net.runelite.cache.fs.io; +package net.runelite.cache.io; public abstract class Stream { protected int offset; diff --git a/src/main/java/net/runelite/cache/renderable/RGBSprite.java b/src/main/java/net/runelite/cache/renderable/RGBSprite.java new file mode 100644 index 0000000000..8a7c668ad3 --- /dev/null +++ b/src/main/java/net/runelite/cache/renderable/RGBSprite.java @@ -0,0 +1,1452 @@ +package com.osrs.suite.cache.renderable; + +import com.alex.store.Store; +import com.osrs.suite.cache.definitions.SpriteDefinition; + +import java.awt.*; +import java.awt.image.*; + +/** + * Created by Allen Kinzalow on 3/14/2015. + */ +public class RGBSprite extends Rasterizer2D { + + public int offsetY; + public int spriteWidth; + public int spriteHeight; + public int offsetX; + public int maxHeight; + public int maxWidth; + public int[] pixels; + + public static RGBSprite getRGBSprite(Store store, int archiveId, int fileId, byte var3) { + if(!SpriteDefinition.loadPaletteSprite(store, archiveId, fileId, -1593817854)) { + return null; + } else { + RGBSprite sprite = new RGBSprite(); + sprite.maxWidth = SpriteDefinition.loadedSpriteMaxWidth; + sprite.maxHeight = SpriteDefinition.loadedSpriteMaxHeight; + sprite.offsetX = SpriteDefinition.loadedSpriteOffsetX[0]; + sprite.offsetY = SpriteDefinition.loadedSpriteOffsetY[0]; + sprite.spriteWidth = SpriteDefinition.loadedSpriteWidth[0]; + sprite.spriteHeight = SpriteDefinition.loadedSpriteHeight[0]; + int dimmension = sprite.spriteWidth * sprite.spriteHeight; + byte[] var6 = SpriteDefinition.loadedSpritePixels[0]; + sprite.pixels = new int[dimmension]; + + for(int pos = 0; pos < dimmension; ++pos) { + sprite.pixels[pos] = SpriteDefinition.loadedPalette[var6[pos] & 255]; + } + + SpriteDefinition.resetLastPaletteValues(); + return sprite; + } + } + + public static RGBSprite getRGBSprite(int index) { + RGBSprite sprite = new RGBSprite(); + sprite.maxWidth = SpriteDefinition.loadedSpriteMaxWidth; + sprite.maxHeight = SpriteDefinition.loadedSpriteMaxHeight; + sprite.offsetX = SpriteDefinition.loadedSpriteOffsetX[index]; + sprite.offsetY = SpriteDefinition.loadedSpriteOffsetY[index]; + sprite.spriteWidth = SpriteDefinition.loadedSpriteWidth[index]; + sprite.spriteHeight = SpriteDefinition.loadedSpriteHeight[index]; + int dimmension = sprite.spriteWidth * sprite.spriteHeight; + byte[] var6 = SpriteDefinition.loadedSpritePixels[index]; + sprite.pixels = new int[dimmension]; + + for(int pos = 0; pos < dimmension; ++pos) { + sprite.pixels[pos] = SpriteDefinition.loadedPalette[var6[pos] & 255]; + } + + //SpriteDefinition.resetLastPaletteValues(); + return sprite; + } + + public BufferedImage getBufferedImage() { + BufferedImage bi = new BufferedImage(spriteWidth, spriteHeight, BufferedImage.TYPE_INT_RGB); + bi.setRGB(0, 0, spriteWidth, spriteHeight, pixels, 0, spriteWidth); + Image img = makeColorTransparent(bi, new Color(0, 0, 0)); + BufferedImage trans = imageToBufferedImage(img); + return trans; + } + + public static Image makeColorTransparent(BufferedImage im, final Color color) { + RGBImageFilter filter = new RGBImageFilter() { + public int markerRGB = color.getRGB() | 0xFF000000; + public final int filterRGB(int x, int y, int rgb) { + if ((rgb | 0xFF000000) == markerRGB) { + return 0x00FFFFFF & rgb; + } else { + return rgb; + } + } + }; + ImageProducer ip = new FilteredImageSource(im.getSource(), filter); + return Toolkit.getDefaultToolkit().createImage(ip); + } + + private static BufferedImage imageToBufferedImage(Image image) { + BufferedImage bufferedImage = new BufferedImage(image.getWidth(null), image.getHeight(null), BufferedImage.TYPE_INT_ARGB); + Graphics2D g2 = bufferedImage.createGraphics(); + g2.drawImage(image, 0, 0, null); + g2.dispose(); + return bufferedImage; + } + + void method2741(int var1, int var2, int var3, int var4, int var5, int var6) { + if(var6 != 0) { + var1 -= this.offsetX << 4; + var2 -= this.offsetY << 4; + double var18 = (double)(var5 & '\uffff') * 9.587379924285257E-5D; + int var20 = (int)Math.floor(Math.sin(var18) * (double)var6 + 0.5D); + int var21 = (int)Math.floor(Math.cos(var18) * (double)var6 + 0.5D); + int var22 = -var1 * var21 + -var2 * var20; + int var23 = -(-var1) * var20 + -var2 * var21; + int var29 = ((this.spriteWidth << 4) - var1) * var21 + -var2 * var20; + int var34 = -((this.spriteWidth << 4) - var1) * var20 + -var2 * var21; + int var32 = -var1 * var21 + ((this.spriteHeight << 4) - var2) * var20; + int var26 = -(-var1) * var20 + ((this.spriteHeight << 4) - var2) * var21; + int var27 = ((this.spriteWidth << 4) - var1) * var21 + ((this.spriteHeight << 4) - var2) * var20; + int var28 = -((this.spriteWidth << 4) - var1) * var20 + ((this.spriteHeight << 4) - var2) * var21; + int var24; + int var31; + if(var22 < var29) { + var31 = var22; + var24 = var29; + } else { + var31 = var29; + var24 = var22; + } + + if(var32 < var31) { + var31 = var32; + } + + if(var27 < var31) { + var31 = var27; + } + + if(var32 > var24) { + var24 = var32; + } + + if(var27 > var24) { + var24 = var27; + } + + int var25; + int var30; + if(var23 < var34) { + var25 = var23; + var30 = var34; + } else { + var25 = var34; + var30 = var23; + } + + if(var26 < var25) { + var25 = var26; + } + + if(var28 < var25) { + var25 = var28; + } + + if(var26 > var30) { + var30 = var26; + } + + if(var28 > var30) { + var30 = var28; + } + + var31 >>= 12; + var24 = var24 + 4095 >> 12; + var25 >>= 12; + var30 = var30 + 4095 >> 12; + var31 += var3; + var24 += var3; + var25 += var4; + var30 += var4; + var31 >>= 4; + var24 = var24 + 15 >> 4; + var25 >>= 4; + var30 = var30 + 15 >> 4; + if(var31 < topX) { + var31 = topX; + } + + if(var24 > bottomX) { + var24 = bottomX; + } + + if(var25 < topY) { + var25 = topY; + } + + if(var30 > bottomY) { + var30 = bottomY; + } + + var24 = var31 - var24; + if(var24 < 0) { + var30 = var25 - var30; + if(var30 < 0) { + int var12 = var25 * renderWidth + var31; + double var36 = 1.6777216E7D / (double)var6; + int var9 = (int)Math.floor(Math.sin(var18) * var36 + 0.5D); + int var11 = (int)Math.floor(Math.cos(var18) * var36 + 0.5D); + int var14 = (var31 << 4) + 8 - var3; + int var38 = (var25 << 4) + 8 - var4; + int var8 = (var1 << 8) - (var38 * var9 >> 4); + int var10 = (var2 << 8) + (var38 * var11 >> 4); + int var7; + int var13; + int var15; + int var16; + int var17; + int var33; + int var35; + if(var11 == 0) { + if(var9 == 0) { + for(var7 = var30; var7 < 0; var12 += renderWidth) { + var35 = var12; + var15 = var8; + var13 = var10; + var17 = var24; + if(var8 >= 0 && var10 >= 0 && var8 - (this.spriteWidth << 12) < 0 && var10 - (this.spriteHeight << 12) < 0) { + for(; var17 < 0; ++var17) { + var33 = this.pixels[(var13 >> 12) * this.spriteWidth + (var15 >> 12)]; + if(var33 != 0) { + renderPixels[var35++] = var33; + } else { + ++var35; + } + } + } + + ++var7; + } + + } else if(var9 < 0) { + for(var7 = var30; var7 < 0; var12 += renderWidth) { + var35 = var12; + var15 = var8; + var13 = var10 + (var14 * var9 >> 4); + var17 = var24; + if(var8 >= 0 && var8 - (this.spriteWidth << 12) < 0) { + if((var16 = var13 - (this.spriteHeight << 12)) >= 0) { + var16 = (var9 - var16) / var9; + var17 = var24 + var16; + var13 += var9 * var16; + var35 = var12 + var16; + } + + if((var16 = (var13 - var9) / var9) > var17) { + var17 = var16; + } + + while(var17 < 0) { + var33 = this.pixels[(var13 >> 12) * this.spriteWidth + (var15 >> 12)]; + if(var33 != 0) { + renderPixels[var35++] = var33; + } else { + ++var35; + } + + var13 += var9; + ++var17; + } + } + + ++var7; + var8 -= var9; + } + + } else { + for(var7 = var30; var7 < 0; var12 += renderWidth) { + var35 = var12; + var15 = var8; + var13 = var10 + (var14 * var9 >> 4); + var17 = var24; + if(var8 >= 0 && var8 - (this.spriteWidth << 12) < 0) { + if(var13 < 0) { + var16 = (var9 - 1 - var13) / var9; + var17 = var24 + var16; + var13 += var9 * var16; + var35 = var12 + var16; + } + + if((var16 = (1 + var13 - (this.spriteHeight << 12) - var9) / var9) > var17) { + var17 = var16; + } + + while(var17 < 0) { + var33 = this.pixels[(var13 >> 12) * this.spriteWidth + (var15 >> 12)]; + if(var33 != 0) { + renderPixels[var35++] = var33; + } else { + ++var35; + } + + var13 += var9; + ++var17; + } + } + + ++var7; + var8 -= var9; + } + + } + } else if(var11 < 0) { + if(var9 == 0) { + for(var7 = var30; var7 < 0; var12 += renderWidth) { + var35 = var12; + var15 = var8 + (var14 * var11 >> 4); + var13 = var10; + var17 = var24; + if(var10 >= 0 && var10 - (this.spriteHeight << 12) < 0) { + if((var16 = var15 - (this.spriteWidth << 12)) >= 0) { + var16 = (var11 - var16) / var11; + var17 = var24 + var16; + var15 += var11 * var16; + var35 = var12 + var16; + } + + if((var16 = (var15 - var11) / var11) > var17) { + var17 = var16; + } + + while(var17 < 0) { + var33 = this.pixels[(var13 >> 12) * this.spriteWidth + (var15 >> 12)]; + if(var33 != 0) { + renderPixels[var35++] = var33; + } else { + ++var35; + } + + var15 += var11; + ++var17; + } + } + + ++var7; + var10 += var11; + } + + } else if(var9 < 0) { + for(var7 = var30; var7 < 0; var12 += renderWidth) { + var35 = var12; + var15 = var8 + (var14 * var11 >> 4); + var13 = var10 + (var14 * var9 >> 4); + var17 = var24; + if((var16 = var15 - (this.spriteWidth << 12)) >= 0) { + var16 = (var11 - var16) / var11; + var17 = var24 + var16; + var15 += var11 * var16; + var13 += var9 * var16; + var35 = var12 + var16; + } + + if((var16 = (var15 - var11) / var11) > var17) { + var17 = var16; + } + + if((var16 = var13 - (this.spriteHeight << 12)) >= 0) { + var16 = (var9 - var16) / var9; + var17 += var16; + var15 += var11 * var16; + var13 += var9 * var16; + var35 += var16; + } + + if((var16 = (var13 - var9) / var9) > var17) { + var17 = var16; + } + + while(var17 < 0) { + var33 = this.pixels[(var13 >> 12) * this.spriteWidth + (var15 >> 12)]; + if(var33 != 0) { + renderPixels[var35++] = var33; + } else { + ++var35; + } + + var15 += var11; + var13 += var9; + ++var17; + } + + ++var7; + var8 -= var9; + var10 += var11; + } + + } else { + for(var7 = var30; var7 < 0; var12 += renderWidth) { + var35 = var12; + var15 = var8 + (var14 * var11 >> 4); + var13 = var10 + (var14 * var9 >> 4); + var17 = var24; + if((var16 = var15 - (this.spriteWidth << 12)) >= 0) { + var16 = (var11 - var16) / var11; + var17 = var24 + var16; + var15 += var11 * var16; + var13 += var9 * var16; + var35 = var12 + var16; + } + + if((var16 = (var15 - var11) / var11) > var17) { + var17 = var16; + } + + if(var13 < 0) { + var16 = (var9 - 1 - var13) / var9; + var17 += var16; + var15 += var11 * var16; + var13 += var9 * var16; + var35 += var16; + } + + if((var16 = (1 + var13 - (this.spriteHeight << 12) - var9) / var9) > var17) { + var17 = var16; + } + + while(var17 < 0) { + var33 = this.pixels[(var13 >> 12) * this.spriteWidth + (var15 >> 12)]; + if(var33 != 0) { + renderPixels[var35++] = var33; + } else { + ++var35; + } + + var15 += var11; + var13 += var9; + ++var17; + } + + ++var7; + var8 -= var9; + var10 += var11; + } + + } + } else if(var9 == 0) { + for(var7 = var30; var7 < 0; var12 += renderWidth) { + var35 = var12; + var15 = var8 + (var14 * var11 >> 4); + var13 = var10; + var17 = var24; + if(var10 >= 0 && var10 - (this.spriteHeight << 12) < 0) { + if(var15 < 0) { + var16 = (var11 - 1 - var15) / var11; + var17 = var24 + var16; + var15 += var11 * var16; + var35 = var12 + var16; + } + + if((var16 = (1 + var15 - (this.spriteWidth << 12) - var11) / var11) > var17) { + var17 = var16; + } + + while(var17 < 0) { + var33 = this.pixels[(var13 >> 12) * this.spriteWidth + (var15 >> 12)]; + if(var33 != 0) { + renderPixels[var35++] = var33; + } else { + ++var35; + } + + var15 += var11; + ++var17; + } + } + + ++var7; + var10 += var11; + } + + } else if(var9 < 0) { + for(var7 = var30; var7 < 0; var12 += renderWidth) { + var35 = var12; + var15 = var8 + (var14 * var11 >> 4); + var13 = var10 + (var14 * var9 >> 4); + var17 = var24; + if(var15 < 0) { + var16 = (var11 - 1 - var15) / var11; + var17 = var24 + var16; + var15 += var11 * var16; + var13 += var9 * var16; + var35 = var12 + var16; + } + + if((var16 = (1 + var15 - (this.spriteWidth << 12) - var11) / var11) > var17) { + var17 = var16; + } + + if((var16 = var13 - (this.spriteHeight << 12)) >= 0) { + var16 = (var9 - var16) / var9; + var17 += var16; + var15 += var11 * var16; + var13 += var9 * var16; + var35 += var16; + } + + if((var16 = (var13 - var9) / var9) > var17) { + var17 = var16; + } + + while(var17 < 0) { + var33 = this.pixels[(var13 >> 12) * this.spriteWidth + (var15 >> 12)]; + if(var33 != 0) { + renderPixels[var35++] = var33; + } else { + ++var35; + } + + var15 += var11; + var13 += var9; + ++var17; + } + + ++var7; + var8 -= var9; + var10 += var11; + } + + } else { + for(var7 = var30; var7 < 0; var12 += renderWidth) { + var35 = var12; + var15 = var8 + (var14 * var11 >> 4); + var13 = var10 + (var14 * var9 >> 4); + var17 = var24; + if(var15 < 0) { + var16 = (var11 - 1 - var15) / var11; + var17 = var24 + var16; + var15 += var11 * var16; + var13 += var9 * var16; + var35 = var12 + var16; + } + + if((var16 = (1 + var15 - (this.spriteWidth << 12) - var11) / var11) > var17) { + var17 = var16; + } + + if(var13 < 0) { + var16 = (var9 - 1 - var13) / var9; + var17 += var16; + var15 += var11 * var16; + var13 += var9 * var16; + var35 += var16; + } + + if((var16 = (1 + var13 - (this.spriteHeight << 12) - var9) / var9) > var17) { + var17 = var16; + } + + while(var17 < 0) { + var33 = this.pixels[(var13 >> 12) * this.spriteWidth + (var15 >> 12)]; + if(var33 != 0) { + renderPixels[var35++] = var33; + } else { + ++var35; + } + + var15 += var11; + var13 += var9; + ++var17; + } + + ++var7; + var8 -= var9; + var10 += var11; + } + + } + } + } + } + } + + public RGBSprite(int var1, int var2) { + this.pixels = new int[var1 * var2]; + this.spriteWidth = this.maxWidth = var1; + this.spriteHeight = this.maxHeight = var2; + this.offsetY = 0; + this.offsetX = 0; + } + + public RGBSprite method2743() { + RGBSprite var1 = new RGBSprite(this.spriteWidth, this.spriteHeight); + var1.maxWidth = this.maxWidth; + var1.maxHeight = this.maxHeight; + var1.offsetX = this.maxWidth - this.spriteWidth - this.offsetX; + var1.offsetY = this.offsetY; + + for(int var2 = 0; var2 < this.spriteHeight; ++var2) { + for(int var3 = 0; var3 < this.spriteWidth; ++var3) { + var1.pixels[var2 * this.spriteWidth + var3] = this.pixels[var2 * this.spriteWidth + this.spriteWidth - 1 - var3]; + } + } + + return var1; + } + + public void method2744() { + setMaxRasterizeArea(this.pixels, this.spriteWidth, this.spriteHeight); + } + + public void alterColor(int var1, int var2, int var3) { + for(int var4 = 0; var4 < this.pixels.length; ++var4) { + int var6 = this.pixels[var4]; + if(var6 != 0) { + int var7 = var6 >> 16 & 255; + var7 += var1; + if(var7 < 1) { + var7 = 1; + } else if(var7 > 255) { + var7 = 255; + } + + int var5 = var6 >> 8 & 255; + var5 += var2; + if(var5 < 1) { + var5 = 1; + } else if(var5 > 255) { + var5 = 255; + } + + int var8 = var6 & 255; + var8 += var3; + if(var8 < 1) { + var8 = 1; + } else if(var8 > 255) { + var8 = 255; + } + + this.pixels[var4] = (var7 << 16) + (var5 << 8) + var8; + } + } + + } + + public void method2746(int x, int y) { + x += this.offsetX; + y += this.offsetY; + int var4 = x + y * renderWidth; + int var8 = 0; + int var6 = this.spriteHeight; + int var3 = this.spriteWidth; + int var9 = renderWidth - var3; + int var7 = 0; + int var5; + if(y < topY) { + var5 = topY - y; + var6 -= var5; + y = topY; + var8 += var5 * var3; + var4 += var5 * renderWidth; + } + + if(y + var6 > bottomY) { + var6 -= y + var6 - bottomY; + } + + if(x < topX) { + var5 = topX - x; + var3 -= var5; + x = topX; + var8 += var5; + var4 += var5; + var7 += var5; + var9 += var5; + } + + if(x + var3 > bottomX) { + var5 = x + var3 - bottomX; + var3 -= var5; + var7 += var5; + var9 += var5; + } + + if(var3 > 0) { + if(var6 > 0) { + method2770(renderPixels, this.pixels, 0, var8, var4, var3, var6, var9, var7); + } + } + } + + public void flipHorizontal() { + int[] var1 = new int[this.spriteWidth * this.spriteHeight]; + int var4 = 0; + + for(int var2 = this.spriteHeight - 1; var2 >= 0; --var2) { + for(int var3 = 0; var3 < this.spriteWidth; ++var3) { + var1[var4++] = this.pixels[var3 + var2 * this.spriteWidth]; + } + } + + this.pixels = var1; + this.offsetY = this.maxHeight - this.spriteHeight - this.offsetY; + } + + public void setPixels(int var1) { + int[] var2 = new int[this.spriteWidth * this.spriteHeight]; + int var4 = 0; + + for(int var5 = 0; var5 < this.spriteHeight; ++var5) { + for(int var3 = 0; var3 < this.spriteWidth; ++var3) { + int var6 = this.pixels[var4]; + if(var6 == 0) { + if(var3 > 0 && this.pixels[var4 - 1] != 0) { + var6 = var1; + } else if(var5 > 0 && this.pixels[var4 - this.spriteWidth] != 0) { + var6 = var1; + } else if(var3 < this.spriteWidth - 1 && this.pixels[var4 + 1] != 0) { + var6 = var1; + } else if(var5 < this.spriteHeight - 1 && this.pixels[var4 + this.spriteWidth] != 0) { + var6 = var1; + } + } + + var2[var4++] = var6; + } + } + + this.pixels = var2; + } + + static void method2751(int[] var0, int[] var1, int var2, int var3, int var4, int var5, int var6, int var7, int var8, int var9, int var10, int var11, int var12) { + int var13 = 256 - var12; + int var18 = var3; + + for(int var15 = -var8; var15 < 0; ++var15) { + int var16 = (var4 >> 16) * var11; + + for(int var17 = -var7; var17 < 0; ++var17) { + var2 = var1[(var3 >> 16) + var16]; + if(var2 != 0) { + int var14 = var0[var5]; + var0[var5++] = ((var2 & 16711935) * var12 + (var14 & 16711935) * var13 & -16711936) + ((var2 & '\uff00') * var12 + (var14 & '\uff00') * var13 & 16711680) >> 8; + } else { + ++var5; + } + + var3 += var9; + } + + var4 += var10; + var3 = var18; + var5 += var6; + } + + } + + static void method2753(int[] var0, int[] var1, int var2, int var3, int var4, int var5, int var6, int var7) { + for(int var8 = -var5; var8 < 0; ++var8) { + int var9; + for(var9 = var3 + var4 - 3; var3 < var9; var0[var3++] = var1[var2++]) { + var0[var3++] = var1[var2++]; + var0[var3++] = var1[var2++]; + var0[var3++] = var1[var2++]; + } + + for(var9 += 3; var3 < var9; var0[var3++] = var1[var2++]) { + ; + } + + var3 += var6; + var2 += var7; + } + + } + + public void method2755(int var1, int var2, int var3, int var4, int var5, int var6, int var7, int var8, int[] var9, int[] var10) { + try { + int var11 = -var3 / 2; + int var12 = -var4 / 2; + int var13 = (int)(Math.sin((double)var7 / 326.11D) * 65536.0D); + int var14 = (int)(Math.cos((double)var7 / 326.11D) * 65536.0D); + var13 = var13 * var8 >> 8; + var14 = var14 * var8 >> 8; + int var15 = (var5 << 16) + var12 * var13 + var11 * var14; + int var16 = (var6 << 16) + (var12 * var14 - var11 * var13); + int var17 = var1 + var2 * renderWidth; + + for(var2 = 0; var2 < var4; ++var2) { + int var18 = var9[var2]; + int var19 = var17 + var18; + int var20 = var15 + var14 * var18; + int var21 = var16 - var13 * var18; + + for(var1 = -var10[var2]; var1 < 0; ++var1) { + renderPixels[var19++] = this.pixels[(var20 >> 16) + (var21 >> 16) * this.spriteWidth]; + var20 += var14; + var21 -= var13; + } + + var15 += var13; + var16 += var14; + var17 += renderWidth; + } + + } catch (Exception var22) { + ; + } + } + + public void method2756(int var1, int var2, int var3, int var4) { + if(var3 > 0) { + if(var4 > 0) { + int var10 = this.spriteWidth; + int var5 = this.spriteHeight; + int var11 = 0; + int var6 = 0; + int var15 = this.maxWidth; + int var13 = this.maxHeight; + int var12 = (var15 << 16) / var3; + int var7 = (var13 << 16) / var4; + int var14; + if(this.offsetX > 0) { + var14 = ((this.offsetX << 16) + var12 - 1) / var12; + var1 += var14; + var11 += var14 * var12 - (this.offsetX << 16); + } + + if(this.offsetY > 0) { + var14 = ((this.offsetY << 16) + var7 - 1) / var7; + var2 += var14; + var6 += var14 * var7 - (this.offsetY << 16); + } + + if(var10 < var15) { + var3 = ((var10 << 16) - var11 + var12 - 1) / var12; + } + + if(var5 < var13) { + var4 = ((var5 << 16) - var6 + var7 - 1) / var7; + } + + var14 = var1 + var2 * renderWidth; + int var8 = renderWidth - var3; + if(var2 + var4 > bottomY) { + var4 -= var2 + var4 - bottomY; + } + + int var9; + if(var2 < topY) { + var9 = topY - var2; + var4 -= var9; + var14 += var9 * renderWidth; + var6 += var7 * var9; + } + + if(var1 + var3 > bottomX) { + var9 = var1 + var3 - bottomX; + var3 -= var9; + var8 += var9; + } + + if(var1 < topX) { + var9 = topX - var1; + var3 -= var9; + var14 += var9; + var11 += var12 * var9; + var8 += var9; + } + + method2757(renderPixels, this.pixels, 0, var11, var6, var14, var8, var3, var4, var12, var7, var10); + } + } + } + + static void method2757(int[] var0, int[] var1, int var2, int var3, int var4, int var5, int var6, int var7, int var8, int var9, int var10, int var11) { + int var12 = var3; + + for(int var13 = -var8; var13 < 0; ++var13) { + int var14 = (var4 >> 16) * var11; + + for(int var15 = -var7; var15 < 0; ++var15) { + var2 = var1[(var3 >> 16) + var14]; + if(var2 != 0) { + var0[var5++] = var2; + } else { + ++var5; + } + + var3 += var9; + } + + var4 += var10; + var3 = var12; + var5 += var6; + } + + } + + public void drawSpriteAlpha(int var1, int var2, int var3, int var4) { + if(var3 == 256) { + this.method2746(var1, var2); + } else { + var1 += this.offsetX; + var2 += this.offsetY; + int var7 = var1 + var2 * renderWidth; + int var11 = 0; + int var8 = this.spriteHeight; + int var5 = this.spriteWidth; + int var9 = renderWidth - var5; + int var10 = 0; + int var6; + if(var2 < topY) { + var6 = topY - var2; + var8 -= var6; + var2 = topY; + var11 += var6 * var5; + var7 += var6 * renderWidth; + } + + if(var2 + var8 > bottomY) { + var8 -= var2 + var8 - bottomY; + } + + if(var1 < topX) { + var6 = topX - var1; + var5 -= var6; + var1 = topX; + var11 += var6; + var7 += var6; + var10 += var6; + var9 += var6; + } + + if(var1 + var5 > bottomX) { + var6 = var1 + var5 - bottomX; + var5 -= var6; + var10 += var6; + var9 += var6; + } + + if(var5 > 0) { + if(var8 > 0) { + method2763(renderPixels, this.pixels, 0, var11, var7, var5, var8, var9, var10, var3, var4); + } + } + } + } + + static void method2761(int[] var0, int[] var1, int var2, int var3, int var4, int var5, int var6, int var7, int var8, int var9) { + int var10 = 256 - var9; + + for(int var11 = -var6; var11 < 0; ++var11) { + for(int var12 = -var5; var12 < 0; ++var12) { + var2 = var1[var3++]; + if(var2 != 0) { + int var13 = var0[var4]; + var0[var4++] = ((var2 & 16711935) * var9 + (var13 & 16711935) * var10 & -16711936) + ((var2 & '\uff00') * var9 + (var13 & '\uff00') * var10 & 16711680) >> 8; + } else { + ++var4; + } + } + + var4 += var7; + var3 += var8; + } + + } + + public void method2762(int var1, int var2, int var3, int var4, int var5) { + if(var3 > 0) { + if(var4 > 0) { + int var15 = this.spriteWidth; + int var10 = this.spriteHeight; + int var11 = 0; + int var8 = 0; + int var16 = this.maxWidth; + int var13 = this.maxHeight; + int var12 = (var16 << 16) / var3; + int var9 = (var13 << 16) / var4; + int var6; + if(this.offsetX > 0) { + var6 = ((this.offsetX << 16) + var12 - 1) / var12; + var1 += var6; + var11 += var6 * var12 - (this.offsetX << 16); + } + + if(this.offsetY > 0) { + var6 = ((this.offsetY << 16) + var9 - 1) / var9; + var2 += var6; + var8 += var6 * var9 - (this.offsetY << 16); + } + + if(var15 < var16) { + var3 = ((var15 << 16) - var11 + var12 - 1) / var12; + } + + if(var10 < var13) { + var4 = ((var10 << 16) - var8 + var9 - 1) / var9; + } + + var6 = var1 + var2 * renderWidth; + int var14 = renderWidth - var3; + if(var2 + var4 > bottomY) { + var4 -= var2 + var4 - bottomY; + } + + int var7; + if(var2 < topY) { + var7 = topY - var2; + var4 -= var7; + var6 += var7 * renderWidth; + var8 += var9 * var7; + } + + if(var1 + var3 > bottomX) { + var7 = var1 + var3 - bottomX; + var3 -= var7; + var14 += var7; + } + + if(var1 < topX) { + var7 = topX - var1; + var3 -= var7; + var6 += var7; + var11 += var12 * var7; + var14 += var7; + } + + method2751(renderPixels, this.pixels, 0, var11, var8, var6, var14, var3, var4, var12, var9, var15, var5); + } + } + } + + static void method2763(int[] var0, int[] var1, int var2, int var3, int var4, int var5, int var6, int var7, int var8, int var9, int var10) { + int var11 = 256 - var9; + int var13 = (var10 & 16711935) * var11 & -16711936; + int var14 = (var10 & '\uff00') * var11 & 16711680; + var10 = (var13 | var14) >>> 8; + + for(int var15 = -var6; var15 < 0; ++var15) { + for(int var12 = -var5; var12 < 0; ++var12) { + var2 = var1[var3++]; + if(var2 != 0) { + var13 = (var2 & 16711935) * var9 & -16711936; + var14 = (var2 & '\uff00') * var9 & 16711680; + var0[var4++] = ((var13 | var14) >>> 8) + var10; + } else { + ++var4; + } + } + + var4 += var7; + var3 += var8; + } + + } + + public void method2765(int var1, int var2, int var3, int var4, int var5, int var6, double var7, int var9) { + try { + int var10 = -var3 / 2; + int var11 = -var4 / 2; + int var12 = (int)(Math.sin(var7) * 65536.0D); + int var13 = (int)(Math.cos(var7) * 65536.0D); + var12 = var12 * var9 >> 8; + var13 = var13 * var9 >> 8; + int var14 = (var5 << 16) + var11 * var12 + var10 * var13; + int var15 = (var6 << 16) + (var11 * var13 - var10 * var12); + int var16 = var1 + var2 * renderWidth; + + for(var2 = 0; var2 < var4; ++var2) { + int var17 = var16; + int var18 = var14; + int var19 = var15; + + for(var1 = -var3; var1 < 0; ++var1) { + int var20 = this.pixels[(var18 >> 16) + (var19 >> 16) * this.spriteWidth]; + if(var20 != 0) { + renderPixels[var17++] = var20; + } else { + ++var17; + } + + var18 += var13; + var19 -= var12; + } + + var14 += var12; + var15 += var13; + var16 += renderWidth; + } + + } catch (Exception var21) { + ; + } + } + + public void method2766(int var1, int var2, int var3, int var4) { + this.method2741(this.maxWidth << 3, this.maxHeight << 3, var1 << 4, var2 << 4, var3, var4); + } + + public void drawSprite(int var1, int var2) { + var1 += this.offsetX; + var2 += this.offsetY; + int var8 = var1 + var2 * renderWidth; + int var5 = 0; + int var3 = this.spriteHeight; + int var6 = this.spriteWidth; + int var9 = renderWidth - var6; + int var4 = 0; + int var7; + if(var2 < topY) { + var7 = topY - var2; + var3 -= var7; + var2 = topY; + var5 += var7 * var6; + var8 += var7 * renderWidth; + } + + if(var2 + var3 > bottomY) { + var3 -= var2 + var3 - bottomY; + } + + if(var1 < topX) { + var7 = topX - var1; + var6 -= var7; + var1 = topX; + var5 += var7; + var8 += var7; + var4 += var7; + var9 += var7; + } + + if(var1 + var6 > bottomX) { + var7 = var1 + var6 - bottomX; + var6 -= var7; + var4 += var7; + var9 += var7; + } + + if(var6 > 0) { + if(var3 > 0) { + method2753(renderPixels, this.pixels, var5, var8, var6, var3, var9, var4); + } + } + } + + static void method2768(int[] var0, int[] var1, int var2, int var3, int var4, int var5, int var6, int var7, int var8, int var9, int var10, byte[] var11) { + int var12 = -(var6 >> 2); + var6 = -(var6 & 3); + + for(int var14 = -var7; var14 < 0; ++var14) { + int var13; + for(var13 = var12; var13 < 0; ++var13) { + var2 = var1[var3++]; + if(var2 != 0 && var11[var5] == 0) { + var0[var4++] = var2; + } else { + ++var4; + } + + ++var5; + var2 = var1[var3++]; + if(var2 != 0 && var11[var5] == 0) { + var0[var4++] = var2; + } else { + ++var4; + } + + ++var5; + var2 = var1[var3++]; + if(var2 != 0 && var11[var5] == 0) { + var0[var4++] = var2; + } else { + ++var4; + } + + ++var5; + var2 = var1[var3++]; + if(var2 != 0 && var11[var5] == 0) { + var0[var4++] = var2; + } else { + ++var4; + } + + ++var5; + } + + for(var13 = var6; var13 < 0; ++var13) { + var2 = var1[var3++]; + if(var2 != 0 && var11[var5] == 0) { + var0[var4++] = var2; + } else { + ++var4; + } + + ++var5; + } + + var4 += var8; + var3 += var9; + var5 += var10; + } + + } + + RGBSprite() {} + + static void method2770(int[] var0, int[] var1, int var2, int var3, int var4, int var5, int var6, int var7, int var8) { + int var9 = -(var5 >> 2); + var5 = -(var5 & 3); + + for(int var10 = -var6; var10 < 0; ++var10) { + int var11; + for(var11 = var9; var11 < 0; ++var11) { + var2 = var1[var3++]; + if(var2 != 0) { + var0[var4++] = var2; + } else { + ++var4; + } + + var2 = var1[var3++]; + if(var2 != 0) { + var0[var4++] = var2; + } else { + ++var4; + } + + var2 = var1[var3++]; + if(var2 != 0) { + var0[var4++] = var2; + } else { + ++var4; + } + + var2 = var1[var3++]; + if(var2 != 0) { + var0[var4++] = var2; + } else { + ++var4; + } + } + + for(var11 = var5; var11 < 0; ++var11) { + var2 = var1[var3++]; + if(var2 != 0) { + var0[var4++] = var2; + } else { + ++var4; + } + } + + var4 += var7; + var3 += var8; + } + + } + + /*public void method2778(PaletteSprite var1, int var2, int var3) { + if(bottomX - topX == var1.paletteSpriteWidth && bottomY - topY == var1.paletteSpriteHeight) { + var2 += this.offsetX; + var3 += this.offsetY; + int var10 = var2 + var3 * renderWidth; + int var7 = 0; + int var6 = this.spriteHeight; + int var4 = this.spriteWidth; + int var8 = renderWidth - var4; + int var9 = 0; + int var5; + if(var3 < topY) { + var5 = topY - var3; + var6 -= var5; + var3 = topY; + var7 += var5 * var4; + var10 += var5 * renderWidth; + } + + if(var3 + var6 > bottomY) { + var6 -= var3 + var6 - bottomY; + } + + if(var2 < topX) { + var5 = topX - var2; + var4 -= var5; + var2 = topX; + var7 += var5; + var10 += var5; + var9 += var5; + var8 += var5; + } + + if(var2 + var4 > bottomX) { + var5 = var2 + var4 - bottomX; + var4 -= var5; + var9 += var5; + var8 += var5; + } + + if(var4 > 0) { + if(var6 > 0) { + var5 = var2 - topX + (var3 - topY) * var1.paletteSpriteWidth; + int var11 = var1.paletteSpriteWidth - var4; + method2768(renderPixels, this.pixels, 0, var7, var10, var5, var4, var6, var8, var9, var11, var1.pixels); + } + } + } else { + throw new IllegalStateException(); + } + }*/ + + public void method2782(int var1) { + if(this.spriteWidth != this.maxWidth || this.spriteHeight != this.maxHeight) { + int var3 = var1; + if(var1 > this.offsetX) { + var3 = this.offsetX; + } + + int var4 = var1; + if(var1 + this.offsetX + this.spriteWidth > this.maxWidth) { + var4 = this.maxWidth - this.offsetX - this.spriteWidth; + } + + int var8 = var1; + if(var1 > this.offsetY) { + var8 = this.offsetY; + } + + int var9 = var1; + if(var1 + this.offsetY + this.spriteHeight > this.maxHeight) { + var9 = this.maxHeight - this.offsetY - this.spriteHeight; + } + + int var5 = this.spriteWidth + var3 + var4; + int var6 = this.spriteHeight + var8 + var9; + int[] var7 = new int[var5 * var6]; + + for(int var10 = 0; var10 < this.spriteHeight; ++var10) { + for(int var2 = 0; var2 < this.spriteWidth; ++var2) { + var7[(var10 + var8) * var5 + var2 + var3] = this.pixels[var10 * this.spriteWidth + var2]; + } + } + + this.pixels = var7; + this.spriteWidth = var5; + this.spriteHeight = var6; + this.offsetX -= var3; + this.offsetY -= var8; + } + } + + public void method2792() { + if(this.spriteWidth != this.maxWidth || this.spriteHeight != this.maxHeight) { + int[] var1 = new int[this.maxWidth * this.maxHeight]; + + for(int var2 = 0; var2 < this.spriteHeight; ++var2) { + for(int var3 = 0; var3 < this.spriteWidth; ++var3) { + var1[(var2 + this.offsetY) * this.maxWidth + var3 + this.offsetX] = this.pixels[var2 * this.spriteWidth + var3]; + } + } + + this.pixels = var1; + this.spriteWidth = this.maxWidth; + this.spriteHeight = this.maxHeight; + this.offsetX = 0; + this.offsetY = 0; + } + } + + public void method2814(int var1) { + for(int var2 = this.spriteHeight - 1; var2 > 0; --var2) { + int var3 = var2 * this.spriteWidth; + + for(int var4 = this.spriteWidth - 1; var4 > 0; --var4) { + if(this.pixels[var4 + var3] == 0 && this.pixels[var4 + var3 - 1 - this.spriteWidth] != 0) { + this.pixels[var4 + var3] = var1; + } + } + } + + } + + public void method2818(int var1, int var2, int var3) { + var1 += this.offsetX; + var2 += this.offsetY; + int var6 = var1 + var2 * renderWidth; + int var10 = 0; + int var7 = this.spriteHeight; + int var4 = this.spriteWidth; + int var8 = renderWidth - var4; + int var9 = 0; + int var5; + if(var2 < topY) { + var5 = topY - var2; + var7 -= var5; + var2 = topY; + var10 += var5 * var4; + var6 += var5 * renderWidth; + } + + if(var2 + var7 > bottomY) { + var7 -= var2 + var7 - bottomY; + } + + if(var1 < topX) { + var5 = topX - var1; + var4 -= var5; + var1 = topX; + var10 += var5; + var6 += var5; + var9 += var5; + var8 += var5; + } + + if(var1 + var4 > bottomX) { + var5 = var1 + var4 - bottomX; + var4 -= var5; + var9 += var5; + var8 += var5; + } + + if(var4 > 0) { + if(var7 > 0) { + method2761(renderPixels, this.pixels, 0, var10, var6, var4, var7, var8, var9, var3); + } + } + } + + public void flipVertical() { + int[] var1 = new int[this.spriteWidth * this.spriteHeight]; + int var4 = 0; + + for(int var2 = 0; var2 < this.spriteHeight; ++var2) { + for(int var3 = this.spriteWidth - 1; var3 >= 0; --var3) { + var1[var4++] = this.pixels[var3 + var2 * this.spriteWidth]; + } + } + + this.pixels = var1; + this.offsetX = this.maxWidth - this.spriteWidth - this.offsetX; + } + + public RGBSprite(byte[] var1, Component var2) { + try { + Image var3 = Toolkit.getDefaultToolkit().createImage(var1); + MediaTracker var4 = new MediaTracker(var2); + var4.addImage(var3, 0); + var4.waitForAll(); + this.spriteWidth = var3.getWidth(var2); + this.spriteHeight = var3.getHeight(var2); + this.maxWidth = this.spriteWidth; + this.maxHeight = this.spriteHeight; + this.offsetX = 0; + this.offsetY = 0; + this.pixels = new int[this.spriteWidth * this.spriteHeight]; + PixelGrabber var5 = new PixelGrabber(var3, 0, 0, this.spriteWidth, this.spriteHeight, this.pixels, 0, this.spriteWidth); + var5.grabPixels(); + } catch (InterruptedException var6) { + ; + } + } + +} diff --git a/src/main/java/net/runelite/cache/utils/StringUtilities.java b/src/main/java/net/runelite/cache/utils/StringUtilities.java new file mode 100644 index 0000000000..86d303560b --- /dev/null +++ b/src/main/java/net/runelite/cache/utils/StringUtilities.java @@ -0,0 +1,125 @@ +package net.runelite.cache.utils; + +import net.runelite.cache.io.InputStream; + +/** + * Created by Allen Kinzalow on 3/15/2015. + * + * These are methods from the OSRS Client. + */ +public class StringUtilities { + +// public static int method769(CharSequence sequence, int var1) { +// int length = sequence.length(); +// int position = 0; +// +// for(int charPosition = 0; charPosition < length; ++charPosition) { +// position = (position << 5) - position + method671(sequence.charAt(charPosition)); +// } +// +// return position; +// } +// +// public static byte method671(char var0) { +// byte var2; +// if((var0 <= 0 || var0 >= 128) && (var0 < 160 || var0 > 255)) { +// if(8364 == var0) { +// var2 = -128; +// } else if(var0 == 8218) { +// var2 = -126; +// } else if(402 == var0) { +// var2 = -125; +// } else if(8222 == var0) { +// var2 = -124; +// } else if(var0 == 8230) { +// var2 = -123; +// } else if(8224 == var0) { +// var2 = -122; +// } else if(8225 == var0) { +// var2 = -121; +// } else if(710 == var0) { +// var2 = -120; +// } else if(8240 == var0) { +// var2 = -119; +// } else if(var0 == 352) { +// var2 = -118; +// } else if(8249 == var0) { +// var2 = -117; +// } else if(var0 == 338) { +// var2 = -116; +// } else if(381 == var0) { +// var2 = -114; +// } else if(var0 == 8216) { +// var2 = -111; +// } else if(var0 == 8217) { +// var2 = -110; +// } else if(8220 == var0) { +// var2 = -109; +// } else if(var0 == 8221) { +// var2 = -108; +// } else if(8226 == var0) { +// var2 = -107; +// } else if(8211 == var0) { +// var2 = -106; +// } else if(8212 == var0) { +// var2 = -105; +// } else if(732 == var0) { +// var2 = -104; +// } else if(8482 == var0) { +// var2 = -103; +// } else if(var0 == 353) { +// var2 = -102; +// } else if(8250 == var0) { +// var2 = -101; +// } else if(339 == var0) { +// var2 = -100; +// } else if(var0 == 382) { +// var2 = -98; +// } else if(376 == var0) { +// var2 = -97; +// } else { +// var2 = 63; +// } +// } else { +// var2 = (byte)var0; +// } +// +// return var2; +// } + + public static String readString_2(InputStream stream) { + int var2 = stream.getOffset(); + + while(stream.readByte() != 0) { + ; + } + + int var3 = stream.getOffset() - var2 - 1; + return var3 == 0? "" : getStringMethod(stream.getBuffer(), var2, var3); + } + + public static String getStringMethod(byte[] var0, int var1, int var2) { + char[] aCharArray1496 = new char[]{'\u20ac', '\u0000', '\u201a', '\u0192', '\u201e', '\u2026', '\u2020', '\u2021', '\u02c6', '\u2030', '\u0160', '\u2039', '\u0152', '\u0000', '\u017d', '\u0000', '\u0000', '\u2018', '\u2019', '\u201c', '\u201d', '\u2022', '\u2013', '\u2014', '\u02dc', '\u2122', '\u0161', '\u203a', '\u0153', '\u0000', '\u017e', '\u0178'}; + char[] var4 = new char[var2]; + int var5 = 0; + + for (int var8 = 0; var8 < var2; ++var8) { + int var6 = var0[var1 + var8] & 255; + if (var6 != 0) { + if (var6 >= 128 && var6 < 160) { + char var7 = aCharArray1496[var6 - 128]; + if (0 == var7) { + var7 = 63; + } + + var6 = var7; + } + + var4[var5++] = (char) var6; + } + } + + return new String(var4, 0, var5); + } + +} diff --git a/src/test/java/net/runelite/cache/StoreLocation.java b/src/test/java/net/runelite/cache/StoreLocation.java new file mode 100644 index 0000000000..4d0b08c945 --- /dev/null +++ b/src/test/java/net/runelite/cache/StoreLocation.java @@ -0,0 +1,8 @@ +package net.runelite.cache; + +import java.io.File; + +public class StoreLocation +{ + public static final File LOCATION = new File("c:/rs/cache"); +} \ No newline at end of file diff --git a/src/test/java/net/runelite/cache/fs/StoreLoadTest.java b/src/test/java/net/runelite/cache/fs/StoreLoadTest.java index 5ec3e3cff6..45049b1d22 100644 --- a/src/test/java/net/runelite/cache/fs/StoreLoadTest.java +++ b/src/test/java/net/runelite/cache/fs/StoreLoadTest.java @@ -2,22 +2,23 @@ package net.runelite.cache.fs; import java.io.FileOutputStream; import java.io.IOException; +import net.runelite.cache.StoreLocation; import org.junit.Test; public class StoreLoadTest { - @Test + //@Test public void test() throws IOException { - Store store = new Store(new java.io.File("d:/rs/07/cache"));//c:/rs/cache")); + Store store = new Store(StoreLocation.LOCATION); store.load(); System.out.println(store); } - //@Test + @Test public void unpackStore() throws IOException { - java.io.File base = new java.io.File("d:/rs/07/cache"); + java.io.File base = StoreLocation.LOCATION; try (Store store = new Store(base)) { store.load(); diff --git a/src/test/java/net/runelite/cache/loaders/SpriteLoaderTest.java b/src/test/java/net/runelite/cache/loaders/SpriteLoaderTest.java new file mode 100644 index 0000000000..6bc0960123 --- /dev/null +++ b/src/test/java/net/runelite/cache/loaders/SpriteLoaderTest.java @@ -0,0 +1,45 @@ +package net.runelite.cache.loaders; + +import java.io.IOException; +import java.util.List; +import net.runelite.cache.IndexType; +import net.runelite.cache.StoreLocation; +import net.runelite.cache.definitions.SpriteDefinition; +import net.runelite.cache.fs.Archive; +import net.runelite.cache.fs.File; +import net.runelite.cache.fs.Index; +import net.runelite.cache.fs.Store; +import net.runelite.cache.io.InputStream; +import org.junit.Assert; +import org.junit.Test; + +public class SpriteLoaderTest +{ + @Test + public void extract() throws IOException + { + java.io.File base = StoreLocation.LOCATION; + try (Store store = new Store(base)) + { + store.load(); + + Index index = store.getIndex(IndexType.SPRITE); + + for (Archive a : index.getArchives()) + { + List files = a.getFiles(); + + Assert.assertEquals(1, files.size()); + + File file = files.get(0); + byte[] contents = file.getContents(); + + SpriteDefinition def = new SpriteDefinition(42); + def.decode(new InputStream(contents)); + + SpriteDefinition spr[] = SpriteDefinition.loadPaletteSpriteSet(); + int i =5; + } + } + } +}