public void Load(PrimitiveReader reader)
{
// checking magic
var magic = reader.ReadUInt32();
if (magic != Magic)
{
throw new InvalidOperationException("Memory: Cannot resume state from stream: Invalid magic.");
}
SegmentSize = reader.ReadInt32();
size = reader.ReadInt64();
if (emptyCtorUsed)
{
Init();
}
var realSegmentsCount = 0;
for (var i = 0; i < segments.Length; i++)
{
var isTouched = reader.ReadBoolean();
if (!isTouched)
{
continue;
}
var compressedSegmentSize = reader.ReadInt32();
var compressedBuffer = reader.ReadBytes(compressedSegmentSize);
TouchSegment(i);
realSegmentsCount++;
var decodedBuffer = LZ4Codec.Decode(compressedBuffer, 0, compressedBuffer.Length, SegmentSize);
Marshal.Copy(decodedBuffer, 0, segments[i], decodedBuffer.Length);
}
this.NoisyLog(string.Format("{0} segments loaded from stream, of which {1} had content.", segments.Length, realSegmentsCount));
}
public void Load(PrimitiveReader reader)
{
Id = reader.ReadUInt64();
Message = reader.ReadString();
SourceId = reader.ReadInt32();
ThreadId = reader.ReadInt32();
Time = new DateTime(reader.ReadInt64());
numericLogLevel = reader.ReadInt32();
if(ThreadId == -1)
{
ThreadId = null;
}
}
public async ValueTask Read(PrimitiveReader primitiveReader, CancellationToken cancellationToken)
{
BoolValue = await primitiveReader.ReadBool(cancellationToken);
ByteValue = await primitiveReader.ReadByte(cancellationToken);
SByteValue = await primitiveReader.ReadSByte(cancellationToken);
ShortValue = await primitiveReader.ReadInt16(cancellationToken);
UShortValue = await primitiveReader.ReadUInt16(cancellationToken);
IntValue = await primitiveReader.ReadInt32(cancellationToken);
UIntValue = await primitiveReader.ReadUInt32(cancellationToken);
LongValue = await primitiveReader.ReadInt64(cancellationToken);
ULongValue = await primitiveReader.ReadUInt64(cancellationToken);
FloatValue = await primitiveReader.ReadSingle(cancellationToken);
DoubleValue = await primitiveReader.ReadDouble(cancellationToken);
StringValue = await primitiveReader.ReadString(cancellationToken);
deserializationCounter++;
}
public void ShouldWriteAndReadInts(
[Values(1, 10, 100, 10000, 1000 * 1000)]
int numberOfInts)
{
var randomInts = Helpers.GetRandomIntegers(numberOfInts);
var stream = new MemoryStream();
using (var writer = new PrimitiveWriter(stream))
{
for (var i = 0; i < randomInts.Length; i++)
{
writer.Write(randomInts[i]);
}
}
var position = stream.Position;
stream.Seek(0, SeekOrigin.Begin);
using (var reader = new PrimitiveReader(stream))
{
for (var i = 0; i < randomInts.Length; i++)
{
Assert.AreEqual(randomInts[i], reader.ReadInt32());
}
}
Assert.AreEqual(position, stream.Position, StreamCorruptedMessage);
}
public void ShouldWriteAndReadInts(
[Values(1, 10, 100, 10000, 1000*1000)]
int numberOfInts)
{
var randomInts = Helpers.GetRandomIntegers(numberOfInts);
var stream = new MemoryStream();
using(var writer = new PrimitiveWriter(stream, buffered))
{
for(var i = 0; i < randomInts.Length; i++)
{
writer.Write(randomInts[i]);
}
}
var position = stream.Position;
stream.Seek(0, SeekOrigin.Begin);
using(var reader = new PrimitiveReader(stream, buffered))
{
for(var i = 0; i < randomInts.Length; i++)
{
Assert.AreEqual(randomInts[i], reader.ReadInt32());
}
}
Assert.AreEqual(position, stream.Position, StreamCorruptedMessage);
}
public void ShouldHandleNotAlignedWrites()
{
const int iterationCount = 80000;
var stream = new MemoryStream();
using (var writer = new PrimitiveWriter(stream))
{
writer.Write((byte)1);
for (var i = 0; i < iterationCount; i++)
{
writer.Write(int.MaxValue);
}
}
var position = stream.Position;
stream.Seek(0, SeekOrigin.Begin);
using (var reader = new PrimitiveReader(stream))
{
Assert.AreEqual((byte)1, reader.ReadByte());
for (var i = 0; i < iterationCount; i++)
{
Assert.AreEqual(int.MaxValue, reader.ReadInt32());
}
}
Assert.AreEqual(position, stream.Position, StreamCorruptedMessage);
}
public void ShouldReadAndWriteLimits()
{
var stream = new MemoryStream();
using (var writer = new PrimitiveWriter(stream))
{
writer.Write(byte.MinValue);
writer.Write(byte.MaxValue);
writer.Write(sbyte.MinValue);
writer.Write(sbyte.MaxValue);
writer.Write(short.MinValue);
writer.Write(short.MaxValue);
writer.Write(ushort.MinValue);
writer.Write(ushort.MaxValue);
writer.Write(int.MinValue);
writer.Write(int.MaxValue);
writer.Write(uint.MinValue);
writer.Write(uint.MaxValue);
writer.Write(long.MinValue);
writer.Write(long.MaxValue);
writer.Write(ulong.MinValue);
writer.Write(ulong.MaxValue);
}
var position = stream.Position;
stream.Seek(0, SeekOrigin.Begin);
using (var reader = new PrimitiveReader(stream))
{
Assert.AreEqual(byte.MinValue, reader.ReadByte());
Assert.AreEqual(byte.MaxValue, reader.ReadByte());
Assert.AreEqual(sbyte.MinValue, reader.ReadSByte());
Assert.AreEqual(sbyte.MaxValue, reader.ReadSByte());
Assert.AreEqual(short.MinValue, reader.ReadInt16());
Assert.AreEqual(short.MaxValue, reader.ReadInt16());
Assert.AreEqual(ushort.MinValue, reader.ReadUInt16());
Assert.AreEqual(ushort.MaxValue, reader.ReadUInt16());
Assert.AreEqual(int.MinValue, reader.ReadInt32());
Assert.AreEqual(int.MaxValue, reader.ReadInt32());
Assert.AreEqual(uint.MinValue, reader.ReadUInt32());
Assert.AreEqual(uint.MaxValue, reader.ReadUInt32());
Assert.AreEqual(long.MinValue, reader.ReadInt64());
Assert.AreEqual(long.MaxValue, reader.ReadInt64());
Assert.AreEqual(ulong.MinValue, reader.ReadUInt64());
Assert.AreEqual(ulong.MaxValue, reader.ReadUInt64());
}
Assert.AreEqual(position, stream.Position, StreamCorruptedMessage);
}
public static Version ReadVersion(this PrimitiveReader @this)
{
var major = @this.ReadInt32();
var minor = @this.ReadInt32();
var build = @this.ReadInt32();
var revision = @this.ReadInt32();
if (revision != -1)
{
return(new Version(major, minor, build, revision));
}
else if (build != -1)
{
return(new Version(major, minor, build));
}
return(new Version(major, minor));
}
public void Load(PrimitiveReader reader)
{
var length = reader.ReadInt32();
data = new IntPtr[length];
for (var i = 0; i < length; i++)
{
data[i] = new IntPtr(reader.ReadByte());
}
}
public IEnumerable<AudioChunk> StreamData( Stream source )
{
infoBuffer.Length = 0;
info = new AudioChunk();
PrimitiveReader reader = new PrimitiveReader( source );
string signature = reader.ReadASCIIString( 4 );
if( signature != "FORM" )
throw new InvalidDataException( "Invalid initial signature." );
reader.BigEndian = true;
int formChunkSize = reader.ReadInt32();
AppendInfoLine( 0, "-- Begin info --" );
AppendInfoLine( 0, "{0} (Chunk size: {1} bytes, {2} KB, {3} MB)", signature,
formChunkSize, formChunkSize / 1024, formChunkSize / 1024 / 1024 );
string format = reader.ReadASCIIString( 4 );
switch( format ) {
case "AIFF":
break;
//http://www-mmsp.ece.mcgill.ca/Documents/AudioFormats/AIFF/Docs/AIFF-C.9.26.91.pdf
case "AIFC":
aifcFormat = true;
break;
default:
throw new InvalidDataException( "Invalid initial signature." );
}
AiffChunkHeader chunk;
while( true ) {
chunk = ReadChunkHeader( reader );
AppendInfoLine( 1, "{0} (Chunk size: {1})", chunk.Signature, chunk.DataSize );
if( chunk.Signature == "COMM" ) {
ProcessCommonChunk( chunk, reader );
} else if( chunk.Signature == "SSND" ) {
break;
} else {
SkipChunkData( reader, chunk.DataSize );
}
}
AppendInfoLine( 0, "-- End info --" );
fileinfo = infoBuffer.ToString();
return StreamDataCore( chunk, reader );
}
public override void ReadMetadata()
{
reader = new PrimitiveReader( stream );
string signature = reader.ReadASCIIString( 4 );
bool bigendian = false, reverseHeaders = false;
if( signature == "RIFF" ) {
} else if( signature == "RIFX" ) {
bigendian = true;
} else if( signature == "FFIR" ) {
bigendian = true;
reverseHeaders = true;
} else {
throw new InvalidDataException( "Invalid initial signature" );
}
reader.BigEndian = bigendian;
int riffChunkSize = reader.ReadInt32();
string format = reader.ReadASCIIString( 4 );
if( !( format == "WAVE" || format == "EVAW" ) )
throw new InvalidDataException( "Invalid format." );
// Although technically a wave chunk is supposed to consist of
// a 'fmt ' chunk followed by a 'data' chunk, this is not always the case.
RiffChunkHeader chunk;
while( true ) {
chunk = ReadChunkHeader( reader, reverseHeaders );
if( chunk.Signature == "fmt " ) {
ProcessFormatChunk( chunk, reader );
foundAudioInfo = true;
} else if( chunk.Signature == "data" ) {
if( !foundAudioInfo ) {
Logger.Log( LoggingType.CodecError, "Data chunk found before format chunk.",
"This usually indicates an improper encoder or a corrupted file." );
throw new InvalidOperationException( "Stream must be seekable when the data chunk is before the format chunk." );
}
break;
} else {
reader.SkipData( chunk.DataSize );
}
}
chunkDataSize = chunk.DataSize;
}
public void ShouldWriteAndReadNegativeInt()
{
var value = -Helpers.Random.Next();
var stream = new MemoryStream();
using (var writer = new PrimitiveWriter(stream))
{
writer.Write(value);
}
var position = stream.Position;
stream.Seek(0, SeekOrigin.Begin);
using (var reader = new PrimitiveReader(stream))
{
Assert.AreEqual(value, reader.ReadInt32());
}
Assert.AreEqual(position, stream.Position, StreamCorruptedMessage);
}
public void ShouldHandleNotAlignedWrites()
{
const int iterationCount = 80000;
var stream = new MemoryStream();
using(var writer = new PrimitiveWriter(stream))
{
writer.Write((byte)1);
for(var i = 0; i < iterationCount; i++)
{
writer.Write(int.MaxValue);
}
}
var position = stream.Position;
stream.Seek(0, SeekOrigin.Begin);
using(var reader = new PrimitiveReader(stream))
{
Assert.AreEqual((byte)1, reader.ReadByte());
for(var i = 0; i < iterationCount; i++)
{
Assert.AreEqual(int.MaxValue, reader.ReadInt32());
}
}
Assert.AreEqual(position, stream.Position, StreamCorruptedMessage);
}
void ProcessMetadataPicture( int len, PrimitiveReader reader )
{
uint type = reader.ReadUInt32();
PictureType pictureType = (PictureType)type;
int mimeTypeLength = reader.ReadInt32();
string mimeType = reader.ReadASCIIString( mimeTypeLength );
int descriptionLength = reader.ReadInt32();
string description = reader.ReadUTF8String( descriptionLength );
int width = reader.ReadInt32();
int height = reader.ReadInt32();
int colourDepth = reader.ReadInt32(); // Bits per pixel.
int indexedColoursUsed = reader.ReadInt32();
int picturelength = reader.ReadInt32();
byte[] data = reader.ReadBytes( picturelength );
}
void ProcessMetadataVorbisComment( int len, PrimitiveReader reader )
{
int bytesRead = 0;
reader.BigEndian = false;
while( bytesRead < len ) {
int vendorLength = reader.ReadInt32();
string vendor = reader.ReadUTF8String( vendorLength );
bytesRead += 4 + vendorLength;
uint commentsCount = reader.ReadUInt32();
bytesRead += 4;
for( uint i = 0; i < commentsCount; i++ ) {
int commentLength = reader.ReadInt32();
string comment = reader.ReadUTF8String( commentLength );
bytesRead += 4 + commentLength;
}
}
reader.BigEndian = true;
}
static AiffChunkHeader ReadChunkHeader( PrimitiveReader reader )
{
AiffChunkHeader chunk = new AiffChunkHeader();
chunk.Signature = reader.ReadASCIIString( 4 );
chunk.DataSize = reader.ReadInt32();
return chunk;
}
public void Load(PrimitiveReader reader)
{
reader.ReadInt32();
reader.ReadInt32();
}
IEnumerable<AudioChunk> StreamDataCore( AiffChunkHeader chunk, PrimitiveReader reader )
{
int offset = reader.ReadInt32();
int blockSize = reader.ReadInt32();
long length = (uint)chunk.DataSize - 8; // Signed number to unsigned number.
int bufferLength = bufferSize; // Approximately one second each.
while( length > 0 ) {
int currentBufferSize = (int)Math.Min( bufferLength, length );
byte[] data = reader.ReadBytes( currentBufferSize );
info.Data = transformer.Transform( data, actualBitsPerSample );
length -= bufferLength;
yield return info;
}
}
bool ReadV3Frame( PrimitiveReader reader, ref int len )
{
string frameId = reader.ReadASCIIString( 4 ); len -= 4;
if( frameId == "\0\0\0\0" ) return true;
int frameDataSize = reader.ReadInt32();
ushort frameFlags = reader.ReadUInt16(); len -= ( frameDataSize + 4 + 2 );
bool encryption = ( frameFlags & 0x80 ) != 0;
bool compression = ( frameFlags & 0x40 ) != 0;
bool groupingInfo = ( frameFlags & 0x20 ) != 0;
if( groupingInfo ) {
byte groupIdentifier = reader.ReadByte();
}
if( encryption || compression ) throw new NotImplementedException( "encryption and/or compression support is not yet implemented." );
Console.WriteLine( "reading frame: " + frameId );
if( v3TagConstructors == null ) {
v3TagConstructors = ID3v2Tag.Makev3TagConstructors();
}
Func<ID3v2Tag> constructor;
if( v3TagConstructors.TryGetValue( frameId, out constructor ) ) {
ID3v2Tag tag = constructor();
tag.Identifier = frameId;
tag.DataSize = frameDataSize;
tag.Read( container, reader );
} else {
Console.WriteLine( " skipping frame." );
reader.SkipData( frameDataSize );
}
return false;
}
void ProcessFormatChunk( RiffChunkHeader chunk, PrimitiveReader reader )
{
byte[] chunkData = reader.ReadBytes( chunk.DataSize );
Stream source = reader.stream;
reader.stream = new MemoryStream( chunkData );
int audioFormat = reader.ReadUInt16();
Metadata["WAVE audio format"] = ((AudioFormat)audioFormat).ToString();
int channels = reader.ReadInt16();
Metadata[MetadataKeys.Channels] = channels.ToString();
int sampleRate = reader.ReadInt32();
Metadata[MetadataKeys.SampleRate] = sampleRate.ToString();
int byteRate = reader.ReadInt32();
int blockAlign = reader.ReadInt16();
int bitsPerSample = reader.ReadInt16();
Metadata[MetadataKeys.BitsPerSample] = bitsPerSample.ToString();
int extraInfoSize = 0;
#pragma warning disable 0618
// Usually, only very old wave files don't have this
// field included. (WaveFormat structure, not WaveFormatEx structure)
// Supress the warning because it's a MemoryStream.
if( reader.Position != reader.Length ) {
extraInfoSize = reader.ReadUInt16();
}
#pragma warning restore 0618
this.freq = sampleRate;
transformer = EmptyTransformer.Instance;
this.channels = channels;
this.bitsPerSample = bitsPerSample;
codecBitsPerSample = bitsPerSample;
switch( (AudioFormat)audioFormat ) {
case AudioFormat.Pcm: // No compression.
if( bitsPerSample == 16 && reader.BigEndian ) {
transformer = BigEndian16BitTo16BitTransformer.Instance;
}
break;
case AudioFormat.IeeeFloat:
if( bitsPerSample == 32 ) {
this.bitsPerSample = 16;
} else if( bitsPerSample == 64 ) {
this.bitsPerSample = 16;
}
throw new NotSupportedException();
break;
case AudioFormat.ALaw:
transformer = ALawTransformer.Instance;
this.bitsPerSample = 16;
break;
case AudioFormat.MuLaw:
transformer = MuLawTransformer.Instance;
this.bitsPerSample = 16;
break;
// TODO: Properly test this transformer, but I can't seem to find any wave files that use this format.
case AudioFormat.DialogicOkiAdpcm:
transformer = DialogicAdpcmTransformer.Instance;
this.bitsPerSample = 16;
break;
// TODO: Test this transformer too.
case AudioFormat.ImaAdpcm:
transformer = ImaAdpcmTransformer.Instance;
this.bitsPerSample = 16;
break;
case AudioFormat.Extensible:
ushort validBitsPerSample = reader.ReadUInt16();
uint channelMask = reader.ReadUInt32();
Guid subFormat = reader.ReadGuid();
Metadata["extensible guid"] = subFormat.ToString();
if( subFormat == PcmGuid ) {
} else if( subFormat == IeeeFloatGuid ) {
throw new NotSupportedException( "Ieee float sub format not supported." );
} else if( subFormat == DrmGuid ) {
throw new NotSupportedException( "Drm sub format not supported." );
} else if( subFormat == AlawGuid ) {
transformer = ALawTransformer.Instance;
this.bitsPerSample = 16;
} else if( subFormat == MulawGuid ) {
transformer = MuLawTransformer.Instance;
this.bitsPerSample = 16;
} else if( subFormat == AdpcmGuid ) {
throw new NotSupportedException( "Adpcm sub format not supported." );
} else if( subFormat == MpegGuid ) {
throw new NotSupportedException( "Mpeg sub format not supported." );
} else {
throw new NotSupportedException( "Unsupported sub format: " + subFormat );
}
break;
default:
throw new NotSupportedException( "Unsupported audio format: " + (AudioFormat)audioFormat );
}
reader.stream = source;
}
public override void ReadMetadata()
{
reader = new PrimitiveReader( stream );
string signature = reader.ReadASCIIString( 4 );
if( signature != ".snd" ) {
throw new InvalidDataException( "Invalid initial signature." );
}
reader.BigEndian = true;
uint dataOffset = reader.ReadUInt32();
dataLength = reader.ReadUInt32();
if( dataLength == 0xFFFFFFFF ) {
dataLength = (uint)( reader.Length - dataOffset );
}
AuEncoding encoding = (AuEncoding)reader.ReadUInt32();
Metadata["AU encoding"] = encoding.ToString();
freq = reader.ReadInt32();
Metadata[MetadataKeys.SampleRate] = freq.ToString();
channels = reader.ReadInt32();
Metadata[MetadataKeys.Channels] = channels.ToString();
if( dataOffset > 24 ) {
int infoLength = (int)( dataOffset - 24 );
string info = reader.ReadASCIIString( infoLength );
Metadata["File comment"] = info;
}
transformer = EmptyTransformer.Instance;
switch( encoding ) {
case AuEncoding.Int8G711uLaw:
transformer = MuLawTransformer.Instance;
bitsPerSample = 16; codecBitsPerSample = 8;
break;
case AuEncoding.Int8LinearPcm:
bitsPerSample = codecBitsPerSample = 8;
break;
case AuEncoding.Int16LinearPcm:
bitsPerSample = codecBitsPerSample = 16;
transformer = BigEndian16BitTo16BitTransformer.Instance;
break;
case AuEncoding.Int24LinearPcm:
bitsPerSample = 16; codecBitsPerSample = 24;
transformer = BigEndian24BitTo16BitTransformer.Instance;
break;
case AuEncoding.Int32LinearPcm:
bitsPerSample = 16; codecBitsPerSample = 32;
transformer = BigEndian32BitTo16BitTransformer.Instance;
break;
case AuEncoding.Float32LinearPcm:
bitsPerSample = 16; codecBitsPerSample = 32;
transformer = BigEndianFloat32To16BitTransformer.Instance;
break;
case AuEncoding.Float64LinearPcm:
bitsPerSample = 16; codecBitsPerSample = 64;
transformer = BigEndianFloat64To16BitTransformer.Instance;
break;
case AuEncoding.Int8G711ALaw:
transformer = ALawTransformer.Instance;
bitsPerSample = 16; codecBitsPerSample = 8;
break;
default:
throw new NotSupportedException( "Unsupported audio format: " + encoding );
}
Metadata[MetadataKeys.BitsPerSample] = bitsPerSample.ToString();
}
public void ReadData(string path)
{
PrimitiveReader reader = new PrimitiveReader(path);
SaveGameFile file = new SaveGameFile();
file.Version = reader.ReadASCIIString(8);
file.Unknown1 = reader.ReadFloat32();
bool aiDataIncluded = reader.ReadUInt32() != 0;
if (aiDataIncluded)
{
file.AiInfo2 = AiInfo.ReadFrom(reader);
}
file.Unknown2 = reader.ReadUInt32();
file.GameSpeed1 = reader.ReadUInt32();
file.Unknown3 = reader.ReadUInt32();
file.GameSpeed2 = reader.ReadUInt32();
file.Unknown4 = reader.ReadFloat32();
file.Unknown5 = reader.ReadUInt32();
file.Unknown6 = reader.ReadBytes(17);
file.RecordedGamePlayerNumber = reader.ReadUInt16();
//System.Diagnostics.Debugger.Break();
file.PlayersCount = reader.ReadUInt8();
file.Unknown7 = reader.ReadUInt32();
file.Unknown8 = reader.ReadBytes(12);
file.Unknown9 = reader.ReadBytes(14);
file.Unknown10 = reader.ReadUInt32Array(8);
//System.Diagnostics.Debugger.Break();
reader.SeekAbsolute(126);
int mapWidth = reader.ReadInt32();
int mapLength = reader.ReadInt32();
uint unknownDataCount = reader.ReadUInt32();
ushort unknown2 = reader.ReadUInt16();
SaveGameMap map = SaveGameMap.ReadFrom(reader, mapWidth, mapLength);
/*int unknownIntsArrayCount = reader.ReadInt32();
* uint[][] unknowns = new uint[unknownIntsArrayCount][];
* for( int i = 0; i < unknowns.Length; i++ ) {
* int intsCount = reader.ReadInt32() - 1;
* if( intsCount < 0 ) throw new Exception();
* unknowns[i] = reader.ReadUInt32Array( intsCount );
* }*/
reader.SeekAbsolute(29132);
int mapWidth2 = reader.ReadInt32();
int mapLength2 = reader.ReadInt32();
uint[] unknownMap2 = reader.ReadUInt32Array(mapWidth2 * mapLength2);
//byte unknownIntsCount1 = reader.ReadUInt8();
//uint[] unknownInts = reader.ReadUInt32Array( unknownIntsCount1 );
reader.SeekAbsolute(88779);
SavePlayerInfo f = SavePlayerInfo.ReadFrom(reader, 2);
System.Diagnostics.Debugger.Break();
}
void ReadV3ExtendedHeader( PrimitiveReader reader, ref int len )
{
int extendedDataSize = reader.ReadInt32(); len -= ( 4 + extendedDataSize );
ushort extendedFlags = reader.ReadUInt16();
int paddingSize = reader.ReadInt32();
extendedDataSize -= 6;
if( ( extendedFlags & 0x8000 ) != 0 ) {
uint crc32 = reader.ReadUInt32();
extendedDataSize -= 4;
}
reader.SkipData( extendedDataSize );
}
public void ShouldWriteAndReadNegativeInt()
{
var value = -Helpers.Random.Next();
var stream = new MemoryStream();
using(var writer = new PrimitiveWriter(stream))
{
writer.Write(value);
}
var position = stream.Position;
stream.Seek(0, SeekOrigin.Begin);
using(var reader = new PrimitiveReader(stream))
{
Assert.AreEqual(value, reader.ReadInt32());
}
Assert.AreEqual(position, stream.Position, StreamCorruptedMessage);
}
static RiffChunkHeader ReadChunkHeader( PrimitiveReader reader, bool reverseHeaders )
{
byte[] sig = reader.ReadBytes( 4 );
if( reverseHeaders ) {
sig = new byte[] { sig[3], sig[2], sig[1], sig[0] };
}
RiffChunkHeader chunk = new RiffChunkHeader();
chunk.Signature = Encoding.ASCII.GetString( sig );
chunk.DataSize = reader.ReadInt32();
return chunk;
}
public void ShouldReadAndWriteLimits()
{
var stream = new MemoryStream();
using(var writer = new PrimitiveWriter(stream))
{
writer.Write(byte.MinValue);
writer.Write(byte.MaxValue);
writer.Write(sbyte.MinValue);
writer.Write(sbyte.MaxValue);
writer.Write(short.MinValue);
writer.Write(short.MaxValue);
writer.Write(ushort.MinValue);
writer.Write(ushort.MaxValue);
writer.Write(int.MinValue);
writer.Write(int.MaxValue);
writer.Write(uint.MinValue);
writer.Write(uint.MaxValue);
writer.Write(long.MinValue);
writer.Write(long.MaxValue);
writer.Write(ulong.MinValue);
writer.Write(ulong.MaxValue);
}
var position = stream.Position;
stream.Seek(0, SeekOrigin.Begin);
using(var reader = new PrimitiveReader(stream))
{
Assert.AreEqual(byte.MinValue, reader.ReadByte());
Assert.AreEqual(byte.MaxValue, reader.ReadByte());
Assert.AreEqual(sbyte.MinValue, reader.ReadSByte());
Assert.AreEqual(sbyte.MaxValue, reader.ReadSByte());
Assert.AreEqual(short.MinValue, reader.ReadInt16());
Assert.AreEqual(short.MaxValue, reader.ReadInt16());
Assert.AreEqual(ushort.MinValue, reader.ReadUInt16());
Assert.AreEqual(ushort.MaxValue, reader.ReadUInt16());
Assert.AreEqual(int.MinValue, reader.ReadInt32());
Assert.AreEqual(int.MaxValue, reader.ReadInt32());
Assert.AreEqual(uint.MinValue, reader.ReadUInt32());
Assert.AreEqual(uint.MaxValue, reader.ReadUInt32());
Assert.AreEqual(long.MinValue, reader.ReadInt64());
Assert.AreEqual(long.MaxValue, reader.ReadInt64());
Assert.AreEqual(ulong.MinValue, reader.ReadUInt64());
Assert.AreEqual(ulong.MaxValue, reader.ReadUInt64());
}
Assert.AreEqual(position, stream.Position, StreamCorruptedMessage);
}
public static SavePlayerInfo ReadFrom(PrimitiveReader reader, int pCount)
{
SavePlayerInfo p = new SavePlayerInfo();
byte[] diplomacyFrom = reader.ReadBytes(pCount);
uint[] diplomacyTo = reader.ReadUInt32Array(9);
uint unknown1 = reader.ReadUInt32();
byte unknown2 = reader.ReadUInt8();
string name = Utils.ReadUInt16LengthPrefixedString(reader);
byte unknown3 = reader.ReadUInt8();
int floatsCount = reader.ReadInt32();
byte unknown4 = reader.ReadUInt8();
float[] civHeader = reader.ReadFloat32Array(floatsCount);
FloatTest t = new FloatTest(civHeader);
byte unknown5 = reader.ReadUInt8();
float[] unknown6 = reader.ReadFloat32Array(2);
byte[] unknown7 = reader.ReadBytes(9);
byte civilization = reader.ReadUInt8();
byte[] unknown8 = reader.ReadBytes(3);
byte colour = reader.ReadUInt8();
byte[] unknown9 = reader.ReadBytes(4183);
float unknown10 = reader.ReadFloat32();
int researchCount = reader.ReadInt32();
ushort unknown11 = reader.ReadUInt16();
ResearchStat[] stats = new ResearchStat[researchCount];
for (int i = 0; i < stats.Length; i++)
{
stats[i] = ResearchStat.ReadFrom(reader);
}
Console.WriteLine("LAST KNOWN POS:" + reader.Position);
reader.SeekAbsolute(128358);
int masterObjectsCount = reader.ReadInt32();
bool[] objectExistsFlags = new bool[masterObjectsCount];
for (int i = 0; i < objectExistsFlags.Length; i++)
{
objectExistsFlags[i] = reader.ReadUInt32() != 0;
}
//System.Diagnostics.Debugger.Break();
ushort unknownObjects = reader.ReadUInt16();
Console.WriteLine("BEGIN READ OBJECTS.." + reader.Position);
MasterObject[] masterObjects = new MasterObject[masterObjectsCount];
for (int i = 0; i < masterObjects.Length; i++)
{
if (objectExistsFlags[i])
{
masterObjects[i] = MasterObject.ReadFrom(reader, i);
}
}
System.Diagnostics.Debugger.Break();
return(p);
}
