public static ArmourStrength ReadFrom(PrimitiveReader reader)
{
ArmourStrength value;
value.GroupType = reader.ReadInt16();
value.Amount = reader.ReadInt16();
return(value);
}
public static ResourceCost ReadFrom(PrimitiveReader reader)
{
ResourceCost value;
value.Type = reader.ReadInt16();
value.Amount = reader.ReadInt16();
value.Unknown = reader.ReadInt16();
return(value);
}
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 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 ResearchStat ReadFrom(PrimitiveReader reader)
{
ResearchStat s = new ResearchStat();
s.Status = reader.ReadInt16();
s.Unknown1 = reader.ReadUInt32();
s.Unknown2 = reader.ReadUInt32();
s.Unknown3 = reader.ReadUInt32();
return(s);
}
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);
}
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;
}
void ProcessCommonChunk( AiffChunkHeader chunk, PrimitiveReader reader )
{
byte[] chunkData = reader.ReadBytes( chunk.DataSize );
Stream source = reader.stream;
reader.stream = new MemoryStream( chunkData );
int channelsCount = reader.ReadInt16();
uint frameCount = reader.ReadUInt32();
int bitsPerSample = reader.ReadInt16();
byte[] sampleRateBytes = reader.ReadBytes( 10 );
double sampleRate = ConvertFromIeeeExtended( sampleRateBytes );
Console.WriteLine( sampleRate );
AppendInfoLine( 2, "Channels Count: {0}", channelsCount );
AppendInfoLine( 2, "Sample rate (frames/sec): {0}", sampleRate );
AppendInfoLine( 2, "Bits per sample: {0}", bitsPerSample );
AppendInfoLine( 2, "Frame count: {0}", frameCount );
int byteRate = (int)Math.Ceiling( sampleRate ) * channelsCount * bitsPerSample / 8;
info.Frequency = (int)sampleRate;
Console.WriteLine( "BPS:" + bitsPerSample + ", SR:" + info.Frequency );
transformer = EmptyTransformer.Instance;
if( bitsPerSample > 8 && bitsPerSample <= 16 ) {
transformer = BigEndian16BitTo16BitTransformer.Instance;
}
if( bitsPerSample > 16 && bitsPerSample <= 24 ) {
transformer = BigEndian24BitTo16BitTransformer.Instance;
}
// Number of bytes that make up a second's worth of audio data.
bufferSize = byteRate;
info.Channels = channelsCount;
actualBitsPerSample = bitsPerSample;
// TODO: Remove this hackery.
if( bitsPerSample > 16 )
bitsPerSample = 16;
info.BitsPerSample = bitsPerSample;
if( aifcFormat ) {
string compressionType = reader.ReadASCIIString( 4 );
string compressionName = reader.ReadASCIIString( reader.ReadByte() );
AppendInfoLine( 2, "Compression type: {0}", compressionType );
AppendInfoLine( 2, "Compression name: {0}", compressionName );
switch( compressionType ) {
case "NONE":
case "sowt":
break;
case "alaw":
case "ALAW":
info.BitsPerSample = 16;
transformer = ALawTransformer.Instance;
break;
case "ulaw":
case "ULAW":
info.BitsPerSample = 16;
transformer = MuLawTransformer.Instance;
break;
}
}
reader.stream = source;
}
void ProcessMetadataStreamInfo( int len, PrimitiveReader reader )
{
short minBlockSize = reader.ReadInt16();
short maxBlockSize = reader.ReadInt16();
int minFrameSize = reader.ReadUInt24();
int maxFrameSize = reader.ReadUInt24();
FlacBitReader bitReader = new FlacBitReader( reader );
bitReader.BigEndian = true;
int sampleRate = bitReader.ReadBits( 20 );
Metadata[MetadataKeys.SampleRate] = sampleRate.ToString();
int channels = bitReader.ReadBits( 3 ) + 1;
Metadata[MetadataKeys.Channels] = channels.ToString();
int bitsPerSample = bitReader.ReadBits( 5 ) + 1;
Metadata[MetadataKeys.BitsPerSample] = bitsPerSample.ToString();
long totalSamples = bitReader.ReadBits64( 36 );
Metadata["Total samples"] = totalSamples.ToString();
channelCount = channels;
metaSampleRate = sampleRate;
metaBitsPerSample = bitsPerSample;
byte[] md5hash = reader.ReadBytes( 16 );
}
public static MasterObject ReadFrom(PrimitiveReader reader, int i)
{
MasterObject value = new MasterObject();
byte objectType = reader.ReadUInt8();
value.ObjectType = objectType;
value.UnitId = reader.ReadUInt16();
value.Unknown1 = reader.ReadUInt16();
value.Unknown2 = reader.ReadUInt16();
value.UnitClass = reader.ReadUInt16();
value.Unknown3 = reader.ReadBytes(6);
const int breakId = -1;
switch (objectType)
{
default:
throw new NotImplementedException("Unsupported object type: " + objectType);
case 10: // Basic units
{
short hitpoints = reader.ReadInt16();
float lengthOfSight = reader.ReadFloat32();
byte garrisonCapacity = reader.ReadUInt8();
float sizeRadiusX = reader.ReadFloat32();
float sizeRadiusY = reader.ReadFloat32();
ushort resourceCarriage = reader.ReadUInt16();
float resourceAmount = reader.ReadFloat32();
// Constants?
ushort unknown12 = reader.ReadUInt16();
byte unknown13 = reader.ReadUInt8();
}
break;
case 25: // Same as 20, only DOPL uses this.
case 20: // Extended basic units (FLAGX)
{
value.UnitData = reader.ReadBytes(28);
PrimitiveReader r2 = new PrimitiveReader(value.UnitData);
short hitpoints = r2.ReadInt16();
float lengthOfSight = r2.ReadFloat32();
byte garrisonCapacity = r2.ReadUInt8();
float sizeRadiusX = r2.ReadFloat32();
float sizeRadiusY = r2.ReadFloat32();
ulong unknown1 = r2.ReadUInt64();
ushort unknown2 = r2.ReadUInt16();
if (unknown1 != 0 || unknown2 != 0)
{
File.WriteAllBytes("unitextended.bin", value.UnitData);
System.Diagnostics.Debugger.Break();
}
// Constants?
ushort unknown12 = r2.ReadUInt16();
byte unknown13 = r2.ReadUInt8();
if (i == breakId)
{
System.Diagnostics.Debugger.Break();
}
} break;
case 30: // Dead units
{
value.UnitData = reader.ReadBytes(32);
if (i == breakId)
{
System.Diagnostics.Debugger.Break();
}
}
break;
case 60: // Projectiles
{
short hitpoints = reader.ReadInt16();
float lengthOfSight = reader.ReadFloat32();
byte garrisonCapacity = reader.ReadUInt8();
float sizeRadiusX = reader.ReadFloat32();
float sizeRadiusY = reader.ReadFloat32();
short resourceCarriage = reader.ReadInt16();
float unknownFloat = reader.ReadFloat32();
byte unknown2 = reader.ReadUInt8();
float movementRate = reader.ReadFloat32();
float extraRotationSpeed = reader.ReadFloat32();
float searchRadius = reader.ReadFloat32();
float workRate = reader.ReadFloat32();
short unknown4 = reader.ReadInt16();
ushort attackStrengthsCount = reader.ReadUInt16();
AttackStrength[] strengths = new AttackStrength[attackStrengthsCount];
for (int j = 0; j < strengths.Length; j++)
{
strengths[j] = AttackStrength.ReadFrom(reader);
}
ushort armourStrengthsCount = reader.ReadUInt16();
ArmourStrength[] astrengths = new ArmourStrength[armourStrengthsCount];
for (int j = 0; j < astrengths.Length; j++)
{
astrengths[j] = ArmourStrength.ReadFrom(reader);
}
float reloadTime = reader.ReadFloat32();
float maximumRange = reader.ReadFloat32();
short accuracyPercentage = reader.ReadInt16();
short projectileUnitId = reader.ReadInt16();
short unknown7 = reader.ReadInt16();
float displayedAttackRange = reader.ReadFloat32();
float blastRadius = reader.ReadFloat32();
float minimumRange = reader.ReadFloat32();
// Constants?
ushort unknown12 = reader.ReadUInt16();
byte unknown13 = reader.ReadUInt8();
if (unknown2 != 0)
{
System.Diagnostics.Debugger.Break();
}
if (i == breakId)
{
System.Diagnostics.Debugger.Break();
}
} break;
case 70: // Living units
{
short hitpoints = reader.ReadInt16();
float lengthOfSight = reader.ReadFloat32();
byte garrisonCapacity = reader.ReadUInt8();
float sizeRadiusX = reader.ReadFloat32();
float sizeRadiusY = reader.ReadFloat32();
short resourceCarriage = reader.ReadInt16();
float storageAmount = reader.ReadFloat32(); // e.g. iron boar = 700
byte unknown2 = reader.ReadUInt8();
float movementRate = reader.ReadFloat32();
float extraRotationSpeed = reader.ReadFloat32(); // Rotation speed for extra parts - sails for ships.
float searchRadius = reader.ReadFloat32();
float workRate = reader.ReadFloat32();
short unknown4 = reader.ReadInt16();
ushort attackStrengthsCount = reader.ReadUInt16();
AttackStrength[] strengths = new AttackStrength[attackStrengthsCount];
for (int j = 0; j < strengths.Length; j++)
{
strengths[j] = AttackStrength.ReadFrom(reader);
}
ushort armourStrengthsCount = reader.ReadUInt16();
ArmourStrength[] astrengths = new ArmourStrength[armourStrengthsCount];
for (int j = 0; j < astrengths.Length; j++)
{
astrengths[j] = ArmourStrength.ReadFrom(reader);
}
float reloadTime = reader.ReadFloat32();
float maximumRange = reader.ReadFloat32();
short accuracyPercentage = reader.ReadInt16();
short projectileUnitId = reader.ReadInt16();
short unknown7 = reader.ReadInt16();
float displayedAttackRange = reader.ReadFloat32();
float blastRadius = reader.ReadFloat32();
float minimumRange = reader.ReadFloat32();
ResourceCost res1 = ResourceCost.ReadFrom(reader);
ResourceCost res2 = ResourceCost.ReadFrom(reader);
ResourceCost res3 = ResourceCost.ReadFrom(reader);
short trainingTime = reader.ReadInt16();
float missileDuplicationAmount = reader.ReadFloat32();
// Constants?
ushort unknown12 = reader.ReadUInt16();
byte unknown13 = reader.ReadUInt8();
if (i == breakId)
{
System.Diagnostics.Debugger.Break();
}
}
break;
case 80: // Buildings
{
short hitpoints = reader.ReadInt16();
float lengthOfSight = reader.ReadFloat32();
byte garrisonCapacity = reader.ReadUInt8();
float sizeRadius1 = reader.ReadFloat32();
float sizeRadius2 = reader.ReadFloat32();
short resourceCarriage = reader.ReadInt16();
float storageAmount = reader.ReadFloat32();
byte unknown2 = reader.ReadUInt8();
float movementRate = reader.ReadFloat32();
float extraRotationSpeed = reader.ReadFloat32(); // Rotation speed for extra parts - something for trebuchets.
float searchRadius = reader.ReadFloat32();
float workRate = reader.ReadFloat32();
short unknown4 = reader.ReadInt16();
ushort attackStrengthsCount = reader.ReadUInt16();
AttackStrength[] strengths = new AttackStrength[attackStrengthsCount];
for (int j = 0; j < strengths.Length; j++)
{
strengths[j] = AttackStrength.ReadFrom(reader);
}
ushort armourStrengthsCount = reader.ReadUInt16();
ArmourStrength[] astrengths = new ArmourStrength[armourStrengthsCount];
for (int j = 0; j < astrengths.Length; j++)
{
astrengths[j] = ArmourStrength.ReadFrom(reader);
}
float reloadTime = reader.ReadFloat32();
float maximumRange = reader.ReadFloat32();
short accuracyPercentage = reader.ReadInt16();
short projectileUnitId = reader.ReadInt16();
short unknown7 = reader.ReadInt16(); // Seems to have something to do with buildings
float displayedAttackRange = reader.ReadFloat32();
float blastRadius = reader.ReadFloat32();
float minimumRange = reader.ReadFloat32();
ResourceCost res1 = ResourceCost.ReadFrom(reader);
ResourceCost res2 = ResourceCost.ReadFrom(reader);
ResourceCost res3 = ResourceCost.ReadFrom(reader);
short trainingTime = reader.ReadInt16();
float missileDuplicationAmount = reader.ReadFloat32();
ushort unknown14 = reader.ReadUInt16(); // No clue at all.
// Constants?
ushort unknown12 = reader.ReadUInt16();
byte unknown13 = reader.ReadUInt8();
if (i == breakId)
{
System.Diagnostics.Debugger.Break();
}
}
break;
}
return(value);
}
