private void button3_Click(object sender, EventArgs e)
{
saveFileDialog1.Filter = "All Files (*.*)|*.*";
saveFileDialog1.ShowDialog();
if (saveFileDialog1.FileName != null)
{
byte[] bytes = System.IO.File.ReadAllBytes(openFileDialog1.FileName);
var decompressedBlob = ZlibStream.UncompressBuffer(bytes);
try
{
System.IO.FileStream _FileStream = (System.IO.FileStream)saveFileDialog1.OpenFile();
_FileStream.Write(decompressedBlob, 0, decompressedBlob.Length);
_FileStream.Close();
}
catch
{ }
}
}
static void Main(string[] args)
{
var utf8 = new UTF8Encoding();
using (var client = new SubscriberSocket())
{
client.Options.ReceiveHighWatermark = 1000;
client.Connect("tcp://cedar.canonn.tech:9500");
client.SubscribeToAnyTopic();
while (true)
{
var bytes = client.ReceiveFrameBytes();
var uncompressed = ZlibStream.UncompressBuffer(bytes);
var result = utf8.GetString(uncompressed);
Console.WriteLine(result);
}
}
}
static void Main(string[] args)
{
if (args[0] == "-d")
{
FileStream fs = File.OpenRead(args[1]);
int BufferSz = ReadInt32(fs);
byte[] RunDataBuffer = new byte[BufferSz];
fs.Read(RunDataBuffer, 0x00, BufferSz);
byte[] RunDataUncompressed = ZlibStream.UncompressBuffer(RunDataBuffer);
File.WriteAllBytes(args[2], RunDataUncompressed);
}
if (args[0] == "-e")
{
byte[] RunDataUncompressed = File.ReadAllBytes(args[1]);
FileStream fs = File.OpenWrite(args[2]);
byte[] RunDataCompressed = Compress(RunDataUncompressed);
WriteInt32(fs, RunDataCompressed.Length);
fs.Write(RunDataCompressed, 0x00, RunDataCompressed.Length);
}
}
public static void MapChunkBulk(MinecraftClient client, IPacket _packet)
{
var packet = (MapChunkBulkPacket)_packet;
var data = ZlibStream.UncompressBuffer(packet.ChunkData);
var offset = 0;
foreach (var metadata in packet.ChunkMetadata)
{
var chunkLength = (BlockDataLength + (NibbleDataLength * 2) + (packet.LightIncluded ? NibbleDataLength : 0)) *
GetSectionCount(metadata.PrimaryBitMap) +
NibbleDataLength * GetSectionCount(metadata.AddBitMap) + (Chunk.Width * Chunk.Depth);
var chunkData = new byte[chunkLength];
Array.Copy(data, offset, chunkData, 0, chunkLength);
AddChunk(client, metadata.ChunkX, metadata.ChunkZ, metadata.PrimaryBitMap, metadata.AddBitMap, packet.LightIncluded, true, chunkData);
offset += chunkLength;
}
}
public byte[] Decompress(byte[] file, string type)
{
byte[] align = new byte[4]; Array.Copy(file, 4, align, 0, 4); //used for byte alignment. But it's being fudged by the dll.
byte[] compressed = new byte[4]; Array.Copy(file, 8, compressed, 0, 4);
byte[] uncompressed = new byte[4]; Array.Copy(file, 12, uncompressed, 0, 4);
byte[] input = new byte[BitConverter.ToInt32(compressed, 0)]; Array.Copy(file, 16, input, 0, file.Length - 16);
byte[] output = new byte[BitConverter.ToInt32(uncompressed, 0)];
int padding = BitConverter.ToInt32(uncompressed, 0) - BitConverter.ToInt32(compressed, 0);
if (type == "BPE ")
{
yukes_bpe(input, BitConverter.ToInt32(compressed, 0), output, BitConverter.ToInt32(uncompressed, 0), padding);
}
if (type == "ZLIB")
{
output = ZlibStream.UncompressBuffer(input);
}
return(output);
}
// Use this for initialization
void Start()
{
FileStream input = new FileStream("E:/gamecheat/resource/ttlz/dump.txt", FileMode.Open, FileAccess.ReadWrite);
FileStream output = new FileStream("E:/gamecheat/resource/ttlz/dump.dll", FileMode.OpenOrCreate, FileAccess.ReadWrite);
string FileName_HashKey = "dump";
long FileSize = input.Length;
byte[] data = new byte[FileSize];
input.Read(data, 0, (int)FileSize);
System.Random random = new System.Random(FileName_HashKey.GetHashCode());
for (int i = 0; i < data.Length; i++)
{
data[i] ^= (byte)random.Next(256);
}
byte[] temp = ZlibStream.UncompressBuffer(data);
for (int i = 0; i < temp.Length; i++)
{
output.WriteByte(temp[i]);
}
}
private bool ReadCompressed(ClientWrapper client, NetworkStream clientStream, int dlength)
{
var buffie = new byte[dlength];
int receivedData;
receivedData = clientStream.Read(buffie, 0, buffie.Length);
buffie = ZlibStream.UncompressBuffer(buffie);
if (receivedData > 0)
{
var buf = new DataBuffer(client);
if (client.Decrypter != null)
{
var date = new byte[4096];
client.Decrypter.TransformBlock(buffie, 0, buffie.Length, date, 0);
buf.BufferedData = date;
}
else
{
buf.BufferedData = buffie;
}
buf.BufferedData = buffie;
buf.Size = dlength;
var packid = buf.ReadVarInt();
if (!new PackageFactory(client, buf).Handle(packid))
{
ConsoleFunctions.WriteWarningLine("Unknown packet received! \"0x" + packid.ToString("X2") + "\"");
}
buf.Dispose();
return(true);
}
else
{
return(false);
}
}
public static IEnumerable <ZlibFile> Open(string path)
{
var files = new List <ZlibFile>();
using (var reader = new BinaryReader(File.OpenRead(path)))
{
byte[] header = reader.ReadBytes(0x10);
int count = reader.ReadInt32();
byte[] separator = reader.ReadBytes(1);
for (int i = 0; i != count; i++)
{
int id = reader.ReadInt32();
int offset = reader.ReadInt32();
long previous = reader.BaseStream.Position;
reader.BaseStream.Seek(offset, SeekOrigin.Begin);
int creation = reader.ReadInt32();
int size = reader.ReadInt32();
int compressedSize = reader.ReadInt32();
bool compressed = Convert.ToBoolean(reader.ReadBytes(1)[0]);
byte[] data = reader.ReadBytes(compressedSize);
if (compressed)
{
data = ZlibStream.UncompressBuffer(data);
}
files.Add(new ZlibFile
{
Id = id,
Content = data
});
reader.BaseStream.Seek(previous, SeekOrigin.Begin);
}
}
return(files);
}
private static double[] ReadBase64EncodedDoubleArray(string base64EncodedData, int wordLengthInBytes, bool zlibCompressed)
{
byte[] bytes = Convert.FromBase64String(base64EncodedData);
if(zlibCompressed)
{
bytes = ZlibStream.UncompressBuffer(bytes);
}
double[] doubles = new double[bytes.Length / wordLengthInBytes];
if(wordLengthInBytes == 4)
{
for(int i = doubles.GetLowerBound(0); i <= doubles.GetUpperBound(0); i++)
{
doubles[i] = BitConverter.ToSingle(bytes, i * wordLengthInBytes);
}
}
else if(wordLengthInBytes == 8)
{
Buffer.BlockCopy(bytes, 0, doubles, 0, bytes.Length);
}
return doubles;
}
public static ModelEntry FillModelEntry(string filename, List <string> subnames, TreeView tree, BinaryReader br, int c, int ID, Type filetype = null)
{
ModelEntry modentry = new ModelEntry();
List <byte> BTemp = new List <byte>();
FillEntry(filename, subnames, tree, br, c, ID, modentry, filetype);
//Decompression Time.
modentry.UncompressedData = ZlibStream.UncompressBuffer(modentry.CompressedData);
//Type Specific Work Here.
using (MemoryStream LmtStream = new MemoryStream(modentry.UncompressedData))
{
using (BinaryReader bnr = new BinaryReader(LmtStream))
{
BuildModelEntry(bnr, modentry);
}
}
return(modentry);
}
public static byte[] Uncompress(this byte[] compressed, int sizeUncompressed, bool checkSizeDifference)
{
if (compressed.Length == sizeUncompressed)
{
return(compressed);
}
byte[] uncompressed;
try
{
uncompressed = ZlibStream.UncompressBuffer(compressed);
}
catch (Exception x)
{
throw new IOException(Resources.UtilDB_Uncompress_Failure_uncompressing_data, x);
}
if (checkSizeDifference && (uncompressed.Length != sizeUncompressed))
{
throw new IOException(Resources.UtilDB_Uncompress_Failure_uncompressing_data);
}
return(uncompressed);
}
public static EffectListEntry FillEFLEntry(string filename, List <string> subnames, TreeView tree, BinaryReader br, int c, int ID, Type filetype = null)
{
EffectListEntry effectList = new EffectListEntry();
List <byte> BTemp = new List <byte>();
FillEntry(filename, subnames, tree, br, c, ID, effectList, filetype);
//Decompression Time.
effectList.UncompressedData = ZlibStream.UncompressBuffer(effectList.CompressedData);
//Type Specific Work Here.
using (MemoryStream LmtStream = new MemoryStream(effectList.UncompressedData))
{
using (BinaryReader bnr = new BinaryReader(LmtStream))
{
BuildEffectListEntry(bnr, effectList);
}
}
return(effectList);
}
private static void DecompressZLIB(string fileName, string targetFileName)
{
byte[] header = new byte[HeaderLength];
HeaderFWS.CopyTo(header, 0);
byte[] uncompressed;
using (BinaryReader reader = new BinaryReader(new FileStream(fileName, FileMode.Open)))
{
reader.BaseStream.Seek(HeaderTypeLength, SeekOrigin.Begin);
reader.Read(header, HeaderTypeLength, HeaderVersionLength + HeaderSizeLength);
reader.BaseStream.Seek(HeaderLength, SeekOrigin.Begin);
byte[] data = new byte[reader.BaseStream.Length - HeaderLength];
reader.Read(data, 0, data.Length);
uncompressed = ZlibStream.UncompressBuffer(data);
}
byte[] combined = CombineBytes(header, uncompressed);
File.WriteAllBytes(targetFileName, combined);
}
public static MaterialEntry FillMatEntry(string filename, List <string> subnames, TreeView tree, BinaryReader br, int c, int ID, Type filetype = null)
{
var MATEntry = new MaterialEntry();
List <byte> BTemp = new List <byte>();
FillEntry(filename, subnames, tree, br, c, ID, MATEntry);
//Decompression Time.
MATEntry.UncompressedData = ZlibStream.UncompressBuffer(MATEntry.CompressedData);
//Material specific work here.
using (MemoryStream MatStream = new MemoryStream(MATEntry.UncompressedData))
{
using (BinaryReader MBR = new BinaryReader(MatStream))
{
BuildMatEntry(MBR, MATEntry);
}
}
return(MATEntry);
}
public float[] ExtractFloatArray()
{
if (string.IsNullOrEmpty(Base64Data))
{
return(Array.Empty <float>());
}
byte[] bytes = Convert.FromBase64String(Base64Data);
bytes = Compression switch
{
Compression.Uncompressed => bytes,
Compression.Zlib => ZlibStream.UncompressBuffer(bytes),
_ => throw new ArgumentOutOfRangeException("Compression", "Unknown compression")
};
return(Bitness switch
{
Bitness.IEEE754FloatLittleEndian => GetFloats(bytes),
Bitness.IEEE754DoubleLittleEndian => GetFloatsFromDoubles(bytes),
_ => throw new ArgumentOutOfRangeException("Bitness", "Unknown bitness")
});
public ClientExample(string endpoint)
{
var utf8 = new UTF8Encoding();
using (var client = new SubscriberSocket())
{
client.Options.ReceiveHighWatermark = 1000;
client.Connect(endpoint);
client.SubscribeToAnyTopic();
while (true)
{
var bytes = client.ReceiveFrameBytes();
var uncompressed = ZlibStream.UncompressBuffer(bytes);
var result = utf8.GetString(uncompressed).Remove(2, 1);
var obj = JsonConvert.DeserializeObject <BaseDataModel <JournalMessage> >(result);
Console.WriteLine(obj.Message.StarSystem);
// var obj = JsonConvert.DeserializeObject<BasicJsonModel>(result);
// if (obj.schemaRef == "https://eddn.edcd.io/schemas/journal/1")
// {
// var msg = JsonConvert.DeserializeObject<JournalMessage>(obj.message);
// }
// else if (obj.schemaRef == "https://eddn.edcd.io/schemas/outfitting/2")
// {
// var msg = JsonConvert.DeserializeObject<OutfittingMessage>(obj.message);
// }
// else if (obj.schemaRef == "https://eddn.edcd.io/schemas/shipyard/2")
// {
// var msg = JsonConvert.DeserializeObject<ShipyardMessage>(obj.message);
// }
// else if (obj.schemaRef == "https://eddn.edcd.io/schemas/commodity/3")
// {
// var message = JsonConvert.DeserializeObject<CommodityMessage>(obj.message);
// Console.WriteLine(message.systemName);
// }
// Console.WriteLine(result);
}
}
}
// 通信結果解凍.サーバーからのレスポンスはzip圧縮されて返ってくる想定.
private System.Object[] UnpackObject(byte[] data)
{
if (data == null || data.Length <= 0)
{
this.IsServerError = true;
return(null);
}
for (int i = 0; i < data.Length; ++i)
{
data[i] = (byte)(data[i] ^ 0x9A);
}
this.ResultObjectBytes = ZlibStream.UncompressBuffer(data); // 解凍にはIonic.Zlib.dllを使用.
var packer = new BoxingPacker();
var result = packer.Unpack(this.ResultObjectBytes) as System.Object[]; // IMsgPackのデシリアライズ
if (result == null)
{
this.IsServerError = true;
}
return(result);
}
public static byte[] Decompress(Stream stream, bool skipType = false)
{
using (var reader = new BinaryReader(stream))
{
if (!skipType)
{
var type = reader.ReadInt32();
}
var realSize = reader.ReadInt32();
var compressedSize = reader.ReadInt32();
var decompressed = ZlibStream.UncompressBuffer(reader.ReadBytes(compressedSize));
if (decompressed.Length != realSize)
{
throw new Exception("Decompressed size does not match the header's value.");
}
return(decompressed);
}
}
// Decryption Routine: Base64 -> AES -> Zlib
private static byte[] Decrypt(PackVersion version, uint size, uint sizeCompressed, Encryption flag, byte[] src)
{
if (flag.HasFlag(Encryption.Aes))
{
// Get the AES Key/IV for transformation
CipherKeys.GetKeyAndIV(version, sizeCompressed, out byte[] key, out byte[] iv);
// Decode the base64 encoded string
src = Convert.FromBase64String(Encoding.UTF8.GetString(src));
// Decrypt the AES encrypted block
AESCipher pCipher = new AESCipher(key, iv);
pCipher.TransformBlock(src, 0, size, src, 0);
}
else if (flag.HasFlag(Encryption.Xor))
{
// Decrypt the XOR encrypted block
src = EncryptXor(version, src, size, sizeCompressed);
}
return(flag.HasFlag(Encryption.Zlib) ? ZlibStream.UncompressBuffer(src) : src);
}
public static void LoadRundata(int projectVersion, string outputPath)
{
string AppDir = AppDomain.CurrentDomain.BaseDirectory;
string fname = "rundata" + projectVersion.ToString();
string RundataPath = Path.Combine(AppDir, fname);
if (!File.Exists(RundataPath))
{
throw new Exception("Unable to find matching rundata file, expected at " + RundataPath);
}
byte[] file = File.ReadAllBytes(RundataPath);
byte[] rawsize = new byte[4];
Array.Copy(file, rawsize, rawsize.Length);
int size = BitConverter.ToInt32(file);
byte[] zlib = new byte[size];
Array.Copy(file, rawsize.Length, zlib, 0, size);
byte[] unpacked = ZlibStream.UncompressBuffer(zlib);
File.WriteAllBytes(outputPath, unpacked);
}
public byte[] DecompressFileEntry(int fileIndex)
{
// Open the archive for reading.
if (OpenArchive(false) == false)
{
// Failed to open the archive.
return(null);
}
// Seek to the start of the file's compressed data
this.reader.BaseStream.Position = this.fileEntries[fileIndex].DataOffset;
// Read the compressed data.
byte[] compressedData = this.reader.ReadBytes(this.fileEntries[fileIndex].CompressedSize);
// Decompress data.
byte[] decompressedData = ZlibStream.UncompressBuffer(compressedData);
// Close the archive and return.
CloseArchive();
return(decompressedData);
}
private static void UE4ChunkUnzip(string source, string destination)
{
using (BinaryReader inReader = new BinaryReader(File.Open(source, FileMode.Open)))
{
using (BinaryWriter binaryWriter = new BinaryWriter(File.Open(destination, FileMode.Create)))
{
FCompressedChunkInfo fcompressedChunkInfo1 = new FCompressedChunkInfo();
fcompressedChunkInfo1.Serialize(inReader);
FCompressedChunkInfo fcompressedChunkInfo2 = new FCompressedChunkInfo();
fcompressedChunkInfo2.Serialize(inReader);
long num1 = fcompressedChunkInfo1.CompressedSize;
long num2 = fcompressedChunkInfo1.UncompressedSize;
if (num2 == 2653586369L)
{
num2 = 131072L;
}
long length = (fcompressedChunkInfo2.UncompressedSize + num2 - 1L) / num2;
FCompressedChunkInfo[] fcompressedChunkInfoArray = new FCompressedChunkInfo[length];
long val2 = 0L;
for (int index = 0; index < length; ++index)
{
fcompressedChunkInfoArray[index] = new FCompressedChunkInfo();
fcompressedChunkInfoArray[index].Serialize(inReader);
val2 = Math.Max(fcompressedChunkInfoArray[index].CompressedSize, val2);
}
for (long index = 0L; index < length; ++index)
{
FCompressedChunkInfo fcompressedChunkInfo3 = fcompressedChunkInfoArray[index];
byte[] buffer = ZlibStream.UncompressBuffer(inReader.ReadBytes((int)fcompressedChunkInfo3.CompressedSize));
binaryWriter.Write(buffer);
}
}
}
}
public async Task DownloadPart(string uri, string filename)
{
var progressReporter = _patcherContext.CreateProgressIndicator();
var fileDirectory = Path.GetDirectoryName(filename);
if (!Directory.Exists(fileDirectory))
{
Directory.CreateDirectory(fileDirectory);
}
Task.Run(async() =>
{
await AsyncDownloader.DownloadFileWithCallbackAsync(uri, filename, (d, s) =>
{
progressReporter.SetLeftText(Path.GetFileName(filename));
progressReporter.SetRightText(s);
progressReporter.SetProgressBar(d);
}, true);
}).Wait();
progressReporter.SetIsIndeterminate(true);
progressReporter.SetRightText(Properties.Resources.Decompressing);
using (var fs = new FileStream(filename, FileMode.Open, FileAccess.ReadWrite))
using (var ms = new MemoryStream())
{
fs.CopyTo(ms);
var buffer = ms.ToArray();
buffer = ZlibStream.UncompressBuffer(buffer);
fs.SetLength(buffer.Length);
fs.Position = 0;
fs.Write(buffer, 0, buffer.Length);
fs.Flush();
}
_patcherContext.DestroyProgressIndicator(progressReporter);
}
public static GemEntry FillGEMEntry(string filename, List <string> subnames, TreeView tree, BinaryReader br, int c, int ID, Type filetype = null)
{
GemEntry GEMentry = new GemEntry();
FillEntry(filename, subnames, tree, br, c, ID, GEMentry, filetype);
GEMentry._FileLength = GEMentry.DSize;
ASCIIEncoding ascii = new ASCIIEncoding();
GEMentry.UncompressedData = ZlibStream.UncompressBuffer(GEMentry.CompressedData);
//Type Specific Work Here.
using (MemoryStream LmtStream = new MemoryStream(GEMentry.UncompressedData))
{
using (BinaryReader bnr = new BinaryReader(LmtStream))
{
BuildGemEntry(bnr, GEMentry, ascii);
}
}
return(GEMentry);
}
public byte[] GetUncompressedData()
{
if (_data != null)
{
return(_data);
}
Span <byte> newData = stackalloc byte[(int)Header.CompressedSizeAligned];
_owner.GetCompressedBytes(Header.FileOffset, Header.CompressedSizeAligned).CopyTo(newData);
if (Header.Flags.HasFlag(FileFlag.Mixed))
{
DecodeFull(newData, Header.CompressedSize);
}
else if (Header.Flags.HasFlag(FileFlag.DES))
{
DecodeHeader(newData);
}
_data = ZlibStream.UncompressBuffer(newData.ToArray());
return(_data);
}
/// <summary>
/// Extracts all files to the specified directory while maintaining file hierarchy
/// </summary>
/// <param name="outputFolder">Output folder to saves files to</param>
/// <returns>True if the files were successfully extracted, false otherwise</returns>
public bool ExtractAllFiles(string outputFolder)
{
// Open the archive for reading.
if (OpenArchive(false) == false)
{
// Failed to open the archive.
return(false);
}
// Loop through all of the files and extract each one.
for (int i = 0; i < this.fileEntries.Count; i++)
{
// Format the folder name and check if it already exists.
string fileName = this.FileEntries[i].FileName;
string fileFolderPath = outputFolder + "\\" + fileName.Substring(0, fileName.LastIndexOf("\\"));
if (Directory.Exists(fileFolderPath) == false)
{
// Create the directory now.
Directory.CreateDirectory(fileFolderPath);
}
// Seek to the start of the file's compressed data.
this.reader.BaseStream.Position = this.fileEntries[i].DataOffset;
// Read the compressed data.
byte[] compressedData = this.reader.ReadBytes(this.fileEntries[i].CompressedSize);
// Decompress and write to file.
byte[] decompressedData = ZlibStream.UncompressBuffer(compressedData);
File.WriteAllBytes(string.Format("{0}\\{1}.{2}", fileFolderPath, fileName.Substring(fileName.LastIndexOf("\\") + 1),
this.fileEntries[i].FileType.ToString()), decompressedData);
}
// Close the archive and return.
CloseArchive();
return(true);
}
public static byte[] DecompressData(FileStream stream)
{
List <byte> decompressed = new List <byte>();
var header = ReadHeader(stream);
for (int i = 0; i < header.BlockOffset.Count; i++)
{
stream.Seek(header.BlockOffset[i], SeekOrigin.Begin);
uint count = 0;
if (i == header.BlockOffset.Count - 1) //处理最后一个
{
count = (uint)stream.Length - header.BlockOffset[i];
}
else
{
count = header.BlockOffset[i + 1] - header.BlockOffset[i];
}
byte[] temp = new byte[count];
stream.Read(temp, 0, temp.Length);
byte[] dtemp = ZlibStream.UncompressBuffer(temp);
decompressed.AddRange(dtemp);
}
return(decompressed.ToArray());
}
private static byte[] DecompressRpmsg(byte[] compressedBytes)
{
LogUtils.Log("");
using (MemoryStream fsOut = new MemoryStream())
{
using (MemoryStream fsIn = new MemoryStream(compressedBytes))
{
byte[] header = new byte[12];
byte[] compressedData = new byte[1];
fsIn.Seek(RPMSG_PREFIX.Length, SeekOrigin.Begin);
while (true)
{
if (fsIn.Read(header, 0, 12) != 12)
{
break;
}
// int marker = BitConverter.ToInt32(header, 0);
// int sizeUncompressed = BitConverter.ToInt32(header, 4);
int sizeCompressed = BitConverter.ToInt32(header, 8);
if (sizeCompressed > compressedData.Length)
{
compressedData = new byte[sizeCompressed];
}
fsIn.Read(compressedData, 0, sizeCompressed);
fsOut.Write(compressedData, 0, sizeCompressed);
}
}
return(ZlibStream.UncompressBuffer(fsOut.ToArray()));
}
}
public static byte[] Convert(XmlData data, string json)
{
var obj = JsonConvert.DeserializeObject <json_dat>(json);
byte[] dat = ZlibStream.UncompressBuffer(obj.data);
var tileDict = new Dictionary <short, TerrainTile>();
for (int i = 0; i < obj.dict.Length; i++)
{
loc o = obj.dict[i];
tileDict[(short)i] = new TerrainTile
{
TileId = o.ground == null ? (ushort)0xff : data.IdToTileType[o.ground],
TileObj = o.objs == null ? null : o.objs[0].id,
Name = o.objs == null ? "" : o.objs[0].name ?? "",
Terrain = TerrainType.None,
Region =
o.regions == null
? TileRegion.None
: (TileRegion)Enum.Parse(typeof(TileRegion), o.regions[0].id.Replace(' ', '_'))
};
}
var tiles = new TerrainTile[obj.width, obj.height];
using (var rdr = new NReader(new MemoryStream(dat)))
for (int y = 0; y < obj.height; y++)
{
for (int x = 0; x < obj.width; x++)
{
tiles[x, y] = tileDict[rdr.ReadInt16()];
}
}
return(WorldMapExporter.Export(tiles));
}
private static void Extract()
{
var stream = File.OpenRead("playlists.aggr");
var reader = new BinaryReader(stream);
var streams = new List <byte[]>();
while (reader.ReadUInt16() == 1)
{
var offset = reader.ReadUInt16();
var length = reader.ReadUInt16();
var oldPos = stream.Position;
stream.Position = offset;
var bytes = reader.ReadBytes(length);
streams.Add(ZlibStream.UncompressBuffer(bytes));
stream.Position = oldPos;
}
File.WriteAllBytes("playlists.info", streams[0]);
File.WriteAllBytes("stuff.info", streams[1]);
}
