public static MemoryStream DecompressToMemoryStream(byte[] compressedBytes, ECompressionType compressType, int decompressedSize = -1)
{
MemoryStream decompressedStream;
switch (compressType)
{
case ECompressionType.LzMa: //LZMA
{
decompressedStream = new MemoryStream();
SevenZipHelper.DecompressData(compressedBytes, decompressedStream, decompressedSize);
break;
}
case ECompressionType.Lz4: //LZ4
case ECompressionType.Lz4Hc: //LZ4HC
{
var decompressedBytes = new byte[decompressedSize];
LZ4Codec.Decode(compressedBytes, 0, compressedBytes.Length,
decompressedBytes, 0, decompressedSize);
decompressedStream = new MemoryStream(decompressedBytes);
break;
}
//case CompressionType.LzHam: //LZHAM
case ECompressionType.None: //None
default:
{
decompressedStream = new MemoryStream(compressedBytes);
break;
}
}
return(decompressedStream);
}
public static byte[] Compress(byte[] data, ECompressionType compressType) //, int start = 0, int count = 0)
{
byte[] compressedData;
switch (compressType)
{
case ECompressionType.LzMa:
compressedData = SevenZipHelper.CompressData(data);
break;
case ECompressionType.Lz4: //LZ4
case ECompressionType.Lz4Hc: //LZ4HC
compressedData = new byte[LZ4Codec.MaximumOutputSize(data.Length)];
var compressedSize = LZ4Codec.Encode(data, 0, data.Length,
compressedData, 0, compressedData.Length);
Array.Resize(ref compressedData, compressedSize);
break;
//case CompressionType.LzHam: //LZHAM
case ECompressionType.None: //None
default:
{
compressedData = data;
break;
}
}
return(compressedData);
}
public void ZipOutputStreamEncryptEmptyEntries(
[Values] UseZip64 useZip64,
[Values(0, 128, 256)] int keySize,
[Values(CompressionMethod.Stored, CompressionMethod.Deflated)] CompressionMethod compressionMethod)
{
using (var ms = new MemoryStream())
{
using (var zipOutputStream = new ZipOutputStream(ms))
{
zipOutputStream.IsStreamOwner = false;
zipOutputStream.Password = "******";
zipOutputStream.UseZip64 = useZip64;
ZipEntry zipEntry = new ZipEntry("emptyEntry")
{
AESKeySize = keySize,
CompressionMethod = compressionMethod,
CompressedSize = 0,
Crc = 0,
Size = 0,
};
zipOutputStream.PutNextEntry(zipEntry);
zipOutputStream.CloseEntry();
}
SevenZipHelper.VerifyZipWith7Zip(ms, "password");
}
}
public MemoryStream DecompressEntry(int Index)
{
MemoryStream result = new MemoryStream();
FileEntryStruct e = Files[Index];
uint count = 0;
byte[] inputBlock;
byte[] outputBlock = new byte[Header.MaxBlockSize];
long left = e.RealUncompressedSize;
FileStream fs = new FileStream(MyFileName, FileMode.Open, FileAccess.Read);
fs.Seek(e.BlockOffsets[0], SeekOrigin.Begin);
byte[] buff;
if (e.BlockSizeIndex == 0xFFFFFFFF)
{
buff = new byte[e.RealUncompressedSize];
fs.Read(buff, 0, buff.Length);
result.Write(buff, 0, buff.Length);
}
else
{
while (left > 0)
{
uint compressedBlockSize = (uint)e.BlockSizes[count];
if (compressedBlockSize == 0)
{
compressedBlockSize = Header.MaxBlockSize;
}
if (compressedBlockSize == Header.MaxBlockSize || compressedBlockSize == left)
{
buff = new byte[compressedBlockSize];
fs.Read(buff, 0, buff.Length);
result.Write(buff, 0, buff.Length);
left -= compressedBlockSize;
}
else
{
var uncompressedBlockSize = (uint)Math.Min(left, Header.MaxBlockSize);
if (compressedBlockSize < 5)
{
throw new Exception("compressed block size smaller than 5");
}
inputBlock = new byte[compressedBlockSize];
fs.Read(inputBlock, 0, (int)compressedBlockSize);
uint actualUncompressedBlockSize = uncompressedBlockSize;
uint actualCompressedBlockSize = compressedBlockSize;
outputBlock = SevenZipHelper.Decompress(inputBlock, (int)actualUncompressedBlockSize);
if (outputBlock.Length != actualUncompressedBlockSize)
{
throw new Exception("Decompression Error");
}
result.Write(outputBlock, 0, (int)actualUncompressedBlockSize);
left -= uncompressedBlockSize;
}
count++;
}
}
fs.Close();
return(result);
}
/// <summary>
/// Extracts a zipped template, and merges better info from another vstemplate file, then rezips the file
/// C:\Users\dkhen\Documents\Visual Studio 2010\My Exported Templates
/// </summary>
/// <param name="zipFile"></param>
void FixTemplate(string zipFile, bool isItemTemplate)
{
var vsTemplateFilename = "MyTemplate.vstemplate";
var dir = SevenZipHelper.ExtractToDir(zipFile);
vsTemplateFilename = Path.Combine(dir, vsTemplateFilename);
var doc1 = XDocument.Load(vsTemplateFilename);
var doc2 = XDocument.Load(@"C:\Projects\SharpKit\trunk\src\SharpKit.Release\VSTemplates10\" + Path.GetFileNameWithoutExtension(zipFile) + ".vstemplate");
XNamespace xn = "http://schemas.microsoft.com/developer/vstemplate/2005";
var el1 = doc1.Root.Element(xn + "TemplateData");
var el2 = doc2.Root.Element(xn + "TemplateData");
foreach (var ch2 in el2.Elements())
{
var ch1 = el1.Element(ch2.Name);
ch1.Value = ch2.Value;
}
doc1.Save(vsTemplateFilename);
FileHelper.DeleteFileIfExists(zipFile + ".bak");
File.Move(zipFile, zipFile + ".bak");
SevenZipHelper.ZipDirectory(dir, zipFile);
Directory.Delete(dir, true);
var newZipFile = el1.Element(xn + "Name").Value + ".zip";
var zipDir = @"C:\Projects\SharpKit\trunk\src\SharpKit.Release\VSTemplates10\ProjectTemplates\";
if (isItemTemplate)
{
zipDir = zipDir.Replace("ProjectTemplates", "ItemTemplates");
}
newZipFile = Path.Combine(zipDir, newZipFile);
File.Copy(zipFile, newZipFile, true);
}
public void EditorTest()
{
//Arrange
var gameObject = new GameObject();
short rating = 1234;
string ratingString = rating.ToString();
byte[] stringBytes = Encoding.UTF8.GetBytes(ratingString);
byte[] shortBytes = BitConverter.GetBytes(rating);
byte[] compressedShort = SevenZipHelper.Compress(shortBytes);
byte[] compressedString = SevenZipHelper.Compress(stringBytes);
Debug.Log(stringBytes.Length);
Debug.Log(shortBytes.Length);
Debug.Log("compressed short " + compressedShort.Length);
Debug.Log("compressed string " + compressedString.Length);
Debug.Log(ratingString);
//Act
//Try to rename the GameObject
var newGameObjectName = "My game object";
gameObject.name = newGameObjectName;
//Assert
//The object has a new name
Assert.AreEqual(newGameObjectName, gameObject.name);
}
public static void SaveFile(string filePath, ReplayFile replay)
{
using (ReplayWriter beatmapWriter = new ReplayWriter(File.Open(filePath, FileMode.Create)))
{
beatmapWriter.Write(replay.Mode);
beatmapWriter.Write(replay.Version);
beatmapWriter.Write(replay.BeatmapHash);
beatmapWriter.Write(replay.PlayerName);
beatmapWriter.Write(replay.ReplayHash);
beatmapWriter.Write(replay.Count300);
beatmapWriter.Write(replay.Count100);
beatmapWriter.Write(replay.Count50);
beatmapWriter.Write(replay.CountGeki);
beatmapWriter.Write(replay.CountKatu);
beatmapWriter.Write(replay.CountMiss);
beatmapWriter.Write(replay.Score);
beatmapWriter.Write(replay.MaxCombo);
beatmapWriter.Write(replay.FullCombo);
beatmapWriter.Write(replay.UsedMods);
beatmapWriter.Write(replay.PerformanceGraphData);
beatmapWriter.Write(replay.ReplayDate);
string[] list = Encoding.ASCII.GetString(SevenZipHelper.Decompress(replay.Replay)).Split(',');
beatmapWriter.Write(replay.Replay);
beatmapWriter.Write(replay.Long0);
}
}
/// <summary>
/// 立即安装
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private void materialTextButton1_Click(object sender, EventArgs e)
{
if (this.extractProgress.Value > 0 && this.extractProgress.Value < 100)
{
MessageBox.Show("正在安装中。。。");
return;
}
this.extractProgress.Visible = true;// 显示进度条
string sPath = Path.Combine(Environment.CurrentDirectory, InstallerConfig.Config.Install7ZFile);
string tPath = m_curInstallExePath;
if (!Directory.Exists(tPath))
{
Directory.CreateDirectory(tPath);
}
if (Directory.GetFiles(tPath).Length > 0) // 如果目标目录存文件， 先删除
{
try
{
FileOperationHelper.RemoveFullFolder(tPath);
}catch (Exception ex)
{
MessageBox.Show(ex.Message);
}
}
var thread = new Thread(() => SevenZipHelper.Extract(sPath, tPath))
{
Name = "InstallThread",
IsBackground = true
};
thread.Start();
}
/// <summary>
/// 快速安装
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private void materialTextButton3_Click(object sender, EventArgs e)
{
if (this.extractProgress.Value > 0 && this.extractProgress.Value < 100)
{
MessageBox.Show("正在安装中。。。");
return;
}
this.customInstallPanel.Visible = false; // 隐藏界面
this.extractProgress.Visible = true; // 显示进度条
string sPath = Path.Combine(Environment.CurrentDirectory, InstallerConfig.Config.Install7ZFile);
string tPath = m_curInstallExePath;
if (!Directory.Exists(tPath))
{
Directory.CreateDirectory(tPath);
}
var thread = new Thread(() => SevenZipHelper.Extract(sPath, tPath))
{
Name = "InstallThread",
IsBackground = true
};
thread.Start();
}
private void ReadPre530Metadata(EndianReader reader)
{
switch (Header.Type)
{
case BundleType.UnityRaw:
{
Metadata = new BundleMetadata(m_filePath);
Metadata.ReadPre530(reader);
}
break;
case BundleType.UnityWeb:
case BundleType.HexFA:
{
// read only last chunk. wtf?
ChunkInfo chunkInfo = Header.ChunkInfos[Header.ChunkInfos.Count - 1];
using (SmartStream stream = SmartStream.CreateMemory(new byte[chunkInfo.DecompressedSize]))
{
SevenZipHelper.DecompressLZMASizeStream(reader.BaseStream, chunkInfo.CompressedSize, stream);
Metadata = new BundleMetadata(m_filePath);
using (EndianReader decompressReader = new EndianReader(stream, EndianType.BigEndian))
{
Metadata.ReadPre530(decompressReader);
}
}
}
break;
default:
throw new NotSupportedException($"Bundle type {Header.Type} isn't supported before 530 generation");
}
}
private void ReadBlocks(EndianBinaryReader varReader, Stream varBlocksStream)
{
foreach (var blockInfo in BlocksInfo)
{
switch (blockInfo.GetCompressionType())
{
default: //None
{
varReader.BaseStream.CopyTo(varBlocksStream, blockInfo.compressedSize);
break;
}
case Compression.CompressionType.kCompressionLzma: //LZMA
{
SevenZipHelper.StreamDecompress(varReader.BaseStream, varBlocksStream, blockInfo.compressedSize, blockInfo.uncompressedSize);
break;
}
case Compression.CompressionType.kCompressionLz4: //LZ4
case Compression.CompressionType.kCompressionLz4HC: //LZ4HC
{
var compressedStream = new MemoryStream(varReader.ReadBytes((int)blockInfo.compressedSize));
using (var lz4Stream = new Lz4DecoderStream(compressedStream))
{
lz4Stream.CopyTo(varBlocksStream, blockInfo.uncompressedSize);
}
break;
}
}
}
varBlocksStream.Position = 0;
}
private SmartStream ReadPre530Metadata(BundleFileReader reader)
{
switch (Header.Type)
{
case BundleType.UnityRaw:
{
Metadata.Read(reader);
return(m_stream.CreateReference());
}
case BundleType.UnityWeb:
{
// read only last chunk. wtf?
ChunkInfo chunkInfo = Header.ChunkInfos[Header.ChunkInfos.Count - 1];
using (SmartStream stream = SmartStream.CreateMemory(new byte[chunkInfo.DecompressedSize]))
{
SevenZipHelper.DecompressLZMASizeStream(reader.BaseStream, chunkInfo.CompressedSize, stream);
using (BundleFileReader decompressReader = new BundleFileReader(stream, reader.EndianType, reader.Generation))
{
Metadata.Read(decompressReader);
}
return(stream.CreateReference());
}
}
default:
throw new NotSupportedException($"Bundle type {Header.Type} isn't supported before 530 generation");
}
}
private void ReadReplay(bool replayDecompress)
{
CompressedReplayData = ReadByteArray();
if (replayDecompress)
{
ReplayFrames = new List <ReplayFrame>();
DecompressedReplayData = SevenZipHelper.Decompress(CompressedReplayData);
string replayData = Encoding.ASCII.GetString(DecompressedReplayData);
if (replayData.Length > 0)
{
string[] replayLines = replayData.Split(',');
ReplayFrame lastFrame;
if (ReplayFrames.Count > 0)
{
lastFrame = ReplayFrames[ReplayFrames.Count - 1];
}
else
{
lastFrame = new ReplayFrame(0, 0, 0);
}
foreach (string replayLine in replayLines)
{
if (replayLine.Length == 0)
{
continue;
}
string[] data = replayLine.Split('|');
if (data.Length < 4)
{
continue;
}
if (data[0] == "-12345")
{
Seed = int.Parse(data[3]);
continue;
}
ReplayFrame nextFrame = new ReplayFrame(
int.Parse(data[0]) + lastFrame.Time,
float.Parse(data[1], _nfi),
float.Parse(data[2], _nfi)
);
ReplayFrames.Add(nextFrame);
lastFrame = nextFrame;
}
}
}
if (Version >= 20140721)
{
OnlineId = _reader.ReadInt64();
}
}
public static void ExportReplay(Score score)
{
if (!Directory.Exists("Replays"))
{
Directory.CreateDirectory("Replays");
}
if (score.rawReplayCompressed == null)
{
score.rawReplayCompressed = SevenZipHelper.Compress(new ASCIIEncoding().GetBytes(score.replayFormatted));
}
string filename =
string.Format("{0} - {1} ({2:yyyyMMddhhmmss}).osr", score.playerName,
BeatmapManager.Current.DisplayTitle,
score.date.ToUniversalTime());
filename = "Replays\\" + GeneralHelper.WindowsFilenameStrip(filename);
Stream stream = File.Open(filename, FileMode.Create);
BinaryFormatter bformatter = new BinaryFormatter();
bformatter.Serialize(stream, score);
stream.Close();
GameBase.ShowMessage("Saved replay to " + filename, Color.BlueViolet, 6000);
}
public bool Read(AssetsFileReader reader)
{
header = new ClassDatabaseFileHeader();
header.Read(reader);
if (header.header != "cldb" || header.fileVersion > 4 || header.fileVersion < 1)
{
valid = false;
return(valid);
}
classes = new List <ClassDatabaseType>();
long classTablePos = reader.Position;
AssetsFileReader newReader = reader;
if (header.compressionType != 0)
{
classTablePos = 0;
MemoryStream ms;
if (header.compressionType == 1) //lz4
{
byte[] uncompressedBytes = new byte[header.uncompressedSize];
using (MemoryStream tempMs = new MemoryStream(reader.ReadBytes((int)header.compressedSize)))
{
Lz4DecoderStream decoder = new Lz4DecoderStream(tempMs);
decoder.Read(uncompressedBytes, 0, (int)header.uncompressedSize);
decoder.Dispose();
}
ms = new MemoryStream(uncompressedBytes);
}
else if (header.compressionType == 2) //lzma
{
using (MemoryStream tempMs = new MemoryStream(reader.ReadBytes((int)header.compressedSize)))
{
ms = SevenZipHelper.StreamDecompress(tempMs);
}
}
else
{
valid = false;
return(valid);
}
newReader = new AssetsFileReader(ms);
newReader.bigEndian = false;
}
newReader.Position = header.stringTablePos;
stringTable = newReader.ReadBytes((int)header.stringTableLen);
newReader.Position = classTablePos;
uint size = newReader.ReadUInt32();
for (int i = 0; i < size; i++)
{
ClassDatabaseType cdt = new ClassDatabaseType();
cdt.Read(newReader, header.fileVersion, header.flags);
classes.Add(cdt);
}
valid = true;
return(valid);
}
public void ExtractTest()
{
string sPath = "C:/Users/zhanghui03/source/repos/DirectorEditor/TestResources/testzip.7z";
string tPath = "C:/Users/zhanghui03/source/repos/DirectorEditor/TestResources/xixi";
SevenZipHelper.Extract(sPath, tPath);
}
internal void ReadReplayData()
{
if (rawReplayCompressed == null)
{
return;
}
if (replay == null)
{
replay = new List <bReplayFrame>();
}
else
{
replay.Clear();
}
try
{
ReadReplayData(new ASCIIEncoding().GetString(SevenZipHelper.Decompress(rawReplayCompressed)));
}
catch (Exception)
{
replay.Clear();
}
#if DEBUG
StreamWriter w = File.CreateText("replay.txt");
foreach (bReplayFrame f in replay)
{
w.WriteLine("{0} {1} {2} {3} {4} {5} {6}", f.time, f.mouseX, f.mouseY, f.mouseLeft1, f.mouseLeft2, f.mouseRight1, f.mouseRight2);
}
w.Close();
#endif
}
private static void WriteToFileQueue(object source, ElapsedEventArgs e, bool shuttingDown = false)
{
if (!shuttingDown)
{
ChangeFileName();
}
ChangeFileNameWaitHandle.WaitOne(); // wait when the file name is being changed
var bufferedData = new RoomInfoWrapper[JsonDataQueue.Count];
lock (JsonDataQueue)
{
JsonDataQueue.CopyTo(bufferedData, 0);
JsonDataQueue.Clear();
}
var utf8Text = JsonConvert.SerializeObject(bufferedData);
var byteText = Encoding.ASCII.GetBytes(utf8Text);
var b = SevenZipHelper.Compress(byteText);
_sw.Write(Encoding.UTF8.GetString(b));
/*Console.WriteLine(
* Encoding.ASCII.GetString(
* SevenZipHelper.Decompress(
* b)).Substring(0,400));*/
}
private void CompressDoUpdateHelper(byte[] content, string name, TypeName typeName, bool compress)
{
if (compress)
{
content = SevenZipHelper.Compress(content);
}
DoUpdateResource(typeName.ToString() + (compress ? "_LZMA" : ""), name, content);
}
public void CreateZipWithEncryptedEntries(string password, int keySize, CompressionMethod compressionMethod = CompressionMethod.Deflated)
{
using (var ms = new MemoryStream())
{
WriteEncryptedZipToStream(ms, password, keySize, compressionMethod);
SevenZipHelper.VerifyZipWith7Zip(ms, password);
}
}
public void BytesCompressionTest()
{
byte[] messageBytes = message.ToBytes();
Debug.Log("uncompressed length: " + messageBytes.Length);
byte[] compressedMessageBytes = SevenZipHelper.Compress(messageBytes);
Debug.Log("compressed length: " + compressedMessageBytes.Length);
Expect(compressedMessageBytes.Length, LessThan(messageBytes.Length));
}
public TextAsset(AssetPreloadData preloadData, bool readSwitch)
{
AssetsFile sourceFile = preloadData.sourceFile;
EndianStream stream = preloadData.sourceFile.a_Stream;
stream.Position = preloadData.Offset;
preloadData.extension = ".txt";
if (sourceFile.platform == -2)
{
uint num2 = stream.ReadUInt32();
PPtr ptr = sourceFile.ReadPPtr();
PPtr ptr2 = sourceFile.ReadPPtr();
}
this.m_Name = stream.ReadAlignedString(stream.ReadInt32());
if (this.m_Name != "")
{
preloadData.Name = this.m_Name;
}
else
{
preloadData.Name = preloadData.TypeString + " #" + preloadData.uniqueID;
}
int count = stream.ReadInt32();
if (readSwitch)
{
this.m_Script = new byte[count];
stream.Read(this.m_Script, 0, count);
if (this.m_Script[0] == 0x5d)
{
this.m_Script = SevenZipHelper.Decompress(this.m_Script);
}
if ((this.m_Script[0] == 60) || ((((this.m_Script[0] == 0xef) && (this.m_Script[1] == 0xbb)) && (this.m_Script[2] == 0xbf)) && (this.m_Script[3] == 60)))
{
preloadData.extension = ".xml";
}
}
else
{
if (stream.ReadByte() == 0x5d)
{
stream.Position += 4L;
preloadData.exportSize = stream.ReadInt32();
stream.Position -= 8L;
}
else
{
preloadData.exportSize = count;
}
stream.Position += count - 1;
}
stream.AlignStream(4);
this.m_PathName = stream.ReadAlignedString(stream.ReadInt32());
}
public static bool IsBundleDataCompressed(AssetBundleFile bundle)
{
AssetsFileReader reader = bundle.reader;
reader.Position = bundle.bundleHeader6.GetBundleInfoOffset();
MemoryStream blocksInfoStream;
AssetsFileReader memReader;
int compressedSize = (int)bundle.bundleHeader6.compressedSize;
byte[] uncompressedBytes;
switch (bundle.bundleHeader6.GetCompressionType())
{
case 1:
uncompressedBytes = new byte[bundle.bundleHeader6.decompressedSize];
using (MemoryStream mstream = new MemoryStream(reader.ReadBytes(compressedSize)))
{
MemoryStream decoder = SevenZipHelper.StreamDecompress(mstream, compressedSize);
decoder.Read(uncompressedBytes, 0, (int)bundle.bundleHeader6.decompressedSize);
decoder.Dispose();
}
blocksInfoStream = new MemoryStream(uncompressedBytes);
break;
case 2:
case 3:
uncompressedBytes = new byte[bundle.bundleHeader6.decompressedSize];
using (MemoryStream mstream = new MemoryStream(reader.ReadBytes(compressedSize)))
{
var decoder = new Lz4DecoderStream(mstream);
decoder.Read(uncompressedBytes, 0, (int)bundle.bundleHeader6.decompressedSize);
decoder.Dispose();
}
blocksInfoStream = new MemoryStream(uncompressedBytes);
break;
default:
blocksInfoStream = null;
break;
}
var uncompressedInf = bundle.bundleInf6;
if (bundle.bundleHeader6.GetCompressionType() != 0)
{
using (memReader = new AssetsFileReader(blocksInfoStream))
{
memReader.Position = 0;
uncompressedInf = new AssetBundleBlockAndDirectoryList06();
uncompressedInf.Read(0, memReader);
}
}
return(uncompressedInf.blockInf.Any(inf => (inf.flags & 0x3f) != 0));
}
///<summary>Decodes a file using SevenZip </summary>
private static async Task <SaveMgr.SaveHead> DecodeAsync(string OriPath, string destPath, int head = 2000)
{
int len = 0;
SaveMgr.SaveHead fileHead = await Task.Run(() => GameUlt.GetFileHead(OriPath, out len));
head = len > head ? len : head;
await Task.Run(() => SevenZipHelper.Unzip(OriPath, destPath, head));
return(fileHead);
}
private static async Task <SaveMgr.SaveHead> DecodeAsync(Stream inStream, Stream outStream, int head = 2000)
{
int len = 0;
var fileHead = GetFileHead(inStream, out len);
head = len > head ? len : head;
await Task.Run(() => SevenZipHelper.Unzip(inStream, outStream, head));
outStream.Position = 0;
return(fileHead);
}
private static async Task BuildSaveFileAsync(Stream inStream, Stream outStream, SaveFile.FileHeader header)
{
var saveHead = new SaveMgr.SaveHead();
saveHead.V = header.Version;
saveHead.M = header.Mode;
saveHead.Ms = header.Mods;
saveHead.U = header.WriteTime;
string head = Assets.USecurity.AES.Encrypt(JsonConvert.SerializeObject((object)saveHead), "bh89757");
await Task.Run(() => SevenZipHelper.Zip(inStream, outStream, head));
}
public void JsonCompressionTest()
{
string jsonString = message.ToJsonString();
byte[] jsonBytes = Encoding.UTF8.GetBytes(jsonString);
Debug.Log(jsonString);
Debug.Log("uncompressed length: " + jsonBytes.Length);
byte[] jsonBytesCompressed = SevenZipHelper.Compress(jsonBytes);
Debug.Log("compressed length: " + jsonBytesCompressed.Length);
Expect(jsonBytesCompressed.Length, LessThan(jsonBytes.Length));
}
static Assembly ReadAssemblyFromResource(AssemblyName assemblyName)
{
var resStream = Assembly.GetExecutingAssembly().GetManifestResourceStream(assemblyName.Name.ToLower());
if (resStream == null)
{
return(null);
}
var assemblyStream = new BinaryReader(resStream);
byte[] data = SevenZipHelper.Decompress(assemblyStream.ReadBytes((int)assemblyStream.BaseStream.Length));
return(Assembly.Load(data));
}
override public byte[] Expand(byte[] inputbuffer, int realsize)
{
var ret = SevenZipHelper.Decompress(inputbuffer);
if (ret.Length != realsize)
{
System.Console.WriteLine("WARNING! I expected this lzma block to be " + realsize + " byte long, but it is in fact " + ret.Length + " bytes long");
if (ret.Length == inputbuffer.Length)
{
System.Console.WriteLine("I have the feeling decompression did NOT take place somehow(?)");
}
}
return(ret);
}
private static async Task BuildSaveFileAsync(Stream st, string path, SaveFile.FileHeader header)
{
SaveMgr.SaveHead saveHead = new SaveMgr.SaveHead();
saveHead.V = header.Version;
saveHead.M = header.Mode;
saveHead.Ms = header.Mods;
saveHead.U = header.WriteTime;
string head = Assets.USecurity.AES.Encrypt(JsonConvert.SerializeObject((object)saveHead), "bh89757");
if (IntPtr.Size == 4)
{
GC.Collect();
}
await Task.Run(() => SevenZipHelper.Zip(st, path, head));
}
