/// <summary>
/// Wraps the given stream in a compression stream.
/// </summary>
/// <param name="output">Stream to wrap.</param>
/// <returns>Compression stream to which data can be written.</returns>
public static Stream CompressStream(Stream output)
{
Stream result = new GZipStream(output, CompressionMode.Compress);
result.WriteByte(0xff & (MagicNumber >> 24));
result.WriteByte(0xff & (MagicNumber >> 16));
result.WriteByte(0xff & (MagicNumber >> 8));
result.WriteByte(0xff & (MagicNumber));
return result;
}
public static void Save(Level level, string file) {
using (Stream fs = File.Create(file),
gs = new GZipStream(fs, CompressionMode.Compress, true))
{
byte[] header = new byte[16];
BitConverter.GetBytes(1874).CopyTo(header, 0);
gs.Write(header, 0, 2);
BitConverter.GetBytes(level.Width).CopyTo(header, 0);
BitConverter.GetBytes(level.Length).CopyTo(header, 2);
BitConverter.GetBytes(level.Height).CopyTo(header, 4);
BitConverter.GetBytes(level.spawnx).CopyTo(header, 6);
BitConverter.GetBytes(level.spawnz).CopyTo(header, 8);
BitConverter.GetBytes(level.spawny).CopyTo(header, 10);
header[12] = level.rotx;
header[13] = level.roty;
header[14] = (byte)level.permissionvisit;
header[15] = (byte)level.permissionbuild;
gs.Write(header, 0, header.Length);
byte[] blocks = level.blocks;
byte[] convBlocks = new byte[blocks.Length];
for (int i = 0; i < blocks.Length; ++i) {
byte block = blocks[i];
if (block < Block.CpeCount) {
convBlocks[i] = block; //CHANGED THIS TO INCOPARATE SOME MORE SPACE THAT I NEEDED FOR THE door_orange_air ETC.
} else {
convBlocks[i] = Block.SaveConvert(block);
}
}
gs.Write(convBlocks, 0, convBlocks.Length);
// write out new blockdefinitions data
gs.WriteByte(0xBD);
int index = 0;
for (int y = 0; y < level.ChunksY; y++)
for (int z = 0; z < level.ChunksZ; z++)
for (int x = 0; x < level.ChunksX; x++)
{
byte[] chunk = level.CustomBlocks[index];
if (chunk == null) {
gs.WriteByte(0);
} else {
gs.WriteByte(1);
gs.Write(chunk, 0, chunk.Length);
}
index++;
}
}
}
public async Task ConcatenatedEmptyGzipStreams()
{
const int copyToBufferSizeRequested = 0x8000;
// we'll request a specific size buffer, but we cannot guarantee that's the size
// that will be used since CopyTo will rent from the array pool
// take advantage of this knowledge to find out what size it will actually use
var rentedBuffer = ArrayPool <byte> .Shared.Rent(copyToBufferSizeRequested);
int actualBufferSize = rentedBuffer.Length;
ArrayPool <byte> .Shared.Return(rentedBuffer);
// use 3 buffers-full so that we can prime the stream with the first buffer-full,
// test that CopyTo successfully flushes this at the beginning of the operation,
// then populates the second buffer-full and reads its entirety despite every
// payload being 0 length before it reads the final buffer-full.
int minCompressedSize = 3 * actualBufferSize;
using (Stream compressedStream = new DerivedMemoryStream())
{
using (var gz = new GZipStream(compressedStream, CompressionLevel.NoCompression, leaveOpen: true))
{
// write one byte in order to allow us to prime the inflater buffer
gz.WriteByte(3);
}
while (compressedStream.Length < minCompressedSize)
{
using (var gz = new GZipStream(compressedStream, CompressionLevel.NoCompression, leaveOpen: true))
{
gz.Write(Array.Empty <byte>());
}
}
compressedStream.Seek(0, SeekOrigin.Begin);
using (Stream gz = new GZipStream(compressedStream, CompressionMode.Decompress, leaveOpen: true))
using (Stream decompressedData = new DerivedMemoryStream())
{
// read one byte in order to fill the inflater bufffer before copy
Assert.Equal(3, gz.ReadByte());
gz.CopyTo(decompressedData, copyToBufferSizeRequested);
Assert.Equal(0, decompressedData.Length);
}
compressedStream.Seek(0, SeekOrigin.Begin);
using (Stream gz = new GZipStream(compressedStream, CompressionMode.Decompress, leaveOpen: true))
using (Stream decompressedData = new DerivedMemoryStream())
{
// read one byte in order to fill the inflater bufffer before copy
Assert.Equal(3, gz.ReadByte());
await gz.CopyToAsync(decompressedData, copyToBufferSizeRequested);
Assert.Equal(0, decompressedData.Length);
}
}
}
static void CompressFile(string inFilename, string outFilename)
{
FileStream sourceFile = File.OpenRead(inFilename);
FileStream destFile = File.Create(outFilename);
GZipStream compStream = new GZipStream(destFile, CompressionMode.Compress);
int theByte = sourceFile.ReadByte();
while (theByte != -1)
{
compStream.WriteByte((byte)theByte);
theByte = sourceFile.ReadByte();
}
sourceFile.Close();
destFile.Close();
compStream.Close();
}
public byte[] Compress(byte[] fileBytes)
{
byte[] bytes;
using (MemoryStream fileStream = new MemoryStream(fileBytes)) {
using (MemoryStream compressedStream = new MemoryStream()) {
using (GZipStream zipStream = new GZipStream(compressedStream, CompressionMode.Compress)) {
int value;
while ((value = fileStream.ReadByte()) != -1) {
zipStream.WriteByte((byte) value);
}
zipStream.Close();
bytes = compressedStream.ToArray();
}
}
}
return bytes;
}
static void Main()
{
// Создание файла и архива.
FileStream source = File.OpenRead(@"D:\test.txt");
FileStream destination = File.Create(@"D:\archive.zip");
// Создание компрессора.
GZipStream compressor = new GZipStream(destination, CompressionMode.Compress);
// Заполнение архива информацией из файла.
int theByte = source.ReadByte();
while (theByte != -1)
{
compressor.WriteByte((byte)theByte);
theByte = source.ReadByte();
}
// Удаление компрессора.
compressor.Close();
}
static void Main(string[] args)
{
FileStream sourceFile = File.OpenRead(@"d.txt");
FileStream destFile = File.Create(@"sample.zip");
GZipStream compStream = new GZipStream(destFile, CompressionMode.Compress);
try
{
int theByte = sourceFile.ReadByte();
while (theByte != -1)
{
compStream.WriteByte((byte)theByte);
theByte = sourceFile.ReadByte();
}
}
finally
{
compStream.Dispose();
}
}
// Compresses the given file, and optionally deletes the source file when finished
private void CompressFile(string fileName, bool deleteFile = true)
{
// zip up the file, taking the compression level from the configuration
var zipFileName = String.Format(ZipPattern, fileName);
using (var fileStream = File.OpenRead(fileName))
using (var destFile = File.Create(zipFileName))
using (var compStream = new GZipStream(destFile, CompressionLevel.Optimal))
{
int theByte = fileStream.ReadByte();
while (theByte != -1)
{
compStream.WriteByte((byte)theByte);
theByte = fileStream.ReadByte();
}
}
if (deleteFile)
File.Delete(fileName);
}
public void ToStream(Stream writestream)
{
GZipStream gZipStream = null;
try
{
System.Windows.MessageBox.Show(Convert.ToString(this.Filedata.Length));
gZipStream = new GZipStream(writestream, CompressionMode.Compress, true);
gZipStream.Write(this.Filedata, 0, (int)this.Filedata.Length);
gZipStream.WriteByte(255);
//gZipStream.Write(this.Screenshot, 0, (int)this.Screenshot.Length);
}
finally
{
if (gZipStream != null)
{
gZipStream.Close();
}
}
return;
}
private async Task TestConcatenatedGzipStreams(int streamCount, bool useAsync, bool useReadByte, int bufferSize, int bytesPerStream = 1)
{
using (var correctDecompressedOutput = new MemoryStream())
using (var compressedStream = new MemoryStream())
using (var decompressorOutput = new MemoryStream())
{
for (int i = 0; i < streamCount; i++)
{
using (var gz = new GZipStream(compressedStream, CompressionLevel.NoCompression, true))
{
for (int j = 0; j < bytesPerStream; j++)
{
byte b = (byte)((i * j) % 256);
gz.WriteByte(b);
correctDecompressedOutput.WriteByte(b);
}
}
}
compressedStream.Seek(0, SeekOrigin.Begin);
var decompressor = CreateStream(compressedStream, CompressionMode.Decompress);
//Thread.Sleep(10000);
var bytes = new byte[bufferSize];
bool finished = false;
int retCount = 0, totalRead = 0;
while (!finished)
{
if (useAsync)
{
try
{
retCount = await decompressor.ReadAsync(bytes, 0, bufferSize);
totalRead += retCount;
if (retCount != 0)
{
await decompressorOutput.WriteAsync(bytes, 0, retCount);
}
else
{
finished = true;
}
}
catch (Exception)
{
throw new Exception(retCount + " " + totalRead);
}
}
else if (useReadByte)
{
int b = decompressor.ReadByte();
if (b != -1)
{
decompressorOutput.WriteByte((byte)b);
}
else
{
finished = true;
}
}
else
{
retCount = decompressor.Read(bytes, 0, bufferSize);
if (retCount != 0)
{
decompressorOutput.Write(bytes, 0, retCount);
}
else
{
finished = true;
}
}
}
decompressor.Dispose();
decompressorOutput.Position = 0;
byte[] decompressorOutputBytes = decompressorOutput.ToArray();
byte[] correctOutputBytes = correctDecompressedOutput.ToArray();
Assert.Equal(correctOutputBytes.Length, decompressorOutputBytes.Length);
for (int i = 0; i < correctOutputBytes.Length; i++)
{
Assert.Equal(correctOutputBytes[i], decompressorOutputBytes[i]);
}
}
}
internal void FullSave()
{
/*
* All we need to do here is dump our level blocks to the file
*
* we dont need to close the filehandle for the uncompressed version
*/
Server.Log("Full Save Directory check...", LogTypesEnum.debug);
DirectoryCheck();
Server.Log("Backup old file...", LogTypesEnum.debug);
if (File.Exists(fileName + compressedExtension))
{
if (File.Exists(fileName + compressedExtension + backupExtension)) File.Delete(fileName + compressedExtension + backupExtension);
File.Copy(fileName + compressedExtension, fileName + compressedExtension + backupExtension);
}
Server.Log("Saving new File...", LogTypesEnum.debug);
FileStream fileStream = new FileStream(compressedPath, FileMode.Create);
GZipStream gzipStream = new GZipStream(fileStream, CompressionMode.Compress);
gzipStream.Write(encode.GetBytes(name.PadRight(64)), 0, 64);
gzipStream.Write(BitConverter.GetBytes(sizeX), 0, 2);
gzipStream.Write(BitConverter.GetBytes(sizeY), 0, 2);
gzipStream.Write(BitConverter.GetBytes(sizeZ), 0, 2);
gzipStream.Write(BitConverter.GetBytes(spawnPos.x), 0, 2);
gzipStream.Write(BitConverter.GetBytes(spawnPos.y), 0, 2);
gzipStream.Write(BitConverter.GetBytes(spawnPos.z), 0, 2);
gzipStream.WriteByte(spawnPos.pitch);
gzipStream.WriteByte(spawnPos.yaw);
gzipStream.Write(BitConverter.GetBytes(physics.isEnabled), 0, 1);
gzipStream.Write(BitConverter.GetBytes(physics.realistic), 0, 1);
gzipStream.Write(blocks, 0, blocks.Length);
gzipStream.Flush();
gzipStream.Close();
//fileStream.Flush();
fileStream.Close();
Console.WriteLine("Done?");
}
private async Task TestConcatenatedGzipStreams(int streamCount, TestScenario scenario, int bufferSize, int bytesPerStream = 1)
{
bool isCopy = scenario == TestScenario.Copy || scenario == TestScenario.CopyAsync;
using (MemoryStream correctDecompressedOutput = new MemoryStream())
// For copy scenarios use a derived MemoryStream to avoid MemoryStream's Copy optimization
// that turns the Copy into a single Write passing the backing buffer
using (MemoryStream compressedStream = isCopy ? new DerivedMemoryStream() : new MemoryStream())
using (MemoryStream decompressorOutput = new MemoryStream())
{
for (int i = 0; i < streamCount; i++)
{
using (var gz = new GZipStream(compressedStream, CompressionLevel.NoCompression, true))
{
for (int j = 0; j < bytesPerStream; j++)
{
byte b = (byte)((i * j) % 256);
gz.WriteByte(b);
correctDecompressedOutput.WriteByte(b);
}
}
}
compressedStream.Seek(0, SeekOrigin.Begin);
var decompressor = CreateStream(compressedStream, CompressionMode.Decompress);
var bytes = new byte[bufferSize];
bool finished = false;
int retCount = 0, totalRead = 0;
while (!finished)
{
switch (scenario)
{
case TestScenario.ReadAsync:
try
{
retCount = await decompressor.ReadAsync(bytes, 0, bufferSize);
totalRead += retCount;
if (retCount != 0)
{
await decompressorOutput.WriteAsync(bytes, 0, retCount);
}
else
{
finished = true;
}
}
catch (Exception)
{
throw new Exception(retCount + " " + totalRead);
}
break;
case TestScenario.ReadByte:
int b = decompressor.ReadByte();
if (b != -1)
{
decompressorOutput.WriteByte((byte)b);
}
else
{
finished = true;
}
break;
case TestScenario.Read:
retCount = decompressor.Read(bytes, 0, bufferSize);
if (retCount != 0)
{
decompressorOutput.Write(bytes, 0, retCount);
}
else
{
finished = true;
}
break;
case TestScenario.Copy:
decompressor.CopyTo(decompressorOutput, bufferSize);
finished = true;
break;
case TestScenario.CopyAsync:
await decompressor.CopyToAsync(decompressorOutput, bufferSize);
finished = true;
break;
}
}
decompressor.Dispose();
decompressorOutput.Position = 0;
byte[] decompressorOutputBytes = decompressorOutput.ToArray();
byte[] correctOutputBytes = correctDecompressedOutput.ToArray();
Assert.Equal(correctOutputBytes.Length, decompressorOutputBytes.Length);
for (int i = 0; i < correctOutputBytes.Length; i++)
{
Assert.Equal(correctOutputBytes[i], decompressorOutputBytes[i]);
}
}
}
static void Slice(string sourceFile, string destinationDirectory, int parts)
{
int partsCounter = 0;
int dotPosition = sourceFile.LastIndexOf('.');
int slashPosition = sourceFile.LastIndexOf('\\');
string sourceFileName = sourceFile.Substring(slashPosition + 1, dotPosition - slashPosition - 1);
string sourceFileExtension = sourceFile.Substring(dotPosition);
if (destinationDirectory.LastIndexOf('\\') != destinationDirectory.Length - 1)
{
destinationDirectory += "\\";
}
using (FileStream source = new FileStream(sourceFile, FileMode.Open, FileAccess.ReadWrite))
{
long partSize = source.Length / parts;
while (partsCounter < parts)
{
source.Position = partsCounter * partSize;
using (FileStream destination = new FileStream(destinationDirectory + sourceFileName + "-part" + partsCounter + sourceFileExtension + ".gz", FileMode.OpenOrCreate, FileAccess.Write))
{
using (GZipStream compressionStream = new GZipStream(destination,CompressionLevel.Optimal))
{
long byteCounter = 0;
while (byteCounter <= partSize)
{
compressionStream.WriteByte((byte)source.ReadByte());
byteCounter++;
}
}
}
partsCounter++;
}
}
Console.WriteLine("The file was sliced successfully.");
}
public void Save(string outpath)
{
#if WIN32
{
string file = System.IO.Path.Combine(outpath, "seeds.bin.bytes");
if (System.IO.Directory.Exists(outpath) == false)
{
System.IO.Directory.CreateDirectory(outpath);
}
using (System.IO.Stream os = System.IO.File.Create(file))
{
#if USECompression
using (GZipStream s = new GZipStream(os, CompressionMode.Compress))
#else
var s = os;
#endif
{
UInt16 len=(UInt16) seeds.Count;
s.Write(BitConverter.GetBytes(len), 0, 2);
foreach (var i in seeds)
{
byte[] sb = System.Text.Encoding.UTF8.GetBytes(i.Key);
s.WriteByte((byte)sb.Length);
s.Write(sb, 0, sb.Length);
i.Value.Write(s);
}
}
}
}
string flist = "";
foreach (var i in anims)
{
string file = System.IO.Path.Combine(outpath, i.Key + ".anim.bin");
using (System.IO.Stream s = System.IO.File.Create(file+".bytes"))
{
i.Value.Write(s);
}
flist += file + "\r\n";
}
System.IO.File.WriteAllText(System.IO.Path.Combine(outpath, "anims.txt"), flist);
#endif
}
public static byte[] GZip(byte[] mapSize, byte[] levelData)
{
var ms = new MemoryStream();
var gs = new GZipStream(ms, CompressionMode.Compress, true);
gs.Write(mapSize, 0, mapSize.Length);
//gs.Write(levelData, 0, levelData.Length);
int currentstart = 0;
for (int i = 0; i < levelData.Length; i++ )
{
byte block = levelData[i];
if(block>49)
{
if(i>0) gs.Write(levelData, currentstart, (i-currentstart));
currentstart = i + 1;
gs.WriteByte((Block.Blocks.ContainsKey(block) ? Block.Blocks[block].BaseType : (byte)0));
}
}
if (currentstart != levelData.Length)
{
gs.Write(levelData, currentstart, (levelData.Length - currentstart));
}
gs.Flush();
gs.Dispose();
ms.Position = 0;
var bytes = new byte[ms.Length];
ms.Read(bytes, 0, (int) ms.Length);
ms.Close();
ms.Dispose();
return bytes;
}
public void FullSave()
{
/*
* All we need to do here is dump our level blocks to the file
*
* we dont need to close the filehandle for the uncompressed version
*/
Server.Log("Full Save Directory check...", LogTypesEnum.Debug);
DirectoryCheck();
Server.Log("Backup old file...", LogTypesEnum.Debug);
if (File.Exists(FileName + CompressedExtension))
{
if (File.Exists(FileName + CompressedExtension + BackupExtension))
File.Delete(FileName + CompressedExtension + BackupExtension);
File.Copy(FileName + CompressedExtension, FileName + CompressedExtension + BackupExtension);
}
Server.Log("Saving new File...", LogTypesEnum.Debug);
var fileStream = new FileStream(CompressedPath, FileMode.Create);
var gzipStream = new GZipStream(fileStream, CompressionMode.Compress);
gzipStream.Write(_encode.GetBytes(Name.PadRight(64)), 0, 64);
gzipStream.Write(BitConverter.GetBytes(SizeX), 0, 2);
gzipStream.Write(BitConverter.GetBytes(SizeY), 0, 2);
gzipStream.Write(BitConverter.GetBytes(SizeZ), 0, 2);
gzipStream.Write(BitConverter.GetBytes(SpawnPos.X), 0, 2);
gzipStream.Write(BitConverter.GetBytes(SpawnPos.Y), 0, 2);
gzipStream.Write(BitConverter.GetBytes(SpawnPos.Z), 0, 2);
gzipStream.WriteByte(SpawnPos.Pitch);
gzipStream.WriteByte(SpawnPos.Yaw);
gzipStream.Write(BitConverter.GetBytes(Physics.IsEnabled), 0, 1);
gzipStream.Write(BitConverter.GetBytes(Physics.Realistic), 0, 1);
gzipStream.WriteByte(BuildPermissions);
gzipStream.WriteByte(VisitPermissions);
gzipStream.Write(BlockData, 0, BlockData.Length);
gzipStream.Flush();
gzipStream.Close();
//fileStream.Flush();
fileStream.Close();
Console.WriteLine("Done?");
}
public void Backup()
{
if (((TimeSpan)(DateTime.Now - lastSaveTime)).TotalSeconds > 600) return; //Don't back up if the map hasn't changed in 10 minutes
try
{
string name = "backups/" + this.name + "/" + DateTime.Now.ToFileTime().ToString();
string filename = name + ".umw";
byte[] saveblocks = new byte[blocks.Length];
blocks.CopyTo(saveblocks, 0);
for (int i = 0; i < saveblocks.Length; i++)
{
switch (saveblocks[i])
{
case Blocks.unflood:
saveblocks[i] = Blocks.ConvertType(saveblocks[i]);
break;
default:
break;
}
}
if (!Directory.Exists("backups/" + this.name)) Directory.CreateDirectory("backups/" + this.name);
GZipStream gzout = new GZipStream(new FileStream("maps/" + filename, FileMode.OpenOrCreate), CompressionMode.Compress);
gzout.Write(BitConverter.GetBytes(0xebabefac), 0, 4);
gzout.Write(BitConverter.GetBytes(width), 0, 2);
gzout.Write(BitConverter.GetBytes(height), 0, 2);
gzout.Write(BitConverter.GetBytes(depth), 0, 2);
gzout.Write(BitConverter.GetBytes(spawnx), 0, 2);
gzout.Write(BitConverter.GetBytes(spawny), 0, 2);
gzout.Write(BitConverter.GetBytes(spawnz), 0, 2);
gzout.WriteByte(this.srotx);
gzout.WriteByte(this.sroty);
gzout.Write(saveblocks, 0, saveblocks.Length);
//gzout.BaseStream.Close();
gzout.Close();
StreamWriter mBlocksOut = new StreamWriter(File.Open("maps/" + name + ".mb", FileMode.Create));
foreach (KeyValuePair<int, string> mb in this.messageBlocks)
{
mBlocksOut.WriteLine(mb.Key + " " + mb.Value);
}
mBlocksOut.Close();
StreamWriter tBlocksOut = new StreamWriter(File.Open("maps/" + name + ".tb", FileMode.Create));
foreach (KeyValuePair<int, int> tb in this.teleportBlocks)
{
tBlocksOut.WriteLine(tb.Key + " " + tb.Value);
}
tBlocksOut.Close();
Program.server.logger.log("Level \"" + this.name + "\" backed up");
}
catch (Exception e)
{
Program.server.logger.log("Error occurred while backing up map", Logger.LogType.Error);
Program.server.logger.log(e);
}
}
public void Save()
{
if (!blockChanged) return; //Don't save if nothing happened
try
{
byte[] saveblocks = new byte[blocks.Length];
blocks.CopyTo(saveblocks, 0);
for (int i = 0; i < saveblocks.Length; i++)
{
switch (saveblocks[i])
{
case Blocks.unflood:
saveblocks[i] = Blocks.ConvertType(saveblocks[i]);
break;
case Blocks.doorOpen:
saveblocks[i] = Blocks.door;
break;
default:
break;
}
}
GZipStream gzout = new GZipStream(new FileStream("maps/" + filename, FileMode.OpenOrCreate), CompressionMode.Compress);
gzout.Write(BitConverter.GetBytes(0xebabefac), 0, 4);
gzout.Write(BitConverter.GetBytes(width), 0, 2);
gzout.Write(BitConverter.GetBytes(height), 0, 2);
gzout.Write(BitConverter.GetBytes(depth), 0, 2);
gzout.Write(BitConverter.GetBytes(spawnx), 0, 2);
gzout.Write(BitConverter.GetBytes(spawny), 0, 2);
gzout.Write(BitConverter.GetBytes(spawnz), 0, 2);
gzout.WriteByte(this.srotx);
gzout.WriteByte(this.sroty);
gzout.Write(saveblocks, 0, saveblocks.Length);
//gzout.BaseStream.Close();
gzout.Close();
StreamWriter mBlocksOut = new StreamWriter(File.Open("maps/" + name + ".mb", FileMode.Create));
foreach (KeyValuePair<int, string> mb in this.messageBlocks)
{
mBlocksOut.WriteLine(mb.Key + " " + mb.Value);
}
mBlocksOut.Close();
StreamWriter tBlocksOut = new StreamWriter(File.Open("maps/" + name + ".tb", FileMode.Create));
foreach (KeyValuePair<int, int> tb in this.teleportBlocks)
{
tBlocksOut.WriteLine(tb.Key + " " + tb.Value);
}
tBlocksOut.Close();
Program.server.logger.log("Level \"" + this.name + "\" saved");
lastSaveTime = DateTime.Now;
blockChanged = false;
}
catch (Exception e)
{
Program.server.logger.log("Error occurred while saving map", Logger.LogType.Error);
Program.server.logger.log(e);
}
}
public static void Save(VoxelSprite sprite, ref Color[] swatches)
{
//StringBuilder sb = new StringBuilder();
//using (StringWriter str = new StringWriter(sb))
//{
SaveFileDialog sfd = new SaveFileDialog();
sfd.AddExtension = true;
sfd.DefaultExt = ".vxl";
sfd.Filter = "Voxel Sprite|*.vxs";
DialogResult dr = sfd.ShowDialog();
if (string.IsNullOrEmpty(sfd.FileName) || dr != DialogResult.OK) return;
using (FileStream str = new FileStream(sfd.FileName, FileMode.Create))
{
//str.Write(gameWorld.X_CHUNKS + "," + gameWorld.Y_CHUNKS + "," + gameWorld.Z_CHUNKS + "\n");
using (GZipStream gzstr = new GZipStream(str, CompressionMode.Compress))
{
gzstr.WriteByte(Convert.ToByte(sprite.X_SIZE));
gzstr.WriteByte(Convert.ToByte(sprite.Y_SIZE));
gzstr.WriteByte(Convert.ToByte(sprite.Z_SIZE));
gzstr.WriteByte(Convert.ToByte(sprite.AnimChunks.Count));
for (int i = 0; i < 10; i++)
{
gzstr.WriteByte(swatches[i].R);
gzstr.WriteByte(swatches[i].G);
gzstr.WriteByte(swatches[i].B);
}
foreach (AnimChunk c in sprite.AnimChunks)
{
//str.Write("C\n");
//Chunk c = gameWorld.Chunks[x, y, z];
for (int vx = 0; vx < sprite.X_SIZE; vx++)
for (int vy = 0; vy < sprite.Y_SIZE; vy++)
for (int vz = 0; vz < sprite.Z_SIZE; vz++)
{
if (!c.Voxels[vx, vy, vz].Active) continue;
//string vox = vx + "," + vy + "," + vz + ",";
//vox += ((int)c.Voxels[vx, vy, vz].Type);
//str.Write(vox + "\n");
gzstr.WriteByte(Convert.ToByte(vx));
gzstr.WriteByte(Convert.ToByte(vy));
gzstr.WriteByte(Convert.ToByte(vz));
gzstr.WriteByte(c.Voxels[vx, vy, vz].Color.R);
gzstr.WriteByte(c.Voxels[vx, vy, vz].Color.G);
gzstr.WriteByte(c.Voxels[vx, vy, vz].Color.B);
}
gzstr.WriteByte(Convert.ToByte('c'));
}
//str.Flush();
}
}
//}
//using (StreamWriter fs = new StreamWriter(fn))
//{
// fs.Write(Compress(sb.ToString()));
// fs.Flush();
//}
//sb.Clear();
//sb = null;
GC.Collect();
}
public static void Main(string[] args)
{
List<FerriesRoute> _items = new List<FerriesRoute>();
List<CacheFlushDate> _cacheFlushDate = new List<CacheFlushDate>();
var serializer = new JsonSerializer();
string cachedDateTime = "";
// The Traveler Information Application Programming Interface is designed to provide third parties
// with a single gateway to all of WSDOT's traveler information data. To use the WSDL services you
// must be assigned an Access Code. You can obtain an Access Code by simply providing your email
// address at the Traveler Information API site, http://www.wsdot.wa.gov/traffic/api/
string API_ACCESS_CODE = "INSERT_YOUR_API_ACCESS_CODE_HERE";
b2b.wsdot.wa.gov.WSFSchedule obj = new b2b.wsdot.wa.gov.WSFSchedule();
try
{
using (var re = File.OpenText(@"WSFCacheFlushDateSchedules.js"))
using (var reader = new JsonTextReader(re))
{
var entries = serializer.Deserialize<CacheFlushDate[]>(reader);
cachedDateTime = entries[0].CacheDate.ToString();
}
}
catch
{
Console.WriteLine("Error opening WSFCacheFlushDateSchedules.js file");
}
// Most web methods in this service are cached. Implementing caching in your program is recommended
// in order to not query the web service when not necessary. GetCacheFlushDate() will tell you the
// date and time that the cache was last flushed.
System.DateTime dateTime = (System.DateTime) obj.GetCacheFlushDate();
_cacheFlushDate.Add(new CacheFlushDate() {
CacheDate = dateTime
});
// Write the most recent cache flush date and time to a JSON file.
string jsonCacheDate = JsonConvert.SerializeObject(_cacheFlushDate);
File.WriteAllText(@"WSFCacheFlushDateSchedules.js", jsonCacheDate);
// Compare the cache dates. If dates are equal then we already have the most current data.
if (!cachedDateTime.Equals(dateTime.ToString()))
{
// All method calls require the APIAccessHeader to pass a valid APIAccessCode.
b2b.wsdot.wa.gov.APIAccessHeader apiAccessHeader = new b2b.wsdot.wa.gov.APIAccessHeader();
apiAccessHeader.APIAccessCode = API_ACCESS_CODE;
obj.APIAccessHeaderValue = apiAccessHeader;
b2b.wsdot.wa.gov.TripDateMsg tripDateMsg = new b2b.wsdot.wa.gov.TripDateMsg();
b2b.wsdot.wa.gov.RouteMsg routeMsg = new b2b.wsdot.wa.gov.RouteMsg();
tripDateMsg.TripDate = DateTime.Today;
// Provide all available routes for a particular date.
b2b.wsdot.wa.gov.RouteBriefResponse[] routes = obj.GetAllRoutes(tripDateMsg);
for (int i=0; i<routes.Length; i++)
{
_items.Add(new FerriesRoute() {
RouteID = routes[i].RouteID,
Description = routes[i].Description
});
DateTime today = DateTime.Today;
for (int j=0; j<7; j++)
{
_items[i].Date.Add(new Dates() {
Date = today
});
routeMsg.RouteID = routes[i].RouteID;
routeMsg.TripDate = today;
// Retrieve sailing times associated with a specific route for a particular date.
b2b.wsdot.wa.gov.SchedResponse scheduleByRouteResults = obj.GetScheduleByRoute(routeMsg);
for (int k=0; k<scheduleByRouteResults.TerminalCombos.Length; k++)
{
_items[i].Date[j].Sailings.Add(new FerriesTerminal() {
DepartingTerminalID = scheduleByRouteResults.TerminalCombos[k].DepartingTerminalID,
DepartingTerminalName = scheduleByRouteResults.TerminalCombos[k].DepartingTerminalName,
ArrivingTerminalID = scheduleByRouteResults.TerminalCombos[k].ArrivingTerminalID,
ArrivingTerminalName = scheduleByRouteResults.TerminalCombos[k].ArrivingTerminalName
});
b2b.wsdot.wa.gov.TerminalComboMsg terminalComboMsg = new b2b.wsdot.wa.gov.TerminalComboMsg();
terminalComboMsg.TripDate = today;
terminalComboMsg.DepartingTerminalID = scheduleByRouteResults.TerminalCombos[k].DepartingTerminalID;
terminalComboMsg.ArrivingTerminalID = scheduleByRouteResults.TerminalCombos[k].ArrivingTerminalID;
// Retrieve sailing times associated with a specific departing / arriving terminal combination for a particular date.
b2b.wsdot.wa.gov.SchedResponse scheduleByTerminalComboResults = obj.GetScheduleByTerminalCombo(terminalComboMsg);
for (int l=0; l<scheduleByTerminalComboResults.TerminalCombos.Length; l++)
{
for (int m=0; m<scheduleByTerminalComboResults.TerminalCombos[l].Annotations.Length; m++)
{
_items[i].Date[j].Sailings[k].Annotations.Add(scheduleByTerminalComboResults.TerminalCombos[l].Annotations[m]);
}
for (int n=0; n<scheduleByTerminalComboResults.TerminalCombos[l].Times.Length; n++)
{
_items[i].Date[j].Sailings[k].Times.Add(new FerriesScheduleTimes() {
DepartingTime = scheduleByTerminalComboResults.TerminalCombos[l].Times[n].DepartingTime
});
for (int o=0; o<scheduleByTerminalComboResults.TerminalCombos[l].Times[n].AnnotationIndexes.Length; o++)
{
_items[i].Date[j].Sailings[k].Times[n].AnnotationIndexes.Add(scheduleByTerminalComboResults.TerminalCombos[l].Times[n].AnnotationIndexes[o]);
}
}
}
}
today = today.AddDays(1);
}
}
// Serialize the data object to a JSON file.
string json = JsonConvert.SerializeObject(_items);
File.WriteAllText(@"WSFRouteSchedules.js", json);
FileStream sourceFile = File.OpenRead(@"WSFRouteSchedules.js");
FileStream destFile = File.Create(@"WSFRouteSchedules.js.gz");
// Now compress the JSON file so it is smaller to download.
// Uncompressed the file is about 459 KB, compressed it drops to 25 KB. Nice.
GZipStream compStream = new GZipStream(destFile, CompressionMode.Compress);
try
{
int theByte = sourceFile.ReadByte();
while (theByte != -1)
{
compStream.WriteByte((byte)theByte);
theByte = sourceFile.ReadByte();
}
}
finally
{
compStream.Dispose();
}
}
}
