ft/skyscraper8
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases 2 Wiki Activity

Compare commits

base: ft:bcf31c729620416a4e84f58db1f9299fe865d0b3
Branches Tags
ft:master
ft:sauerland
ft:ptsFrameDumper
ft:origin/master
ft:bbframes-revisited2
ft:bbframes-revisited3
ft:bbframes-revisited3
ft:release_tag
..
compare: ft:3b30ff7371c6c07c6460623d888174ca96431eba
Branches Tags
ft:master
ft:sauerland
ft:ptsFrameDumper
ft:origin/master
ft:bbframes-revisited2
ft:bbframes-revisited3
ft:bbframes-revisited3
ft:release_tag

No commits in common. "bcf31c729620416a4e84f58db1f9299fe865d0b3" and "3b30ff7371c6c07c6460623d888174ca96431eba" have entirely different histories.
bcf31c7296 ... 3b30ff7371

3 changed files with 431 additions and 423 deletions
Show Stats Expand all files Collapse all files

4
skyscraper8/Skyscraper/IO/RemoteStreamReader/RemoteStreamReaderClient.cs
View File

@ -522,10 +522,10 @@ namespace skyscraper5.Skyscraper.IO.RemoteStreamReader
switch (result) switch (result)
{ {
case RemoteStreamReaderConstants.COMMAND_SUCCESSFUL: case RemoteStreamReaderConstants.COMMAND_SUCCESSFUL:
pRFLevel = TcpStream.ReadDoubleBE(); pRFLevel = NetworkStreamExtensions.ReadDoubleBE(TcpStream);
return true; return true;
case RemoteStreamReaderConstants.COMMAND_FAILED: case RemoteStreamReaderConstants.COMMAND_FAILED:
pRFLevel = TcpStream.ReadDoubleBE(); pRFLevel = NetworkStreamExtensions.ReadDoubleBE(TcpStream);
return false; return false;
default: default:
throw new NotImplementedException(result.ToString()); throw new NotImplementedException(result.ToString());

814
skyscraper8/Skyscraper/IO/StreamExtensions.cs
View File

@ -1,427 +1,401 @@
using System; using System;
using System.ComponentModel; using System.ComponentModel;
using System.Diagnostics; using System.Diagnostics;
using System.IO; using System.IO;
using System.IO.Compression; using System.IO.Compression;
using System.Net.Sockets; using System.Net.Sockets;
using System.Runtime.CompilerServices; using System.Runtime.CompilerServices;
using System.Text; using System.Text;
namespace skyscraper5.Skyscraper.IO namespace skyscraper5.Skyscraper.IO
{ {
public static class StreamExtensions public static class StreamExtensions
{ {
[DebuggerStepThrough] [DebuggerStepThrough]
public static ushort ReadUInt16BE(this Stream stream) public static ushort ReadUInt16BE(this Stream stream)
{ {
byte[] buffer = new byte[2]; byte[] buffer = new byte[2];
if (stream.Read(buffer, 0, 2) != 2) if (stream.Read(buffer, 0, 2) != 2)
throw new EndOfStreamException(); throw new EndOfStreamException();
if (BitConverter.IsLittleEndian) if (BitConverter.IsLittleEndian)
Array.Reverse(buffer, 0, 2); Array.Reverse(buffer, 0, 2);
return BitConverter.ToUInt16(buffer, 0); return BitConverter.ToUInt16(buffer, 0);
} }
public static short ReadInt16LE(this Stream stream) public static short ReadInt16LE(this Stream stream)
{ {
byte[] buffer = new byte[2]; byte[] buffer = new byte[2];
if (stream.Read(buffer, 0, 2) != 2) if (stream.Read(buffer, 0, 2) != 2)
throw new EndOfStreamException(); throw new EndOfStreamException();
if (!BitConverter.IsLittleEndian) if (!BitConverter.IsLittleEndian)
Array.Reverse(buffer, 0, 2); Array.Reverse(buffer, 0, 2);
return BitConverter.ToInt16(buffer, 0); return BitConverter.ToInt16(buffer, 0);
}
public static ushort ReadUInt16LE(this Stream stream)
{
byte[] buffer = new byte[2];
if (stream.Read(buffer, 0, 2) != 2)
throw new EndOfStreamException();
if (!BitConverter.IsLittleEndian)
Array.Reverse(buffer, 0, 2);
return BitConverter.ToUInt16(buffer, 0);
}
[DebuggerStepThrough]
public static uint ReadUInt32BE(this Stream stream)
{
byte[] buffer = new byte[4];
if (stream.Read(buffer, 0, 4) != 4)
throw new EndOfStreamException();
if (BitConverter.IsLittleEndian)
Array.Reverse(buffer, 0, 4);
return BitConverter.ToUInt32(buffer, 0);
}
[DebuggerStepThrough]
public static uint ReadUInt32LE(this Stream stream)
{
byte[] buffer = new byte[4];
if (stream.Read(buffer, 0, 4) != 4)
throw new EndOfStreamException();
if (!BitConverter.IsLittleEndian)
Array.Reverse(buffer, 0, 4);
return BitConverter.ToUInt32(buffer, 0);
}
public static int ReadInt32LE(this Stream stream)
{
byte[] buffer = new byte[4];
if (stream.Read(buffer, 0, 4) != 4)
throw new EndOfStreamException();
if (!BitConverter.IsLittleEndian)
Array.Reverse(buffer, 0, 4);
return BitConverter.ToInt32(buffer, 0);
}
public static ulong ReadUInt48BE(this Stream stream)
{
ulong result = 0;
result = ReadUInt16BE(stream);
result <<= 32;
result += ReadUInt32BE(stream);
return result;
}
public static long ReadInt64LE(this Stream stream)
{
byte[] buffer = new byte[8];
if (stream.Read(buffer, 0, 8) != 8)
throw new EndOfStreamException();
if (!BitConverter.IsLittleEndian)
Array.Reverse(buffer, 0, 4);
return BitConverter.ToInt64(buffer, 0);
}
public static ulong ReadUInt64LE(this Stream stream)
{
byte[] buffer = new byte[8];
if (stream.Read(buffer, 0, 8) != 8)
throw new EndOfStreamException();
if (!BitConverter.IsLittleEndian)
Array.Reverse(buffer, 0, 4);
return BitConverter.ToUInt64(buffer, 0);
}
public static ulong ReadUInt64BE(this Stream stream)
{
byte[] buffer = new byte[8];
if (stream.Read(buffer, 0, 8) != 8)
throw new EndOfStreamException();
if (BitConverter.IsLittleEndian)
Array.Reverse(buffer, 0, 4);
return BitConverter.ToUInt64(buffer, 0);
}
[DebuggerStepThrough]
public static byte[] ReadBytes(this Stream stream, long length)
{
if (length > Int32.MaxValue)
throw new ArgumentOutOfRangeException();
if (length == 0)
return new byte[0];
if (length < 0)
throw new ArgumentOutOfRangeException();
int length32 = (int)length;
byte[] buffer = new byte[length32];
if (stream.Read(buffer, 0, length32) != length32)
throw new EndOfStreamException();
return buffer;
}
[DebuggerStepThrough]
public static sbyte[] ReadSBytes(this Stream stream, long length)
{
if (length > Int32.MaxValue)
throw new ArgumentOutOfRangeException();
if (length == 0)
return new sbyte[0];
if (length < 0)
throw new ArgumentOutOfRangeException();
int length32 = (int)length;
sbyte[] buffer = new sbyte[length32];
for (int i = 0; i < length32; i++)
{
buffer[i] = (sbyte)stream.ReadUInt8();
}
return buffer;
}
[DebuggerStepThrough]
public static byte ReadUInt8(this Stream stream)
{
byte[] buffer = new byte[1];
if (stream.Read(buffer, 0, 1) != 1)
throw new EndOfStreamException();
return buffer[0];
}
[DebuggerStepThrough]
public static long GetAvailableBytes(this Stream stream)
{
if (stream is GZipStream)
{
GZipStream gzip = (GZipStream)stream;
long baseStreamPosition = gzip.BaseStream.Length - gzip.BaseStream.Position;
return baseStreamPosition;
}
return stream.Length - stream.Position;
}
public static void WriteUInt8Repeat(this Stream stream, byte uint8, int repetitions)
{
byte[] buffer = new byte[repetitions];
Array.Fill(buffer, uint8);
stream.Write(buffer, 0, repetitions);
}
public static uint ReadUInt24BE(this Stream stream)
{
uint result = stream.ReadUInt16BE();
result <<= 8;
result += stream.ReadUInt8();
return result;
}
public static double ReadDoubleLE(this Stream stream)
{
byte[] buffer = new byte[8];
if (stream.Read(buffer, 0, 8) != 8)
throw new EndOfStreamException();
if (!BitConverter.IsLittleEndian)
Array.Reverse(buffer, 0, 8);
return BitConverter.ToDouble(buffer, 0);
} }
public static ushort ReadUInt16LE(this Stream stream) public static double ReadDoubleBE(this Stream stream)
{
byte[] buffer = new byte[2];
if (stream.Read(buffer, 0, 2) != 2)
throw new EndOfStreamException();
if (!BitConverter.IsLittleEndian)
Array.Reverse(buffer, 0, 2);
return BitConverter.ToUInt16(buffer, 0);
}
[DebuggerStepThrough]
public static uint ReadUInt32BE(this Stream stream)
{
byte[] buffer = new byte[4];
if (stream.Read(buffer, 0, 4) != 4)
throw new EndOfStreamException();
if (BitConverter.IsLittleEndian)
Array.Reverse(buffer, 0, 4);
return BitConverter.ToUInt32(buffer, 0);
}
[DebuggerStepThrough]
public static uint ReadUInt32LE(this Stream stream)
{
byte[] buffer = new byte[4];
if (stream.Read(buffer, 0, 4) != 4)
throw new EndOfStreamException();
if (!BitConverter.IsLittleEndian)
Array.Reverse(buffer, 0, 4);
return BitConverter.ToUInt32(buffer, 0);
}
public static int ReadInt32LE(this Stream stream)
{
byte[] buffer = new byte[4];
if (stream.Read(buffer, 0, 4) != 4)
throw new EndOfStreamException();
if (!BitConverter.IsLittleEndian)
Array.Reverse(buffer, 0, 4);
return BitConverter.ToInt32(buffer, 0);
}
public static ulong ReadUInt48BE(this Stream stream)
{
ulong result = 0;
result = ReadUInt16BE(stream);
result <<= 32;
result += ReadUInt32BE(stream);
return result;
}
public static long ReadInt64LE(this Stream stream)
{
byte[] buffer = new byte[8];
if (stream.Read(buffer, 0, 8) != 8)
throw new EndOfStreamException();
if (!BitConverter.IsLittleEndian)
Array.Reverse(buffer, 0, 4);
return BitConverter.ToInt64(buffer, 0);
}
public static ulong ReadUInt64LE(this Stream stream)
{
byte[] buffer = new byte[8];
if (stream.Read(buffer, 0, 8) != 8)
throw new EndOfStreamException();
if (!BitConverter.IsLittleEndian)
Array.Reverse(buffer, 0, 4);
return BitConverter.ToUInt64(buffer, 0);
}
public static ulong ReadUInt64BE(this Stream stream)
{
byte[] buffer = new byte[8];
if (stream.Read(buffer, 0, 8) != 8)
throw new EndOfStreamException();
if (BitConverter.IsLittleEndian)
Array.Reverse(buffer, 0, 4);
return BitConverter.ToUInt64(buffer, 0);
}
[DebuggerStepThrough]
public static byte[] ReadBytes(this Stream stream, long length)
{
if (length > Int32.MaxValue)
throw new ArgumentOutOfRangeException();
if (length == 0)
return new byte[0];
if (length < 0)
throw new ArgumentOutOfRangeException();
int length32 = (int)length;
byte[] buffer = new byte[length32];
if (stream.Read(buffer, 0, length32) != length32)
throw new EndOfStreamException();
return buffer;
}
[DebuggerStepThrough]
public static sbyte[] ReadSBytes(this Stream stream, long length)
{
if (length > Int32.MaxValue)
throw new ArgumentOutOfRangeException();
if (length == 0)
return new sbyte[0];
if (length < 0)
throw new ArgumentOutOfRangeException();
int length32 = (int)length;
sbyte[] buffer = new sbyte[length32];
for (int i = 0; i < length32; i++)
{
buffer[i] = (sbyte)stream.ReadUInt8();
}
return buffer;
}
[DebuggerStepThrough]
public static byte ReadUInt8(this Stream stream)
{
byte[] buffer = new byte[1];
if (stream.Read(buffer, 0, 1) != 1)
throw new EndOfStreamException();
return buffer[0];
}
[DebuggerStepThrough]
public static long GetAvailableBytes(this Stream stream)
{
if (stream is GZipStream)
{
GZipStream gzip = (GZipStream)stream;
long baseStreamPosition = gzip.BaseStream.Length - gzip.BaseStream.Position;
return baseStreamPosition;
}
return stream.Length - stream.Position;
}
public static void WriteUInt8Repeat(this Stream stream, byte uint8, int repetitions)
{
byte[] buffer = new byte[repetitions];
Array.Fill(buffer, uint8);
stream.Write(buffer, 0, repetitions);
}
public static uint ReadUInt24BE(this Stream stream)
{
uint result = stream.ReadUInt16BE();
result <<= 8;
result += stream.ReadUInt8();
return result;
}
public static double ReadDoubleLE(this Stream stream)
{
byte[] buffer = new byte[8];
if (stream.Read(buffer, 0, 8) != 8)
throw new EndOfStreamException();
if (!BitConverter.IsLittleEndian)
Array.Reverse(buffer, 0, 8);
return BitConverter.ToDouble(buffer, 0);
}
public static void WriteUInt8(this Stream stream, byte value)
{
byte[] buffer = new byte[1];
buffer[0] = value;
stream.Write(buffer, 0, 1);
}
public static void WriteUInt16BE(this Stream stream, ushort value)
{
byte[] buffer = BitConverter.GetBytes(value);
if (BitConverter.IsLittleEndian)
(buffer[0], buffer[1]) = (buffer[1], buffer[0]);
stream.Write(buffer, 0, 2);
}
public static void WriteUInt16LE(this Stream stream, ushort value)
{
byte[] buffer = BitConverter.GetBytes(value);
if (!BitConverter.IsLittleEndian)
(buffer[0], buffer[1]) = (buffer[1], buffer[0]);
stream.Write(buffer, 0, 2);
}
public static void WriteInt32BE(this Stream stream, int value)
{
byte[] buffer = BitConverter.GetBytes(value);
if (BitConverter.IsLittleEndian)
(buffer[0], buffer[1], buffer[2], buffer[3]) = (buffer[3], buffer[2], buffer[1], buffer[0]);
stream.Write(buffer, 0, 4);
}
public static void WriteUInt32BE(this Stream stream, uint value)
{
byte[] buffer = BitConverter.GetBytes(value);
if (BitConverter.IsLittleEndian)
(buffer[0], buffer[1], buffer[2], buffer[3]) = (buffer[3], buffer[2], buffer[1], buffer[0]);
stream.Write(buffer, 0, 4);
}
public static void WriteUInt32LE(this Stream stream, uint value)
{
byte[] buffer = BitConverter.GetBytes(value);
if (!BitConverter.IsLittleEndian)
(buffer[0], buffer[1], buffer[2], buffer[3]) = (buffer[3], buffer[2], buffer[1], buffer[0]);
stream.Write(buffer, 0, 4);
}
public static void WriteInt32LE(this Stream stream, int value)
{
byte[] buffer = BitConverter.GetBytes(value);
if (!BitConverter.IsLittleEndian)
(buffer[0], buffer[1], buffer[2], buffer[3]) = (buffer[3], buffer[2], buffer[1], buffer[0]);
stream.Write(buffer, 0, 4);
}
public static void WriteInt64LE(this Stream stream, long value)
{
byte[] buffer = BitConverter.GetBytes(value);
if (!BitConverter.IsLittleEndian)
(buffer[0], buffer[1], buffer[2], buffer[3], buffer[4], buffer[5], buffer[6], buffer[7]) = (buffer[7], buffer[6], buffer[5], buffer[4], buffer[3], buffer[2], buffer[1], buffer[0]);
stream.Write(buffer, 0, 8);
}
public static string ReadUTF8FixedLength(this Stream stream, int length)
{
byte[] buffer = new byte[length];
if (stream.Read(buffer, 0, length) != length)
throw new EndOfStreamException();
return Encoding.UTF8.GetString(buffer);
}
public static string ReadUTF16NullTerminated(this Stream stream)
{
StringBuilder sb = new StringBuilder();
do
{
char c = (char)stream.ReadUInt16LE();
if (c == 0)
return sb.ToString();
sb.Append(c);
} while (stream.Position != stream.Length);
return sb.ToString();
}
[DebuggerStepThrough]
public static string ReadAsciiNullTerminated(this Stream stream)
{
StringBuilder sb = new StringBuilder();
do
{
char c = (char)stream.ReadUInt8();
if (c == 0)
return sb.ToString();
sb.Append(c);
} while(stream.Position != stream.Length);
return sb.ToString();
}
/// <summary>
/// Writes a variable-length integer to the stream.
/// (code generated by ChatGPT, model GPT-4o)
/// </summary>
public static void WriteVarInt(this Stream stream, long value)
{
while ((value & ~0x7F) != 0) // More than 7 bits left?
{
stream.WriteByte((byte)((value & 0x7F) | 0x80)); // Write 7 bits + set highest bit
value >>= 7; // Shift right by 7 bits
}
stream.WriteByte((byte)value); // Write last byte (highest bit unset)
}
/// <summary>
/// Reads a variable-length integer from the stream.
/// (code generated by ChatGPT, model GPT-4o)
/// </summary>
public static int ReadVarInt(this Stream stream)
{
int result = 0;
int shift = 0;
byte currentByte;
do
{
currentByte = (byte)stream.ReadByte();
result |= (currentByte & 0x7F) << shift; // Extract 7 bits and shift
shift += 7;
}
while ((currentByte & 0x80) != 0); // Continue while highest bit is set
return result;
}
public static double ReadFloat64LE(this Stream stream)
{
byte[] buffer = new byte[8];
if (stream.Read(buffer, 0, 8) != 8)
throw new EndOfStreamException();
if (!BitConverter.IsLittleEndian)
Array.Reverse(buffer);
return BitConverter.ToDouble(buffer, 0);
}
public static void WriteFloat64LE(this Stream stream, double value)
{
byte[] buffer = BitConverter.GetBytes(value);
if (!BitConverter.IsLittleEndian)
Array.Reverse(buffer);
stream.Write(buffer, 0, 8);
}
public static byte Peek(this Stream stream)
{
if (!stream.CanSeek)
throw new NotSupportedException("Stream is not peekable");
if (stream.Position == stream.Length)
throw new EndOfStreamException();
byte readUInt8 = stream.ReadUInt8();
stream.Position--;
return readUInt8;
}
public static void DumpToFile(this Stream stream, string filename)
{
FileStream fileStream = File.OpenWrite(filename);
stream.CopyTo(fileStream);
fileStream.Flush(true);
fileStream.Close();
fileStream.Dispose();
}
public static int TryReadExactly(this Stream stream, byte[] buffer, int offset, int count)
{
int totalRead = 0;
while (totalRead < count)
{
int bytesRead = stream.Read(buffer, offset + totalRead, count - totalRead);
if (bytesRead == 0)
{
// End of stream
break;
}
totalRead += bytesRead;
}
return totalRead;
}
public static void WriteDoubleBE(this Stream stream, double value)
{
byte[] buffer = BitConverter.GetBytes(value);
if (BitConverter.IsLittleEndian)
Array.Reverse(buffer);
stream.Write(buffer, 0, 8);
}
public static double ReadDoubleBE(this Stream stream)
{ {
byte[] buffer = new byte[8]; byte[] buffer = new byte[8];
if (stream.Read(buffer, 0, 8) != 8) if (stream.Read(buffer, 0, 8) != 8)
throw new EndOfStreamException("failed to read double"); throw new EndOfStreamException();
if (BitConverter.IsLittleEndian) if (BitConverter.IsLittleEndian)
Array.Reverse(buffer); Array.Reverse(buffer, 0, 8);
return BitConverter.ToDouble(buffer, 0); return BitConverter.ToDouble(buffer, 0);
} }
public static void WriteFloatBE(this Stream stream, float value) public static void WriteUInt8(this Stream stream, byte value)
{ {
byte[] buffer = BitConverter.GetBytes(value); byte[] buffer = new byte[1];
if (BitConverter.IsLittleEndian) buffer[0] = value;
Array.Reverse(buffer); stream.Write(buffer, 0, 1);
stream.Write(buffer, 0, 4); }
}
public static void WriteUInt16BE(this Stream stream, ushort value)
public static float ReadFloatBE(this NetworkStream stream) {
{ byte[] buffer = BitConverter.GetBytes(value);
byte[] buffer = new byte[4]; if (BitConverter.IsLittleEndian)
if (stream.Read(buffer, 0, 4) != 4) (buffer[0], buffer[1]) = (buffer[1], buffer[0]);
throw new EndOfStreamException("failed to read float"); stream.Write(buffer, 0, 2);
if (BitConverter.IsLittleEndian) }
Array.Reverse(buffer); public static void WriteUInt16LE(this Stream stream, ushort value)
return BitConverter.ToSingle(buffer, 0); {
} byte[] buffer = BitConverter.GetBytes(value);
} if (!BitConverter.IsLittleEndian)
} (buffer[0], buffer[1]) = (buffer[1], buffer[0]);
stream.Write(buffer, 0, 2);
}
public static void WriteInt32BE(this Stream stream, int value)
{
byte[] buffer = BitConverter.GetBytes(value);
if (BitConverter.IsLittleEndian)
(buffer[0], buffer[1], buffer[2], buffer[3]) = (buffer[3], buffer[2], buffer[1], buffer[0]);
stream.Write(buffer, 0, 4);
}
public static void WriteUInt32BE(this Stream stream, uint value)
{
byte[] buffer = BitConverter.GetBytes(value);
if (BitConverter.IsLittleEndian)
(buffer[0], buffer[1], buffer[2], buffer[3]) = (buffer[3], buffer[2], buffer[1], buffer[0]);
stream.Write(buffer, 0, 4);
}
public static void WriteUInt32LE(this Stream stream, uint value)
{
byte[] buffer = BitConverter.GetBytes(value);
if (!BitConverter.IsLittleEndian)
(buffer[0], buffer[1], buffer[2], buffer[3]) = (buffer[3], buffer[2], buffer[1], buffer[0]);
stream.Write(buffer, 0, 4);
}
public static void WriteInt32LE(this Stream stream, int value)
{
byte[] buffer = BitConverter.GetBytes(value);
if (!BitConverter.IsLittleEndian)
(buffer[0], buffer[1], buffer[2], buffer[3]) = (buffer[3], buffer[2], buffer[1], buffer[0]);
stream.Write(buffer, 0, 4);
}
public static void WriteInt64LE(this Stream stream, long value)
{
byte[] buffer = BitConverter.GetBytes(value);
if (!BitConverter.IsLittleEndian)
(buffer[0], buffer[1], buffer[2], buffer[3], buffer[4], buffer[5], buffer[6], buffer[7]) = (buffer[7], buffer[6], buffer[5], buffer[4], buffer[3], buffer[2], buffer[1], buffer[0]);
stream.Write(buffer, 0, 8);
}
public static string ReadUTF8FixedLength(this Stream stream, int length)
{
byte[] buffer = new byte[length];
if (stream.Read(buffer, 0, length) != length)
throw new EndOfStreamException();
return Encoding.UTF8.GetString(buffer);
}
public static string ReadUTF16NullTerminated(this Stream stream)
{
StringBuilder sb = new StringBuilder();
do
{
char c = (char)stream.ReadUInt16LE();
if (c == 0)
return sb.ToString();
sb.Append(c);
} while (stream.Position != stream.Length);
return sb.ToString();
}
[DebuggerStepThrough]
public static string ReadAsciiNullTerminated(this Stream stream)
{
StringBuilder sb = new StringBuilder();
do
{
char c = (char)stream.ReadUInt8();
if (c == 0)
return sb.ToString();
sb.Append(c);
} while(stream.Position != stream.Length);
return sb.ToString();
}
/// <summary>
/// Writes a variable-length integer to the stream.
/// (code generated by ChatGPT, model GPT-4o)
/// </summary>
public static void WriteVarInt(this Stream stream, long value)
{
while ((value & ~0x7F) != 0) // More than 7 bits left?
{
stream.WriteByte((byte)((value & 0x7F) | 0x80)); // Write 7 bits + set highest bit
value >>= 7; // Shift right by 7 bits
}
stream.WriteByte((byte)value); // Write last byte (highest bit unset)
}
/// <summary>
/// Reads a variable-length integer from the stream.
/// (code generated by ChatGPT, model GPT-4o)
/// </summary>
public static int ReadVarInt(this Stream stream)
{
int result = 0;
int shift = 0;
byte currentByte;
do
{
currentByte = (byte)stream.ReadByte();
result |= (currentByte & 0x7F) << shift; // Extract 7 bits and shift
shift += 7;
}
while ((currentByte & 0x80) != 0); // Continue while highest bit is set
return result;
}
public static double ReadFloat64LE(this Stream stream)
{
byte[] buffer = new byte[8];
if (stream.Read(buffer, 0, 8) != 8)
throw new EndOfStreamException();
if (!BitConverter.IsLittleEndian)
Array.Reverse(buffer);
return BitConverter.ToDouble(buffer, 0);
}
public static void WriteFloat64LE(this Stream stream, double value)
{
byte[] buffer = BitConverter.GetBytes(value);
if (!BitConverter.IsLittleEndian)
Array.Reverse(buffer);
stream.Write(buffer, 0, 8);
}
public static byte Peek(this Stream stream)
{
if (!stream.CanSeek)
throw new NotSupportedException("Stream is not peekable");
if (stream.Position == stream.Length)
throw new EndOfStreamException();
byte readUInt8 = stream.ReadUInt8();
stream.Position--;
return readUInt8;
}
public static void DumpToFile(this Stream stream, string filename)
{
FileStream fileStream = File.OpenWrite(filename);
stream.CopyTo(fileStream);
fileStream.Flush(true);
fileStream.Close();
fileStream.Dispose();
}
public static int TryReadExactly(this Stream stream, byte[] buffer, int offset, int count)
{
int totalRead = 0;
while (totalRead < count)
{
int bytesRead = stream.Read(buffer, offset + totalRead, count - totalRead);
if (bytesRead == 0)
{
// End of stream
break;
}
totalRead += bytesRead;
}
return totalRead;
}
}
}

36
skyscraper8/Skyscraper/Net/Sockets/NetworkStreamExtensions.cs
View File

@ -152,7 +152,41 @@ namespace skyscraper5.Skyscraper.Net.Sockets
return buffer[0]; return buffer[0];
} }
public static void WriteDoubleBE(this NetworkStream stream, double value)
{
byte[] buffer = BitConverter.GetBytes(value);
if (BitConverter.IsLittleEndian)
Array.Reverse(buffer);
stream.Write(buffer, 0, 8);
}
public static double ReadDoubleBE(this NetworkStream stream)
{
byte[] buffer = new byte[8];
if (stream.Read(buffer,0,8) != 8)
throw new EndOfStreamException("failed to read double");
if (BitConverter.IsLittleEndian)
Array.Reverse(buffer);
return BitConverter.ToDouble(buffer, 0);
}
public static void WriteFloatBE(this NetworkStream stream, float value)
{
byte[] buffer = BitConverter.GetBytes(value);
if (BitConverter.IsLittleEndian)
Array.Reverse(buffer);
stream.Write(buffer, 0, 4);
}
public static float ReadFloatBE(this NetworkStream stream)
{
byte[] buffer = new byte[4];
if (stream.Read(buffer, 0, 4) != 4)
throw new EndOfStreamException("failed to read float");
if (BitConverter.IsLittleEndian)
Array.Reverse(buffer);
return BitConverter.ToSingle(buffer, 0);
}
public static void WriteIntPtr(this NetworkStream stream, IntPtr ptr) public static void WriteIntPtr(this NetworkStream stream, IntPtr ptr)
{ {