private void ReadHeader() { if (FileStream.CanWrite && FileStream.Length < 1) { byte[] zbuf = ZlibStream.CompressBuffer(new byte[0]); byte[] zero = new byte[4]; int zlen_le = EndianConverter.LittleEndian(zbuf.Length), zero_fcount = EndianConverter.LittleEndian(7), create_ver = EndianConverter.LittleEndian(m_IntVersion); FileStream.Write(Encoding.ASCII.GetBytes(GRF_HEADER), 0, GRF_HEADER_LEN); FileStream.Write(CryptWatermark, 0, CryptWatermark.Length); FileStream.Write(zero, 0, 4); FileStream.Write(zero, 0, 4); FileStream.Write(BitConverter.GetBytes(zero_fcount), 0, 4); FileStream.Write(BitConverter.GetBytes(create_ver), 0, 4); FileStream.Write(BitConverter.GetBytes(zlen_le), 0, 4); FileStream.Write(zero, 0, 4); FileStream.Write(zbuf, 0, zbuf.Length); FileStream.Seek(0, SeekOrigin.Begin); } byte[] buf = new byte[GRF_HEADER_FULL_LEN]; FileStream.Read(buf, 0, buf.Length); if (buf[GRF_HEADER_LEN + 1] == 1) { m_AllowCrypt = true; // 00 01 02 03 04 05 06 07 08 09 0A 0B 0C 0D 0E for (byte i = 0; i < 0xF; i++) { if (buf[GRF_HEADER_LEN + i] != i) { throw new GrfException(); } } } else if (buf[GRF_HEADER_LEN] == 0) { m_AllowCrypt = false; // 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 for (byte i = 0; i < 0xF; i++) { if (buf[GRF_HEADER_LEN + i] != 0) { throw new GrfException(); } } } else { throw new GrfException(); } using (IntPtrEx pBuffer = new IntPtrEx(buf)) { m_Items = new GrfItemCollection(this); m_IntVersion = EndianConverter.LittleEndian(pBuffer.Read <int>(GRF_HEADER_MID_LEN + 0xC)); m_Items.Capacity = EndianConverter.LittleEndian(pBuffer.Read <int>(GRF_HEADER_MID_LEN + 8)) - EndianConverter.LittleEndian(pBuffer.Read <int>(GRF_HEADER_MID_LEN + 4)) - 7; FileStream.Seek(EndianConverter.LittleEndian(pBuffer.Read <int>(GRF_HEADER_MID_LEN) + GRF_HEADER_FULL_LEN), SeekOrigin.Begin); } switch (m_IntVersion & 0xFF00) { case 0x0200: ReadVer2Info(); break; case 0x0100: ReadVer1Info(); break; default: throw new GrfException(); } }
/// <summary> /// This this grf in the specified path. /// </summary> /// <param name="filepath">The path where to save the grf.</param> public void SaveAs(string filepath) { // Write to temporary file string tempfile = Path.GetTempFileName(); FileStream fs = new FileStream(tempfile, FileMode.Create); BinaryWriter bw = new BinaryWriter(fs); byte[] signatureByte = new byte[Math.Max(_signature.Length, 15)]; Encoding.ASCII.GetBytes(_signature).CopyTo(signatureByte, 0); bw.Write(signatureByte, 0, 15); bw.Write((byte)0); bw.Write(_encryptionKey, 0, 14); bw.Write((int)0); // will be updated later bw.Write((int)_m1); bw.Write((int)_GRFFiles.Count + _m1 + 7); bw.Write((int)0x200); // We always save as 2.0 OnGRFMetaWriteComplete(); foreach (GRFFile file in _GRFFiles) { file.SaveBody(bw); OnFileBodyWriteComplete(new GRFEventArg(file)); } bw.Flush(); int fileTablePos = (int)fs.Position; MemoryStream bodyStream = new MemoryStream(); BinaryWriter bw2 = new BinaryWriter(bodyStream); foreach (GRFFile file in _GRFFiles) { file.Save(bw2); OnFileTableWriteComplete(new GRFEventArg(file)); } bw2.Flush(); //byte[] compressedBody = new byte[_uncompressedLength + 100]; //int size = compressedBody.Length; //ZLib.compress(compressedBody, ref size, bodyStream.GetBuffer(), (int)bodyStream.Length); byte[] compressedBody = ZlibStream.CompressBuffer(bodyStream.GetBuffer()); bw.Write((int)compressedBody.Length); bw.Write((int)bodyStream.Length); bw.Write(compressedBody, 0, compressedBody.Length); bw2.Close(); // Update file table offset bw.BaseStream.Seek(30, SeekOrigin.Begin); bw.Write((int)fileTablePos - 46); bw.Close(); if (_grfStream != null) { _grfStream.Close(); } File.Copy(tempfile, filepath, true); OnGRFSaveComplete(); _filePathToGRF = filepath; Close(); Open(); }
public static void Process(string filename, string paramfile) { var firmware = File.ReadAllText(filename); var param = File.ReadAllText(paramfile).Replace("\r", ""); var fw_json = JsonConvert.DeserializeObject <Hashtable>(firmware); var fw_base64 = fw_json["image"].ToString(); var fw_binary = new MemoryStream(); ZlibStream decompressionStream = new ZlibStream(new MemoryStream(Convert.FromBase64String(fw_base64)), CompressionMode.Decompress); decompressionStream.CopyTo(fw_binary); var magic_str = "PARMDEF"; var param_magic = new byte[] { 0x55, 0x37, 0xf4, 0xa0, 0x38, 0x5d, 0x48, 0x5b }; fw_binary.Position = 0; var offset = ReadOneSrch(fw_binary, magic_str.Select(a => (byte)a).ToArray()); if (offset == -1) { throw new Exception("No param area found"); } var magicoffset = ReadOneSrch(fw_binary, param_magic); if (magicoffset != -1) { var foffset = fw_binary.Position; var br = new BinaryReader(fw_binary); var max_len = br.ReadInt16(); var length = br.ReadInt16(); Console.WriteLine("Found param defaults max_length={0} length={1}", max_len, length); if (param.Length > max_len) { throw new Exception(String.Format("Error: Length {0} larger than maximum {1}", length, max_len)); } var paramdata = new byte[length]; br.Read(paramdata, 0, length); var paramstring = ASCIIEncoding.ASCII.GetString(paramdata); var new_fwms = new MemoryStream(fw_binary.GetBuffer()); var new_fw = new BinaryWriter(new_fwms); new_fw.Seek((int)foffset + 2, SeekOrigin.Begin); new_fw.Write((short)param.Length); new_fw.Write(ASCIIEncoding.ASCII.GetBytes(param), 0, param.Length); fw_json["image"] = Convert.ToBase64String(ZlibStream.CompressBuffer(new_fwms.GetBuffer())); //File.WriteAllBytes(filename + "orig.bin", fw_binary.ToArray()); //File.WriteAllBytes(filename + "new.bin", new_fwms.ToArray()); File.WriteAllText(filename + "new.apj", JsonConvert.SerializeObject(fw_json, Formatting.Indented)); return; } throw new Exception("Error: Param defaults support not found in firmware"); }
public void ReCompress() { this.Compressed = ZlibStream.CompressBuffer(this.Content); }
public override void WriteJson(JsonWriter writer, object?value, JsonSerializer serializer) { if (value is byte[] data) { writer.WriteValue(Convert.ToBase64String(data.Length > Treshold ? ZlibStream.CompressBuffer(data) : data)); } else { writer.WriteNull(); } }
public void SaveCharacter(Account acc, Char chr) { MySqlCommand cmd = CreateQuery(); cmd.CommandText = @"UPDATE characters SET level=@level, exp=@exp, fame=@fame, items=@items, stats=@stats, hp=@hp, mp=@mp, tex1=@tex1, tex2=@tex2, pet=@pet, fameStats=@fameStats WHERE accId=@accId AND charId=@charId;"; cmd.Parameters.AddWithValue("@accId", acc.AccountId); cmd.Parameters.AddWithValue("@charId", chr.CharacterId); cmd.Parameters.AddWithValue("@level", chr.Level); cmd.Parameters.AddWithValue("@exp", chr.Exp); cmd.Parameters.AddWithValue("@fame", chr.CurrentFame); cmd.Parameters.AddWithValue("@items", Utils.GetCommaSepString(chr.EquipSlots())); cmd.Parameters.AddWithValue("@stats", Utils.GetCommaSepString(new[] { chr.MaxHitPoints, chr.MaxMagicPoints, chr.Attack, chr.Defense, chr.Speed, chr.HpRegen, chr.MpRegen, chr.Dexterity })); cmd.Parameters.AddWithValue("@hp", chr.HitPoints); cmd.Parameters.AddWithValue("@mp", chr.MagicPoints); cmd.Parameters.AddWithValue("@tex1", chr.Tex1); cmd.Parameters.AddWithValue("@tex2", chr.Tex2); cmd.Parameters.AddWithValue("@pet", chr.Pet); chr.PCStats = Convert.ToBase64String(ZlibStream.CompressBuffer(chr.FameStats.Write())) .Replace('+', '-') .Replace('/', '_'); cmd.Parameters.AddWithValue("@fameStats", chr.PCStats); cmd.ExecuteNonQuery(); cmd = CreateQuery(); cmd.CommandText = @"INSERT INTO classstats(accId, objType, bestLv, bestFame) VALUES(@accId, @objType, @bestLv, @bestFame) ON DUPLICATE KEY UPDATE bestLv = GREATEST(bestLv, @bestLv), bestFame = GREATEST(bestFame, @bestFame);"; cmd.Parameters.AddWithValue("@accId", acc.AccountId); cmd.Parameters.AddWithValue("@objType", chr.ObjectType); cmd.Parameters.AddWithValue("@bestLv", chr.Level); cmd.Parameters.AddWithValue("@bestFame", chr.CurrentFame); cmd.ExecuteNonQuery(); SaveBackpacks(chr, acc); }
/// <summary> /// Flush all data to the TCPClient NetworkStream. /// </summary> public void FlushData(bool quee = false) { try { var allData = _bffr.ToArray(); _bffr.Clear(); if (ServerSettings.UseCompression && _client.PacketMode == PacketMode.Play && _client.SetCompressionSend) { bool isOver = (allData.Length >= ServerSettings.CompressionThreshold); int dataLength = isOver ? allData.Length : 0; //Calculate length of 'Data Length' byte[] dLength = GetVarIntBytes(dataLength); //Create all data var compressedBytes = ZlibStream.CompressBuffer(allData); int packetlength = compressedBytes.Length + dLength.Length; var dataToSend = isOver ? compressedBytes : allData; var compressed = new DataBuffer(_client); compressed.WriteVarInt(packetlength); compressed.WriteVarInt(dataLength); compressed.Write(dataToSend); Console.WriteLine(); Console.WriteLine("Packet bigger than Threshold: " + isOver); Console.WriteLine("Packet info: "); Console.WriteLine("(Header) Packet Length: " + packetlength); Console.WriteLine("(Header) Data Length: " + dataLength); Console.WriteLine("Data Length " + dataToSend.Length); Console.WriteLine("Length difference: " + (packetlength - dataToSend.Length)); Console.WriteLine(); _client.AddToQuee(compressed.ExportWriter, quee); } else { WriteVarInt(allData.Length); var buffer = _bffr.ToArray(); var data = new List <byte>(); foreach (var i in buffer) { data.Add(i); } foreach (var i in allData) { data.Add(i); } _client.AddToQuee(data.ToArray(), quee); } _bffr.Clear(); } catch (Exception ex) { // ConsoleFunctions.WriteErrorLine("Failed to send a packet!\n" + ex); Globals.ClientManager.PacketError(_client, ex); } }
public static byte[] Compress(this byte[] value) { // compress return(ZlibStream.CompressBuffer(value)); }
/// <summary>ZLib encoder.</summary> /// <param name="input">The input.</param> /// <returns>Compressed data.</returns> public static byte[] ZLibEncoder(byte[] input) { return(ZlibStream.CompressBuffer(input)); }
/// <summary> /// Convert the ushort array to a byte arraay, compressing with the requested algorithm if required /// </summary> /// <param name="data"></param> /// <returns>Uncompressed or compressed byte array</returns> private byte[] PrepareArray(ushort[] data) { byte[] outArray; /* * Convert the ushort[] into a byte[] * From here onwards we deal in byte arrays only */ byte[] byteArray = new byte[data.Length * ShuffleItemSize]; Buffer.BlockCopy(data, 0, byteArray, 0, data.Length * ShuffleItemSize); /* * Compress the data block as configured. */ using (MyStopWatch.Measure($"XISF Compression = {CompressionType}")) { if (CompressionType == XISFCompressionTypeEnum.LZ4) { if (ByteShuffling) { CompressionName = "lz4+sh"; byteArray = Shuffle(byteArray, ShuffleItemSize); } else { CompressionName = "lz4"; } byte[] tmpArray = new byte[LZ4Codec.MaximumOutputSize(byteArray.Length)]; int compressedSize = LZ4Codec.Encode(byteArray, 0, byteArray.Length, tmpArray, 0, tmpArray.Length, LZ4Level.L00_FAST); outArray = new byte[compressedSize]; Array.Copy(tmpArray, outArray, outArray.Length); tmpArray = null; } else if (CompressionType == XISFCompressionTypeEnum.LZ4HC) { if (ByteShuffling) { CompressionName = "lz4hc+sh"; byteArray = Shuffle(byteArray, ShuffleItemSize); } else { CompressionName = "lz4hc"; } byte[] tmpArray = new byte[LZ4Codec.MaximumOutputSize(byteArray.Length)]; int compressedSize = LZ4Codec.Encode(byteArray, 0, byteArray.Length, tmpArray, 0, tmpArray.Length, LZ4Level.L06_HC); outArray = new byte[compressedSize]; Array.Copy(tmpArray, outArray, outArray.Length); tmpArray = null; } else if (CompressionType == XISFCompressionTypeEnum.ZLIB) { if (ByteShuffling) { CompressionName = "zlib+sh"; byteArray = Shuffle(byteArray, ShuffleItemSize); } else { CompressionName = "zlib"; } outArray = ZlibStream.CompressBuffer(byteArray); } else { outArray = new byte[byteArray.Length]; Array.Copy(byteArray, outArray, outArray.Length); CompressionName = null; } } // Revert to the original data array in case the compression is bigger than uncompressed if (outArray.Length > byteArray.Length) { if (ByteShuffling) { //As the original array is shuffled it needs to be unshuffled again - this scenario should be highly unlikely anyways outArray = Unshuffle(byteArray, ShuffleItemSize); } else { outArray = byteArray; } CompressionType = XISFCompressionTypeEnum.NONE; Logger.Debug("XISF output array is larger after compression. Image will be prepared uncompressed instead."); } if (CompressionType != XISFCompressionTypeEnum.NONE) { double percentChanged = (1 - ((double)outArray.Length / (double)byteArray.Length)) * 100; Logger.Debug($"XISF: {CompressionType} compressed {byteArray.Length} bytes to {outArray.Length} bytes ({percentChanged.ToString("#.##")}%)"); } /* * Checksum the data block as configured. * If the data block is compressed, we always checksum the compressed form, not the uncompressed form. */ using (MyStopWatch.Measure($"XISF Checksum = {ChecksumType}")) { SHA3Managed sha3; switch (ChecksumType) { case XISFChecksumTypeEnum.SHA1: SHA1 sha1 = new SHA1CryptoServiceProvider(); Checksum = GetStringFromHash(sha1.ComputeHash(outArray)); ChecksumName = "sha-1"; sha1.Dispose(); break; case XISFChecksumTypeEnum.SHA256: SHA256 sha256 = new SHA256CryptoServiceProvider(); Checksum = GetStringFromHash(sha256.ComputeHash(outArray)); ChecksumName = "sha-256"; sha256.Dispose(); break; case XISFChecksumTypeEnum.SHA512: SHA512 sha512 = new SHA512CryptoServiceProvider(); Checksum = GetStringFromHash(sha512.ComputeHash(outArray)); ChecksumName = "sha-512"; sha512.Dispose(); break; case XISFChecksumTypeEnum.SHA3_256: sha3 = new SHA3Managed(256); Checksum = GetStringFromHash(sha3.ComputeHash(outArray)); ChecksumName = "sha3-256"; sha3.Dispose(); break; case XISFChecksumTypeEnum.SHA3_512: sha3 = new SHA3Managed(512); Checksum = GetStringFromHash(sha3.ComputeHash(outArray)); ChecksumName = "sha3-512"; sha3.Dispose(); break; case XISFChecksumTypeEnum.NONE: default: Checksum = null; ChecksumName = null; break; } } return(outArray); }
internal override void Encode() { int Count = 6; this.Data.AddBool(false); this.Data.AddVInt(0); this.Data.AddVInt(21); this.Data.AddVInt((int)TimeUtils.ToUnixTimestamp(DateTime.Now)); // Timestamp this.Data.AddVInt(11); this.Data.AddVInt(0); this.Data.AddRange("D0B5AFB4E6A8D9EF".HexaToBytes()); // Checksum? this.Data.AddVInt(6); this.Data.AddVInt(1); this.Data.AddRange("7F7F7F7F0000".HexaToBytes()); // Enemy ID this.Data.AddString(string.Empty); this.Data.AddVInt(21); this.Data.AddVInt(9999); this.Data.AddVInt(0); this.Data.AddVInt(0); this.Data.AddVInt(0); this.Data.AddVInt(0); this.Data.AddVInt(0); this.Data.AddVInt(0); this.Data.AddVInt(0); this.Data.AddVInt(0); this.Data.AddVInt(0); this.Data.AddVInt(0); this.Data.AddVInt(0); this.Data.AddVInt(0); this.Data.AddVInt(7); this.Data.AddVInt(0); this.Data.AddVInt(0); this.Data.AddVInt(0); this.Data.AddVInt(0); this.Data.AddVInt(0); this.Data.AddVInt(0); this.Data.AddVInt(0); this.Data.AddVInt(11); this.Data.AddVInt(0); this.Data.AddVInt(0); this.Data.AddVInt(0); this.Data.AddVInt(0); this.Data.AddVInt(0); this.Data.AddVInt(0); this.Data.AddVInt(0); this.Data.AddVInt(0); this.Data.AddVInt(0); this.Data.AddVInt(0); this.Data.AddVInt(4); this.Data.AddRange(this.Device.Player.Battle.ToBytes); this.Data.AddVInt(1); this.Data.AddVInt(0); this.Data.AddVInt(0); this.Data.AddVInt(2); this.Data.AddVInt(2); //Player amount this.Data.AddVInt(44); this.Data.AddVInt(1); this.Data.AddHexa("7F7F"); this.Data.AddVInt(0); this.Data.AddVInt(this.Device.Player.UserHighId); this.Data.AddVInt(this.Device.Player.UserLowId); this.Data.AddVInt(0); this.Data.AddVInt(0); this.Data.AddVInt(0); this.Data.AddVInt(0); this.Data.AddVInt(0); this.Data.AddVInt(0); this.Data.AddVInt(0); this.Data.AddVInt(0); this.Data.AddVInt(0); this.Data.AddVInt(0); // IsTrainer // True = NPC // False = PVP this.Data.AddBool(true); this.Data.AddVInt(0); this.Data.AddVInt(0); this.Data.AddVInt(0); this.Data.AddVInt(142); this.Data.AddVInt(62077); this.Data.AddVInt(0); this.Data.AddVInt(0); this.Data.AddVInt(Count); this.Data.AddVInt(Count); this.Data.AddVInt(35); this.Data.AddVInt(1); this.Data.AddVInt(35); this.Data.AddVInt(1); this.Data.AddVInt(35); this.Data.AddVInt(1); this.Data.AddVInt(35); this.Data.AddVInt(1); this.Data.AddVInt(35); this.Data.AddVInt(0); this.Data.AddVInt(35); this.Data.AddVInt(0); this.Data.AddVInt(1); this.Data.AddVInt(0); this.Data.AddVInt(1); this.Data.AddVInt(0); this.Data.AddVInt(0); this.Data.AddVInt(1); for (int Index = 0; Index < Count; Index++) { this.Data.AddVInt(5); this.Data.AddVInt(Index); } this.Data.AddVInt(12); //Level Tower R this.Data.AddVInt(13); //Prefixed this.Data.AddVInt(14500); //Tower R Z this.Data.AddVInt(25500); //Tower R Y this.Data.AddVInt(0); this.Data.AddVInt(0); this.Data.AddVInt(49276); this.Data.AddVInt(0); this.Data.AddVInt(41985); this.Data.AddVInt(0); this.Data.AddVInt(0); this.Data.AddVInt(0); this.Data.AddVInt(0); this.Data.AddVInt(2); this.Data.AddVInt(0); this.Data.AddVInt(0); this.Data.AddVInt(0); this.Data.AddVInt(0); this.Data.AddVInt(0); this.Data.AddVInt(0); this.Data.AddVInt(0); this.Data.AddVInt(0); this.Data.AddVInt(12); //Level Tower R Enemy this.Data.AddVInt(13); //Prefixed this.Data.AddVInt(3500); //Tower R Enemy X this.Data.AddVInt(6500); //Tower R Enemy Y this.Data.AddVInt(0); this.Data.AddVInt(0); this.Data.AddVInt(32772); this.Data.AddVInt(0); this.Data.AddVInt(41985); this.Data.AddVInt(0); this.Data.AddVInt(0); this.Data.AddVInt(0); this.Data.AddVInt(0); this.Data.AddVInt(1); this.Data.AddVInt(0); this.Data.AddVInt(0); this.Data.AddVInt(0); this.Data.AddVInt(0); this.Data.AddVInt(0); this.Data.AddVInt(0); this.Data.AddVInt(0); this.Data.AddVInt(0); this.Data.AddVInt(12); //Level Tower L this.Data.AddVInt(13); //Prefixed this.Data.AddVInt(3500); //Tower L X this.Data.AddVInt(25500); //Tower L Y this.Data.AddVInt(0); this.Data.AddVInt(0); this.Data.AddVInt(49276); this.Data.AddVInt(0); this.Data.AddVInt(41985); this.Data.AddVInt(0); this.Data.AddVInt(0); this.Data.AddVInt(0); this.Data.AddVInt(0); this.Data.AddVInt(1); this.Data.AddVInt(0); this.Data.AddVInt(0); this.Data.AddVInt(0); this.Data.AddVInt(0); this.Data.AddVInt(0); this.Data.AddVInt(0); this.Data.AddVInt(0); this.Data.AddVInt(0); this.Data.AddVInt(12); //Level Tower L Enemy this.Data.AddVInt(13); //Prefixed this.Data.AddVInt(14500); //Tower L Enemy X this.Data.AddVInt(6500); //Tower L Enemy Y this.Data.AddVInt(0); this.Data.AddVInt(0); this.Data.AddVInt(32772); this.Data.AddVInt(0); this.Data.AddVInt(41985); this.Data.AddVInt(0); this.Data.AddVInt(0); this.Data.AddVInt(0); this.Data.AddVInt(0); this.Data.AddVInt(1); this.Data.AddVInt(0); this.Data.AddVInt(0); this.Data.AddVInt(0); this.Data.AddVInt(0); this.Data.AddVInt(0); this.Data.AddVInt(0); this.Data.AddVInt(0); this.Data.AddVInt(0); this.Data.AddVInt(12); //Enemy Crown Tower Level this.Data.AddVInt(13); //Prefixed this.Data.AddVInt(9000); //Crown Tower Enemy X this.Data.AddVInt(3000); //Tower Tower Enemy Y this.Data.AddVInt(0); this.Data.AddVInt(0); this.Data.AddVInt(32772); this.Data.AddVInt(0); this.Data.AddVInt(41985); this.Data.AddVInt(0); this.Data.AddVInt(0); this.Data.AddVInt(0); this.Data.AddVInt(0); this.Data.AddVInt(0); this.Data.AddVInt(0); this.Data.AddVInt(0); this.Data.AddVInt(0); this.Data.AddVInt(0); this.Data.AddVInt(0); this.Data.AddVInt(0); this.Data.AddVInt(0); this.Data.AddVInt(0); this.Data.AddVInt(0); this.Data.AddVInt(5); this.Data.AddVInt(4); this.Data.AddVInt(5); this.Data.AddRange("027D020401030200007F7F000000".HexaToBytes()); this.Data.AddVInt(5); // Elixir Start this.Data.AddHexa("00000000007F7F7F7F7F7F7F7F"); this.Data.AddVInt(12); //Crown Tower Level this.Data.AddVInt(13); //Prefixed this.Data.AddVInt(9000); //Crown Tower X this.Data.AddVInt(29000); //Crown Tower Tower Y this.Data.AddVInt(0); this.Data.AddVInt(0); this.Data.AddVInt(49276); this.Data.AddVInt(0); this.Data.AddVInt(41985); this.Data.AddVInt(0); this.Data.AddVInt(0); this.Data.AddVInt(0); this.Data.AddVInt(0); this.Data.AddVInt(0); this.Data.AddVInt(0); this.Data.AddVInt(0); this.Data.AddVInt(0); this.Data.AddVInt(0); this.Data.AddVInt(0); this.Data.AddVInt(0); this.Data.AddVInt(0); this.Data.AddVInt(0); this.Data.AddVInt(0); this.Data.AddVInt(5); this.Data.AddVInt(4); this.Data.AddVInt(6); this.Data.AddRange("7B067E0403000204007F7F000000".HexaToBytes()); this.Data.AddVInt(5); // Elixir Start this.Data.AddRange("00000000007F7F7F7F7F7F7F7F".HexaToBytes()); for (int Index = 0; Index < 48; Index++) { this.Data.AddVInt(0); } this.Data.AddVInt(3668); // Player R this.Data.AddVInt(3668); // Enemy R this.Data.AddVInt(3668); // Player L this.Data.AddVInt(3668); // Enemy L this.Data.AddVInt(5832); // Enemy Crown this.Data.AddVInt(5832); // Player Crown for (int Index = 0; Index < Count; Index++) { this.Data.AddVInt(0); this.Data.AddVInt(0); this.Data.AddVInt(0); this.Data.AddVInt(0); this.Data.AddVInt(0); this.Data.AddVInt(0); this.Data.AddVInt(0); this.Data.AddVInt(41985); this.Data.AddVInt(41985); } this.Data.AddRange("FF0184010A2A0B1F0B190B2509020B0707060B00".HexaToBytes()); //Deck - Card Type-ID-Level this.Data.AddHexa("FE03"); this.Data.AddRange(this.Device.Player.Decks.Hand()); this.Data.AddRange("0000050602020402010300000000000000060901010000000000000000000000010000000000000000000000000C00000080A1B0A80F002A002B".HexaToBytes()); ZlibStream.CompressBuffer(this.Data.ToArray()); }
/// <summary> /// 圧縮 /// </summary> public byte[] Deflate() { //データ部圧縮 //compress datas List <int> originalContentDataSizeTable = new List <int>(); List <byte[]> compressedContentDataTable = new List <byte[]>(_contentFileInfoTable.Count); int compressedContentDataTableSize = 0; for (int contentIndex = 0; contentIndex < _contentFileInfoTable.Count; contentIndex++) { var fileInfo = _contentFileInfoTable[contentIndex]; var data = System.IO.File.ReadAllBytes(fileInfo.FullName); originalContentDataSizeTable.Add(data.Length); var compressed = ZlibStream.CompressBuffer(data); compressedContentDataTableSize += compressed.Length; compressedContentDataTable.Add(compressed); } //ファイル名部圧縮 //compress name table byte[] compressedContentNameTable = null; int compressedContentNameTableSize = 0; { //全ファイル名結合 System.Text.StringBuilder builder = new System.Text.StringBuilder(); foreach (var s in _contentNameTable) { builder.Append(s); compressedContentNameTableSize += System.Text.Encoding.UTF8.GetByteCount(s); } compressedContentNameTable = ZlibStream.CompressString(builder.ToString()); } //コンテンツ情報部圧縮 //compress contents byte[] compressedContentTable = null; { byte[] headerTable = new byte[SZipContent.Size * _contentFileInfoTable.Count]; using (MemoryStream stream = new MemoryStream(headerTable)) { using (BinaryWriter writer = new BinaryWriter(stream)) { for (int contentIndex = 0; contentIndex < _contentFileInfoTable.Count; contentIndex++) { var content = new SZipContent(); System.UInt32 crc = SZipUtility.FNVHash(compressedContentDataTable[contentIndex]); content.Set(_contentNameTable[contentIndex].Length, originalContentDataSizeTable[contentIndex], compressedContentDataTable[contentIndex].Length, crc); content.Write(writer); } } } compressedContentTable = ZlibStream.CompressBuffer(headerTable); } //ヘッダ生成 //create szip header var header = new SZipHeader(); header.Set((System.Int16)_contentFileInfoTable.Count, SZipUtility.FNVHash(compressedContentNameTable), SZipUtility.FNVHash(compressedContentTable), compressedContentTable.Length, compressedContentNameTableSize, compressedContentNameTable.Length); //書き込み //write to byte[] { int totalSize = SZipHeader.Size + compressedContentTable.Length + compressedContentNameTable.Length + compressedContentDataTableSize; byte[] output = new byte[totalSize]; using (MemoryStream stream = new MemoryStream(output)) { using (BinaryWriter writer = new BinaryWriter(stream)) { //ヘッダ header.Write(writer); //コンテンツ writer.Write(compressedContentTable); //コンテンツ名 writer.Write(compressedContentNameTable); //データ foreach (var data in compressedContentDataTable) { writer.Write(data); } } } return(output); } }
public byte[] GetZlib() { byte[] ret = ZlibStream.CompressBuffer(((MemoryStream)MyStream).ToArray()); return(ret); }
private void FlushVer2() { byte[] buffer = new byte[m_Items.Count * GRF_ITEM_SIZE]; IntPtrEx pName; int i, offset, len; GrfFileInfo gfile = null; try { m_Items.SortToPosition(); using (IntPtrEx pBuffer = new IntPtrEx(buffer)) { for (i = offset = 0; i < Items.Count; i++) { len = m_Items[i].FullName.Length + 1; using (pName = new IntPtrEx(m_Items[i].FullName)) { Marshal.Copy(pName, buffer, offset, len); } offset += len; if (m_Items[i] is GrfFileInfo) { gfile = (GrfFileInfo)m_Items[i]; if (m_ForceRepack) { gfile.CompressedLength = 0; gfile.AlignedCompressedLength = 0; gfile.Position = 0; } if (gfile.CompressedLength == 0 && gfile.AlignedCompressedLength == 0 && gfile.Position == 0 && gfile.Length != 0) { if (!m_AllowCrypt) { gfile.Flags &= ~(GrfFileFlags.MixCrypt | GrfFileFlags.Des_0x14); } FlushFile(i); } pBuffer.Write <int>(offset, EndianConverter.LittleEndian(gfile.CompressedLength)); pBuffer.Write <int>(offset + 4, EndianConverter.LittleEndian(gfile.AlignedCompressedLength)); pBuffer.Write <int>(offset + 8, EndianConverter.LittleEndian(gfile.Length)); pBuffer.Write <int>(offset + 0xD, EndianConverter.LittleEndian(gfile.Position - GRF_HEADER_FULL_LEN)); } else { pBuffer.Write <int>(offset, EndianConverter.LittleEndian(GrfItem.GRFFILE_DIR_SZSMALL)); pBuffer.Write <int>(offset + 4, EndianConverter.LittleEndian(GrfItem.GRFFILE_DIR_SZFILE)); pBuffer.Write <int>(offset + 8, EndianConverter.LittleEndian(GrfItem.GRFFILE_DIR_SZORIG)); pBuffer.Write <int>(offset + 0xD, EndianConverter.LittleEndian(GrfItem.GRFFILE_DIR_OFFSET - GRF_HEADER_FULL_LEN)); } pBuffer.Write <byte>(offset + 0xC, (byte)m_Items[i].Flags); offset += 0x11; } } } catch (Exception ex) { throw new Exception(ex.Message); } Array.Resize <byte>(ref buffer, offset); buffer = ZlibStream.CompressBuffer(buffer); m_Items.SortToPosition(); int writeOffset = m_Items.FindUnused(8 + buffer.Length); if (writeOffset == 0) { FileStream.Seek(0, SeekOrigin.End); writeOffset = (int)FileStream.Position; } else { FileStream.Seek(writeOffset, SeekOrigin.Begin); } FileStream.Write(BitConverter.GetBytes(EndianConverter.LittleEndian(buffer.Length)), 0, 4); FileStream.Write(BitConverter.GetBytes(EndianConverter.LittleEndian(offset)), 0, 4); FileStream.Write(buffer, 0, buffer.Length); FileStream.Seek(GRF_HEADER_MID_LEN, SeekOrigin.Begin); FileStream.Write(BitConverter.GetBytes(EndianConverter.LittleEndian(writeOffset - GRF_HEADER_FULL_LEN)), 0, 4); FileStream.Write(BitConverter.GetBytes(0), 0, 4); FileStream.Write(BitConverter.GetBytes(EndianConverter.LittleEndian(i + 7)), 0, 4); }
public static ChunkDataPacket CreatePacket(Chunk chunk) { var packet = new ChunkDataPacket(); var X = (int)chunk.AbsolutePosition.X; var Z = (int)chunk.AbsolutePosition.Z; byte[] blockData; byte[] metadata; byte[] blockLight; byte[] skyLight; ushort mask = 1, chunkY = 0; bool nonAir = true; // First pass calculates number of sections to send int totalSections = 0; for (int i = 15; i >= 0; i--) { Section s = chunk.Sections[chunkY++]; if (s.IsAir) { nonAir = false; } if (nonAir) { totalSections++; } } mask = 1; chunkY = 0; nonAir = true; blockData = new byte[totalSections * BlockDataLength]; metadata = new byte[totalSections * NibbleDataLength]; blockLight = new byte[totalSections * NibbleDataLength]; skyLight = new byte[totalSections * NibbleDataLength]; ushort PrimaryBitMap = 0, AddBitMap = 0; // Second pass produces the arrays for (int i = 15; i >= 0; i--) { Section s = chunk.Sections[chunkY++]; if (s.IsAir) { nonAir = false; } if (nonAir) { Array.Copy(s.Blocks, 0, blockData, (chunkY - 1) * BlockDataLength, BlockDataLength); Array.Copy(s.Metadata.Data, 0, metadata, (chunkY - 1) * NibbleDataLength, NibbleDataLength); Array.Copy(s.BlockLight.Data, 0, blockLight, (chunkY - 1) * NibbleDataLength, NibbleDataLength); Array.Copy(s.SkyLight.Data, 0, skyLight, (chunkY - 1) * NibbleDataLength, NibbleDataLength); PrimaryBitMap |= mask; } mask <<= 1; } // Create the final array // TODO: Merge this into the other loop, reduce objects byte[] data = new byte[blockData.Length + metadata.Length + blockLight.Length + skyLight.Length + chunk.Biomes.Length]; int index = 0; Array.Copy(blockData, 0, data, index, blockData.Length); index += blockData.Length; Array.Copy(metadata, 0, data, index, metadata.Length); index += metadata.Length; Array.Copy(blockLight, 0, data, index, blockLight.Length); index += blockLight.Length; Array.Copy(skyLight, 0, data, index, skyLight.Length); index += skyLight.Length; Array.Copy(chunk.Biomes, 0, data, index, chunk.Biomes.Length); // Compress the array var result = ZlibStream.CompressBuffer(data); var GroundUpContiguous = true; return(new ChunkDataPacket(X, Z, GroundUpContiguous, PrimaryBitMap, AddBitMap, result)); }
public static byte[] CompressStream(byte[] unCompressedBytes) { return(ZlibStream.CompressBuffer(unCompressedBytes)); }
public string ToJson() { var obj = new json_dat(); obj.width = Width; obj.height = Height; List <loc> locs = new List <loc>(); MemoryStream ms = new MemoryStream(); using (PacketWriter wtr = new PacketWriter(ms)) for (int y = 0; y < obj.height; y++) { for (int x = 0; x < obj.width; x++) { var loc = new loc(); loc.ground = Tiles[x][y] != -1 ? GetTileId((ushort)Tiles[x][y]) : null; loc.objs = new obj[Entities[x][y].Length]; for (int i = 0; i < loc.objs.Length; i++) { var en = Entities[x][y][i]; obj o = new obj() { id = GetEntityId(en.ObjectType) }; string s = ""; Dictionary <StatsType, object> vals = new Dictionary <StatsType, object>(); foreach (var z in en.Status.Data) { vals.Add(z.Id, z.IsStringData() ? (object)z.StringValue : (object)z.IntValue); } if (vals.ContainsKey(StatsType.Name)) { s += ";name:" + vals[StatsType.Name]; } if (vals.ContainsKey(StatsType.Size)) { s += ";size:" + vals[StatsType.Size]; } if (vals.ContainsKey(StatsType.ObjectConnection)) { s += ";conn:0x" + ((int)vals[StatsType.ObjectConnection]).ToString("X8"); } if (vals.ContainsKey(StatsType.MerchandiseType)) { s += ";mtype:" + vals[StatsType.MerchandiseType]; } if (vals.ContainsKey(StatsType.MerchandiseRemainingCount)) { s += ";mcount:" + vals[StatsType.MerchandiseRemainingCount]; } if (vals.ContainsKey(StatsType.MerchandiseRemainingMinutes)) { s += ";mtime:" + vals[StatsType.MerchandiseRemainingMinutes]; } if (vals.ContainsKey(StatsType.RankRequired)) { s += ";nstar:" + vals[StatsType.RankRequired]; } o.name = s.Trim(';'); loc.objs[i] = o; } int ix = -1; for (int i = 0; i < locs.Count; i++) { if (locs[i].ground != loc.ground) { continue; } if (!((locs[i].objs != null && loc.objs != null) || (locs[i].objs == null && loc.objs == null))) { continue; } if (locs[i].objs != null) { if (locs[i].objs.Length != loc.objs.Length) { continue; } bool b = false; for (int j = 0; j < loc.objs.Length; j++) { if (locs[i].objs[j].id != loc.objs[j].id || locs[i].objs[j].name != loc.objs[j].name) { b = true; break; } } if (b) { continue; } } ix = i; break; } if (ix == -1) { ix = locs.Count; locs.Add(loc); } wtr.Write((short)ix); } } obj.data = ZlibStream.CompressBuffer(ms.ToArray()); obj.dict = locs.ToArray(); var settings = new JsonSerializerSettings(); settings.NullValueHandling = NullValueHandling.Ignore; return(JsonConvert.SerializeObject(obj, settings)); }
public byte[] CompressZlibStream(byte[] bytes, CompressionLevel level = CompressionLevel.Default) { return(ZlibStream.CompressBuffer(bytes)); }
public string ToJson() { var obj = new json_dat(); obj.width = Width; obj.height = Height; var locs = new List <loc>(); var ms = new MemoryStream(); using (var wtr = new NWriter(ms)) for (var y = 0; y < obj.height; y++) { for (var x = 0; x < obj.width; x++) { var loc = new loc(); loc.ground = XmlDatas.TypeToId[(short)Tiles[x][y]]; loc.objs = new obj[Entities[x][y].Length]; for (var i = 0; i < loc.objs.Length; i++) { var en = Entities[x][y][i]; var o = new obj() { id = XmlDatas.TypeToId[(short)en.ObjectType] }; var s = ""; var vals = new Dictionary <StatsType, object>(); foreach (var z in en.Stats.Stats) { vals.Add(z.Key, z.Value); } if (vals.ContainsKey(StatsType.Name)) { s += ";name:" + vals[StatsType.Name]; } if (vals.ContainsKey(StatsType.Size)) { s += ";size:" + vals[StatsType.Size]; } if (vals.ContainsKey(StatsType.ObjectConnection)) { s += ";conn:0x" + ((int)vals[StatsType.ObjectConnection]).ToString("X8"); } if (vals.ContainsKey(StatsType.MerchantMerchandiseType)) { s += ";mtype:" + vals[StatsType.MerchantMerchandiseType]; } if (vals.ContainsKey(StatsType.MerchantRemainingCount)) { s += ";mcount:" + vals[StatsType.MerchantRemainingCount]; } if (vals.ContainsKey(StatsType.MerchantRemainingMinute)) { s += ";mtime:" + vals[StatsType.MerchantRemainingMinute]; } if (vals.ContainsKey(StatsType.NameChangerStar)) { s += ";nstar:" + vals[StatsType.NameChangerStar]; } o.name = s.Trim(';'); loc.objs[i] = o; } var ix = -1; for (var i = 0; i < locs.Count; i++) { if (locs[i].ground != loc.ground) { continue; } if (!((locs[i].objs != null && loc.objs != null) || (locs[i].objs == null && loc.objs == null))) { continue; } if (locs[i].objs != null) { if (locs[i].objs.Length != loc.objs.Length) { continue; } var b = false; for (var j = 0; j < loc.objs.Length; j++) { if (locs[i].objs[j].id != loc.objs[j].id || locs[i].objs[j].name != loc.objs[j].name) { b = true; break; } } if (b) { continue; } } ix = i; break; } if (ix == -1) { ix = locs.Count; locs.Add(loc); } wtr.Write((short)ix); } } obj.data = ZlibStream.CompressBuffer(ms.ToArray()); obj.dict = locs.ToArray(); return(JsonConvert.SerializeObject(obj)); }
public static string ConvertReverse(XmlData data, byte[] wmap) { var obj = new json_dat(); List <TerrainTile> terdict = new List <TerrainTile>(); List <loc> dict = new List <loc>(); List <byte> wmb = new List <byte>(); foreach (var i in wmap) { wmb.Add(i); } wmb.RemoveAt(0); wmap = ZlibStream.UncompressBuffer(wmb.ToArray()); List <byte> dat = new List <byte>(); List <short> newDat = new List <short>(); using (var rdr = new BinaryReader(new MemoryStream(wmap))) { short dicLength = rdr.ReadInt16(); for (short i = 0; i < dicLength; i++) { terdict.Add(new TerrainTile() { TileId = rdr.ReadUInt16(), TileObj = rdr.ReadString(), Name = rdr.ReadString(), Terrain = (TerrainType)rdr.ReadByte(), Region = (TileRegion)rdr.ReadByte() }); } obj.width = rdr.ReadInt32(); obj.height = rdr.ReadInt32(); dat = new List <byte>(rdr.ReadBytes(obj.width * obj.height * 3)); } using (var rdr = new BinaryReader(new MemoryStream(dat.ToArray()))) { for (int i = 0; i < obj.width * obj.height; i++) { newDat.Add(rdr.ReadInt16()); rdr.ReadByte(); //Elevation, don't need } } foreach (var i in terdict) { dict.Add(new loc() { ground = data.Tiles[i.TileId].ObjectId, objs = i.TileObj == null ? null : new obj[] { new obj() { id = i.TileObj, name = i.Name } }, regions = i.Region == TileRegion.None ? null : new obj[] { new obj() { id = i.Region.ToString().Replace('_', ' '), name = "" } } }); } MemoryStream s = new MemoryStream(); using (var wtr = new NWriter(s)) { foreach (var i in newDat) { wtr.Write(i); } } obj.dict = dict.ToArray(); obj.data = ZlibStream.CompressBuffer(s.ToArray()); return(JsonConvert.SerializeObject(obj)); }
public TWADFile(byte[] Content, string FileName) { this.Content = Content; this.FileName = FileName; this.Compressed = ZlibStream.CompressBuffer(this.Content); }
internal override void Encode() { int Count = 6; this.Data.AddBool(false); this.Data.AddVInt(0); this.Data.AddVInt(21); this.Data.AddVInt((int)TimeUtils.ToUnixTimestamp(DateTime.Now)); // Timestamp this.Data.AddVInt(11); this.Data.AddVInt(0); this.Data.AddHexa("F3660944F693DC890701"); // Battle Checksum? if (this.Battle.Player1 == this.Device.Player) { this.Data.AddRange(this.Battle.Player2.Battle.ToBytes); this.Data.AddVInt(34); this.Data.AddVInt(0); this.Data.AddVInt(4); this.Data.AddRange(this.Battle.Player1.Battle.ToBytes); this.Data.AddVInt(0); this.Data.AddVInt(0); this.Data.AddVInt(0); this.Data.AddVInt(14); // Arena Base this.Data.AddVInt(2); this.Data.AddVInt(0); this.Data.AddVInt(21); // Arena but not actually arena? this.Data.AddVInt(this.Battle.Player2.UserHighId); this.Data.AddVInt(this.Battle.Player2.UserLowId); this.Data.AddVInt(0); this.Data.AddVInt(this.Battle.Player1.UserHighId); this.Data.AddVInt(this.Battle.Player1.UserLowId); this.Data.AddVInt(0); } else { this.Data.AddRange(this.Battle.Player1.Battle.ToBytes); this.Data.AddVInt(34); this.Data.AddVInt(0); this.Data.AddVInt(4); this.Data.AddRange(this.Battle.Player2.Battle.ToBytes); this.Data.AddVInt(0); this.Data.AddVInt(0); this.Data.AddVInt(0); this.Data.AddVInt(14); // Arena Base this.Data.AddVInt(2); this.Data.AddVInt(0); this.Data.AddVInt(21); // Arena but not actually arena? this.Data.AddVInt(this.Battle.Player1.UserHighId); this.Data.AddVInt(this.Battle.Player1.UserLowId); this.Data.AddVInt(0); this.Data.AddVInt(this.Battle.Player2.UserHighId); this.Data.AddVInt(this.Battle.Player2.UserLowId); this.Data.AddVInt(0); } this.Data.AddVInt(0); this.Data.AddVInt(0); this.Data.AddVInt(0); this.Data.AddVInt(0); this.Data.AddVInt(0); this.Data.AddVInt(0); this.Data.AddVInt(0); this.Data.AddVInt(0); this.Data.AddVInt(0); this.Data.AddBool(false); //Is Trainer battle this.Data.AddVInt(0); this.Data.AddVInt(0); this.Data.AddVInt(0); this.Data.AddVInt(142); this.Data.AddVInt(62077); this.Data.AddVInt(0); this.Data.AddVInt(0); this.Data.AddVInt(Count); this.Data.AddVInt(Count); this.Data.AddVInt(35); this.Data.AddVInt(1); this.Data.AddVInt(35); this.Data.AddVInt(1); this.Data.AddVInt(35); this.Data.AddVInt(1); this.Data.AddVInt(35); this.Data.AddVInt(1); this.Data.AddVInt(35); this.Data.AddVInt(0); this.Data.AddVInt(35); this.Data.AddVInt(0); this.Data.AddVInt(1); this.Data.AddVInt(0); this.Data.AddVInt(1); this.Data.AddVInt(0); this.Data.AddVInt(0); this.Data.AddVInt(1); for (int Index = 0; Index < Count; Index++) { this.Data.AddVInt(5); this.Data.AddVInt(Index); } this.Data.AddVInt(12); //Level Tower R this.Data.AddVInt(13); //Prefixed this.Data.AddVInt(14500); //Tower R Z this.Data.AddVInt(25500); //Tower R Y this.Data.AddRange("0000C07C00".HexaToBytes()); this.Data.AddRange("A40100000000020000000000000000".HexaToBytes()); this.Data.AddVInt(12); //Level Tower R Enemy this.Data.AddVInt(13); //Prefixed this.Data.AddVInt(3500); //Tower R Enemy X this.Data.AddVInt(6500); //Tower R Enemy Y this.Data.AddRange("0000800400".HexaToBytes()); this.Data.AddRange("A40100000000010000000000000000".HexaToBytes()); this.Data.AddVInt(12); //Level Tower L this.Data.AddVInt(13); //Prefixed this.Data.AddVInt(3500); //Tower L X this.Data.AddVInt(25500); //Tower L Y this.Data.AddRange("0000C07C00".HexaToBytes()); this.Data.AddRange("A40100000000010000000000000000".HexaToBytes()); this.Data.AddVInt(12); //Level Tower L Enemy this.Data.AddVInt(13); //Prefixed this.Data.AddVInt(14500); //Tower L Enemy X this.Data.AddVInt(6500); //Tower L Enemy Y this.Data.AddRange("0000800400".HexaToBytes()); this.Data.AddRange("A40100000000020000000000000000".HexaToBytes()); this.Data.AddVInt(12); //Enemy Crown Tower Level this.Data.AddVInt(13); //Prefixed this.Data.AddVInt(9000); //Crown Tower Enemy X this.Data.AddVInt(3000); //Tower Tower Enemy Y this.Data.AddRange("0000800400".HexaToBytes()); this.Data.AddRange("A40100000000000000000000000000000504".HexaToBytes()); this.Data.AddRange("05027D020401030200007F7F0000000500000000007F7F7F7F7F7F7F7F".HexaToBytes()); this.Data.AddVInt(12); //Crown Tower Level this.Data.AddVInt(13); //Prefixed this.Data.AddVInt(9000); //Crown Tower X this.Data.AddVInt(29000); //Crown Tower Tower Y this.Data.AddRange("0000C07C00".HexaToBytes()); this.Data.AddRange("A40100000000000000000000000000000504".HexaToBytes()); this.Data.AddRange("067B067E0403000204".HexaToBytes()); this.Data.AddRange("007F7F000000".HexaToBytes()); this.Data.AddVInt(5); //elixir bar start ? this.Data.AddRange("00000000007F7F7F7F7F7F7F7F".HexaToBytes()); this.Data.AddRange("000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000".HexaToBytes()); this.Data.AddVInt(3668); // Player R this.Data.AddVInt(3668); // Enemy R this.Data.AddVInt(3668); // Player L this.Data.AddVInt(3668); // Enemy L this.Data.AddVInt(5832); // Enemy Crown this.Data.AddVInt(5832); // Player Crown for (int Index = 0; Index < Count; Index++) { this.Data.AddRange("00000000000000A401A401".HexaToBytes()); } this.Data.AddHexa("FE03"); if (this.Battle.Player1 == this.Device.Player) { this.Data.AddRange(this.Battle.Player1.Decks.Hand()); } else { this.Data.AddRange(this.Battle.Player2.Decks.Hand()); } this.Data.AddVInt(0); this.Data.AddVInt(0); this.Data.AddRange("05060202040201".HexaToBytes()); this.Data.AddVInt(TimeSpan.FromSeconds(Battle.Time.GetRemainingSeconds(DateTime.Now)).Minutes); this.Data.AddVInt(TimeSpan.FromSeconds(Battle.Time.GetRemainingSeconds(DateTime.Now)).Seconds); this.Data.AddVInt(0); this.Data.AddVInt(0); this.Data.AddVInt(0); this.Data.AddVInt(0); this.Data.AddVInt(0); this.Data.AddVInt(0); this.Data.AddVInt(6); this.Data.AddVInt(9); this.Data.AddVInt(1); this.Data.AddVInt(1); this.Data.AddHexa("0000000000000000000000010000000000000000000000000C000000"); this.Data.AddHexa("80A1B0A80F"); this.Data.AddHexa("002A"); this.Data.AddHexa("002B"); ZlibStream.CompressBuffer(this.Data.ToArray()); }
private static byte[] zlibCompress(byte[] bytes) { return(ZlibStream.CompressBuffer(bytes)); }
public static string Encode(string text) { return(Convert.ToBase64String(ZlibStream.CompressBuffer(Encoding.UTF8.GetBytes(text)))); }
internal static byte[] Array() { var part1 = Sodium.Utilities.HexToBinary("01 71 05 00 00".Replace(" ", "")); var decryptedpart2 = new List <byte>(); decryptedpart2.AddHexa( "2A 02 7F 7F 7F 7F 00 00 00 00 00 00 01 80 32 00 00 00 00 00 00 00 00 00 00 00 00 00 08 00 00 00 00 00 00 00 00 0A 00 00 00 00 00 00 00 00 00 00 00 01 02 00 9F BD 19 00 9F BD 19 00 9F BD 19" .Replace(" ", "")); decryptedpart2.AddString(Constants.OwnHomeData.StartingPlayerName); decryptedpart2.AddHexa( "08 B5 31 86 06 95 2A 00 00 00 00 00 24 00 00 00 00 00 08 0E 05 01 BF AC 01 05 02 9D 0E 05 03 01 05 04 00 05 0C 8C 14 05 0D 00 05 0E 01 05 0F 98 11 05 16 B2 11 05 19 B4 D3 9F CA 0A 05 1A 0D 05 1C 00 05 1D 86 88 D5 44 05 25 00 00 00 00 05 05 06 95 35 05 07 80 0E 05 0B 24 05 14 0B 05 1B 0A 8D 01 1A 00 00 1A 01 00 1A 02 01 1A 03 00 1A 04 00 1A 05 01 1A 06 00 1A 07 00 1A 08 00 1A 09 00 1A 0A 00 1A 0B 00 1A 0C 00 1A 0D 00 1A 0E 00 1A 0F 00 1A 10 00 1A 11 00 1A 12 00 1A 13 00 1A 14 00 1A 15 00 1A 16 00 1A 17 00 1A 18 00 1A 19 00 1A 1A 00 1A 1B 00 1A 1C 00 1A 1D 00 1A 1E 00 1A 1F 00 1A 20 00 1A 21 00 1A 22 00 1A 23 00 1A 24 00 1A 25 37 1A 26 00 1A 27 00 1A 28 00 1A 29 00 1A 2A 00 1A 2B 00 1A 2D 00 1A 2E 01 1A 30 15 1A 31 00 1A 36 00 1A 37 10 1B 00 00 1B 01 00 1B 02 00 1B 03 00 1B 04 00 1B 05 00 1B 06 00 1B 07 00 1B 08 00 1B 09 00 1B 0A 00 1C 00 01 1C 01 00 1C 02 00 1C 03 00 1C 04 00 1C 05 00 1C 06 00 1C 07 00 1C 08 01 1C 09 00 1C 0A 00 1C 0B 00 1C 0C 00 1C 0D 00 1C 10 00 1A 39 00 00 00 0B 02 11 A1 B7 2E" .Replace(" ", "")); decryptedpart2.AddString(Constants.OwnHomeData.StartingClanName); decryptedpart2.AddHexa( "18 AD 48 92 08 00 B3 20 AD 1F 01 9F 03 17 00 00 00 00 2B 00 21 7F 0B 00 8D DE 59 6C 87 BB BE B7 03 02 02 26 01 7F 7F 00 00 9F BD 19 00 00 00 00 00 00 00 00 00 06" .Replace(" ", "")); decryptedpart2.Add(true); decryptedpart2.AddHexa("00 00 09 00 00 00 01 00 00 00 8E 02 F2 7D 00 00 06 7A 06 23 01 23 01 23 01 23 01 23 00 23 00 01 00 01 00 00 01 05 00 05 01 05 02 05 03 05 04 05 05 0A 0D A4 E2 01 9C 8E 03 00 00 7F 00 C0 7C 00 00 02 00 00 00 00 00 09 0D AC 36 A4 65 00 00 7F 00 80 04 00 00 01 00 00 00 00 00 0A 0D AC 36 9C 8E 03 00 00 7F 00 C0 7C 00 00 01 00 00 00 00 00 09 0D A4 E2 01 A4 65 00 00 7F 00 80 04 00 00 02 00 00 00 00 00 09 0D A8 8C 01 B8 2E 00 00 7F 00 80 04 00 00 00 00 00 00 00 00 0D 04 04 02 01 79 04 05 01 03 02 00 7F 7F 00 00 00 00 05 00 00 00 00 00 7F 7F 7F 7F 7F 7F 7F 7F 00 00 00 00".Replace(" ", "")); decryptedpart2.Add(12); //Crown tower level decryptedpart2.AddHexa( "0D A8 8C 01 88 C5 03 00 00 7F 00 C0 7C 00 00 00 00 00 00 00 00 0D 04 04 7F 7D 07 04 05 01 06 02 00 7F 7F 00 03 04" .Replace(" ", "")); decryptedpart2.AddString("Cast_Quest_HighCost"); decryptedpart2.AddString("TID_CAST_QUEST_MIN_ELIXIR"); decryptedpart2.AddString("TID_CAST_QUEST_MIN_ELIXIR_INFO"); decryptedpart2.AddString("sc/ui.sc"); decryptedpart2.AddString("quest_item_pvp"); decryptedpart2.AddHexa( "14 1E 00 00 00 00 00 00 00 00 01 0E 00 2E 00 00 00 06 00 01 01 00 02".Replace(" ", "")); decryptedpart2.AddString("Play_Quest_Win_2v2Ladder_PvP"); decryptedpart2.AddString("TID_LADDER_QUEST_2V2_WIN"); decryptedpart2.AddString("TID_LADDER_QUEST_WIN_2V2_INFO"); decryptedpart2.AddString("sc/ui.sc"); decryptedpart2.AddString("quest_item_pvp"); decryptedpart2.AddHexa( "14 05 02 00 00 00 00 00 00 00 01 05 00 0A 01 00 01 02 00 02 00 00 00 00".Replace(" ", "")); decryptedpart2.AddString(""); decryptedpart2.AddString(""); decryptedpart2.AddString("sc/ui.sc"); decryptedpart2.AddString("quest_item_special_pvp"); decryptedpart2.AddHexa("14 28 B4 12 0A 0A 01".Replace(" ", "")); decryptedpart2.AddString("icon_quest_type_specialevent"); //ELIXIR .. decryptedpart2.AddHexa("01 0E 02 04 02 00 00 00 02 B1 12 B3 12 00 00".Replace(" ", "")); decryptedpart2.Add(8); //elixir NOT MORE THAT 63 decryptedpart2.AddHexa( "00 00 00 00 00 7F 7F 7F 7F 7F 7F 7F 7F 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 AC 2F 00 A2 2B 00 AC 2F 00 A2 2B 00 A8 44 00 98 4B 00 00 00 00 00 00 00 00 A4 01 A4 01 00 00 00 00 00 00 00 00 A4 01 A4 01 00 00 00 00 00 00 00 00 A4 01 A4 01 00 00 00 00 00 00 00 00 A4 01 A4 01 00 00 00 00 00 00 00 00 A4 01 A4 01 00 00 00 00 00 00 00 00 A4 01 A4 01 00 FF 01 11 04 01 09 05 04 03 09 1B 01 13 07 8F 01 09 1C 04 00 FE 03" .Replace(" ", "")); // decryptedpart2.AddHexa("2F 00 38 04 03 09 16 07 02 0A 0C 07 96 01 09 8E 01 06 00 00 05 06 02 02 04 02 01".Replace(" ","")); foreach (var cardid in Constants.OwnHomeData.Deck) { decryptedpart2.AddVInt(cardid); decryptedpart2.AddVInt(4); } decryptedpart2.AddHexa("00 00 05 06 02 02 04 02 01".Replace(" ", "")); decryptedpart2.Add(3); //2 for weird things (on troops), 3 for normal decryptedpart2.AddHexa("00 00 00 00 00 00 00 00 0C 00 00 00 90 EE FC F9 0F 00".Replace(" ", "")); return(part1.Concat(ZlibStream.CompressBuffer(decryptedpart2.ToArray())).ToArray()); }
/// <summary> /// Writes the given record to the PQDIF file. /// </summary> /// <param name="record">The record to be written to the file.</param> /// <param name="lastRecord">Indicates whether this record is the last record in the file.</param> /// <exception cref="InvalidDataException">The PQDIF data is invalid.</exception> /// <exception cref="ObjectDisposedException">The writer was disposed.</exception> public void WriteRecord(Record record, bool lastRecord = false) { byte[] bodyImage; uint checksum; if (m_disposed) { throw new ObjectDisposedException(GetType().Name); } using (MemoryStream bodyStream = new MemoryStream()) using (BinaryWriter bodyWriter = new BinaryWriter(bodyStream)) { // Write the record body to the memory stream if (record.Body != null) { WriteCollection(bodyWriter, record.Body.Collection); } // Read and compress the body to a byte array bodyImage = bodyStream.ToArray(); if (m_compressionAlgorithm == CompressionAlgorithm.Zlib && m_compressionStyle == CompressionStyle.RecordLevel) { bodyImage = ZlibStream.CompressBuffer(bodyImage); } // Create the checksum after compression uint adler = Adler.Adler32(0u, null, 0, 0); checksum = Adler.Adler32(adler, bodyImage, 0, bodyImage.Length); // Write the record body to the memory stream if (record.Body != null) { record.Body.Checksum = checksum; } } // Fix the pointer to the next // record before writing this record if (m_stream.CanSeek && m_stream.Length > 0) { m_writer.Write((int)m_stream.Length); m_stream.Seek(0L, SeekOrigin.End); } // Make sure the header points to the correct location based on the size of the body record.Header.HeaderSize = 64; record.Header.BodySize = bodyImage.Length; record.Header.NextRecordPosition = (int)m_stream.Length + record.Header.HeaderSize + record.Header.BodySize; record.Header.Checksum = checksum; // Write up to the next record position m_writer.Write(record.Header.RecordSignature.ToByteArray()); m_writer.Write(record.Header.RecordTypeTag.ToByteArray()); m_writer.Write(record.Header.HeaderSize); m_writer.Write(record.Header.BodySize); // The PQDIF standard defines the NextRecordPosition to be 0 for the last record in the file // We treat seekable streams differently because we can go back and fix the pointers later if (m_stream.CanSeek || lastRecord) { m_writer.Write(0); } else { m_writer.Write(record.Header.NextRecordPosition); } // Write the rest of the header as well as the body m_writer.Write(record.Header.Checksum); m_writer.Write(record.Header.Reserved); m_writer.Write(bodyImage); // If the stream is seekable, seek to the next record // position so we can fix the pointer if we end up // writing another record to the file if (m_stream.CanSeek) { m_stream.Seek(-(24 + record.Header.BodySize), SeekOrigin.Current); } // Dispose of the writer if this is the last record if (!m_stream.CanSeek && lastRecord) { Dispose(); } }
public static byte[] Deflate(byte[] buffer) { return(ZlibStream.CompressBuffer(buffer)); }
public static void WriteGEX(ProjectWriter writer, string filePath) { using (FileStream fs = new FileStream(filePath, FileMode.Open, FileAccess.Read, FileShare.Read)) using (ProjectReader pr = new ProjectReader(fs)) { GEX gex = new GEX(); gex.Load(pr); writer.Write(gex.Package.Version); writer.Write(gex.Package.Name); writer.Write(gex.Package.Folder); writer.Write(gex.Package.Files.Count); foreach (var file in gex.Package.Files) { writer.Write(file.Version); writer.Write(file.FileName); writer.Write((int)file.Kind); writer.Write(file.Initialization); writer.Write(file.Finalization); writer.Write(file.Functions.Count); int id = 0; foreach (var func in file.Functions) { writer.Write(func.Version); writer.Write(func.Name); writer.Write(func.ExternalName); writer.Write((int)func.Convention); writer.Write(id); // ????? writer.Write(func.Argc); for (int i = 0; i < 17; i++) { writer.Write((int)func.ArgTypes[i]); } writer.Write((int)func.Return); id++; } } writer.Write(gex.Seed); // Prepare DAT files... MemoryStream ms = new MemoryStream(); for (int i = 0; i < gex.Package.Files.Count; i++) { if (gex.Package.Files[i].Kind == GEDFile.GEDFileKind.ActionLib) { continue; } byte[] zlibbed = ZlibStream.CompressBuffer(gex.RawDATs[i]); byte[] size = BitConverter.GetBytes(zlibbed.Length); ms.Write(size); ms.Write(zlibbed); } byte[] includes = ms.ToArray(); writer.Write(includes.Length); // GMKrypt the data. for (int i = 1; i < includes.Length; i++) { includes[i] = gex.GMKrypt[0][includes[i]]; } writer.Write(includes); } }
public static byte[] Compress(byte[] data) { return(ZlibStream.CompressBuffer(data)); }
///<summary>Generates a full .mca file stream for use in Minecraft.</summary> public static void WriteRegionToStream(Region region, FileStream stream, Version version, bool writeProgressBar = false) { DateTime time = System.DateTime.Now; int[] locations = new int[1024]; byte[] sizes = new byte[1024]; for (int i = 0; i < 8192; i++) { stream.WriteByte(0); } for (int z = 0; z < 32; z++) { for (int x = 0; x < 32; x++) { int i = z * 32 + x; var chunk = region.chunks[x, z]; if (chunk != null) { locations[i] = (int)(stream.Position / 4096); var chunkData = ChunkSerializer.CreateCompoundForChunk(chunk, version); List <byte> bytes = new List <byte>(); chunkData.WriteToBytes(bytes, true); byte[] compressed = ZlibStream.CompressBuffer(bytes.ToArray()); var cLength = Converter.ReverseEndianness(BitConverter.GetBytes(compressed.Length)); stream.Write(cLength, 0, cLength.Length); stream.WriteByte(2); stream.Write(compressed, 0, compressed.Length); var padding = stream.Length % 4096; //Pad the data to the next 4096 byte mark if (padding > 0) { byte[] paddingBytes = new byte[4096 - padding]; stream.Write(paddingBytes, 0, paddingBytes.Length); } sizes[i] = (byte)((int)(stream.Position / 4096) - locations[i]); if (sizes[i] == 0) { throw new InvalidOperationException("0 byte sized chunk detected."); } } else { locations[i] = 0; sizes[i] = 0; } } if (writeProgressBar) { MCUtilsConsole.WriteProgress(string.Format("Writing chunks to stream [{0}/{1}]", z * 32, 1024), (z * 32f) / 1024f); } } stream.Position = 0; for (int i = 0; i < 1024; i++) { byte[] offsetBytes = Converter.ReverseEndianness(BitConverter.GetBytes(locations[i])); stream.WriteByte(offsetBytes[1]); stream.WriteByte(offsetBytes[2]); stream.WriteByte(offsetBytes[3]); stream.WriteByte(sizes[i]); } DateTime time2 = System.DateTime.Now; TimeSpan len = time2.Subtract(time); MCUtilsConsole.WriteLine("Generating MCA took " + Math.Round(len.TotalSeconds * 100f) / 100f + "s"); }