public static AiInfo ReadFrom(PrimitiveReader reader)
{
AiInfo info = new AiInfo();
info.Unknown = reader.ReadUInt16();
ushort stringsCount = reader.ReadUInt16();
System.Diagnostics.Debugger.Break();
info.Unknown2 = reader.ReadUInt32();
List <string> resources = new List <string>(stringsCount);
for (int i = 0; i < stringsCount; i++)
{
resources.Add(Utils.ReadUInt32LengthPrefixedString(reader));
}
info.Resources = resources;
info.Unknown3 = reader.ReadBytes(6);
AiData[] data = new AiData[8];
for (int i = 0; i < data.Length; i++)
{
data[i] = AiData.ReadFrom(reader);
}
info.Data = data;
info.Unknown4 = reader.ReadBytes(104);
AiTimer[] timers = new AiTimer[8];
for (int i = 0; i < timers.Length; i++)
{
timers[i] = AiTimer.ReadFrom(reader);
}
info.Timers = timers;
info.SharedGoals = reader.ReadUInt32Array(256);
info.Unknown5 = reader.ReadUInt32Array(1024);
return(info);
}
public void Load(FileStream stream)
{
using (var reader = new PrimitiveReader(stream, false))
{
foreach (var provider in providers)
{
var tempFile = TemporaryFilesManager.Instance.GetTemporaryFile();
if (ConfigurationManager.Instance.Get("file-system", "use-cow", false))
{
FileCopier.Copy(stream.Name, tempFile, true);
var size = reader.ReadInt64();
var localPosition = stream.Position;
reader.ReadBytes((int)size);
provider.BlobIsReady(tempFile, localPosition, size);
}
else
{
var size = reader.ReadInt64();
using (var fileStream = new FileStream(tempFile, FileMode.OpenOrCreate))
{
reader.CopyTo(fileStream, size);
}
provider.BlobIsReady(tempFile, 0, size);
}
}
}
}
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));
}
/// <summary>
/// Reads an Nbt style string.
/// </summary>
public static string ReadStringNbt(this PrimitiveReader reader)
{
var length = reader.ReadUShort();
var bytes = reader.ReadBytes(length);
return(System.Text.Encoding.UTF8.GetString(bytes));
}
public void ShouldWriteAndReadPartsOfByteArrays()
{
var arrays = new byte[100][];
for (var i = 0; i < arrays.Length; i++)
{
arrays[i] = Enumerable.Range(0, 256).Select(x => (byte)x).ToArray();
}
var stream = new MemoryStream();
using (var writer = new PrimitiveWriter(stream))
{
for (var i = 0; i < arrays.Length; i++)
{
writer.Write(arrays[i], i, arrays[i].Length - i);
}
}
var position = stream.Position;
stream.Seek(0, SeekOrigin.Begin);
using (var reader = new PrimitiveReader(stream))
{
for (var i = 0; i < arrays.Length; i++)
{
var writtenLength = arrays[i].Length - i;
var writtenArray = reader.ReadBytes(writtenLength);
var subarray = new byte[writtenLength];
Array.Copy(arrays[i], i, subarray, 0, writtenLength);
CollectionAssert.AreEqual(subarray, writtenArray);
}
}
Assert.AreEqual(position, stream.Position, StreamCorruptedMessage);
}
/// <summary>
/// Reads a proto style string.
/// </summary>
/// <exception cref="ArgumentOutOfRangeException">if <paramref name="n"/> > max allowed (<see cref="ProtoConsts.MaxStringChars"/></exception>
/// <exception cref="ProtoException">if read string is invalid.</exception>
public static string ReadStringProto(this PrimitiveReader primitiveReader, uint n)
{
if (n > ProtoConsts.MaxStringChars)
{
throw new ArgumentOutOfRangeException(nameof(n), "greater than maximum allowed.");
}
var length = primitiveReader.ReadVarint();
if (length < 0)
{
throw new ProtoException("Negative string length");
}
if (length > n * 4)
{
throw new ProtoException($"Received string byte length greater than allowed n({n})");
}
var bytes = primitiveReader.ReadBytes(length);
var s = System.Text.Encoding.UTF8.GetString(bytes);
if (new StringInfo(s).LengthInTextElements > n)
{
throw new ProtoException($"Received string has more unicode code points than allowed ({n})");
}
return(s);
}
public void ShouldWriteAndReadByteArray(
[Values(10, 1000, 100000)]
int count
)
{
var stream = new MemoryStream();
byte[] array;
using (var writer = new PrimitiveWriter(stream))
{
array = new byte[count];
Helpers.Random.NextBytes(array);
writer.Write(array);
}
var position = stream.Position;
stream.Seek(0, SeekOrigin.Begin);
byte[] copy;
using (var reader = new PrimitiveReader(stream))
{
copy = reader.ReadBytes(count);
}
CollectionAssert.AreEqual(array, copy);
Assert.AreEqual(position, stream.Position, StreamCorruptedMessage);
}
public static AiRule ReadFrom(PrimitiveReader reader)
{
AiRule rule = new AiRule();
rule.Unknown = reader.ReadBytes(8);
rule.FactsCount = reader.ReadUInt8();
rule.FactsCountAction = reader.ReadUInt8();
rule.Unknown2 = reader.ReadUInt16();
AiRuleData[] rulesData = new AiRuleData[8];
for (int i = 0; i < rulesData.Length; i++)
{
rulesData[i] = AiRuleData.ReadFrom(reader);
}
return(rule);
}
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;
}
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;
}
}
void SkipChunkData( PrimitiveReader reader, long length )
{
while( length > 0 ) {
int skipSize = (int)Math.Min( 4096, length );
reader.ReadBytes( skipSize );
length -= 4096;
}
}
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;
}
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 ProcessMetadataPadding( int len, PrimitiveReader reader )
{
reader.ReadBytes( len );
}
IEnumerable<AudioChunk> StreamDataCore( PrimitiveReader reader )
{
long length = dataLength;
int bufferLength = bufferSize; // Approximately one second each.
while( length > 0 ) {
int currentBufferSize = (int)Math.Min( bufferLength, length );
chunk.Data = reader.ReadBytes( currentBufferSize );
length -= bufferLength;
#if DEBUG_POS
counter++;
Console.WriteLine( "Returned {0} chunks. (Still {1} bytes left)", counter, length );
#endif
yield return chunk;
}
}
int ReadSyncSafeInt32( PrimitiveReader reader )
{
byte[] buffer = reader.ReadBytes( 4 );
return ( buffer[0] & 0x7F ) << 21 | ( buffer[1] & 0x7F ) << 14 |
( buffer[2] & 0x7F ) << 7 | ( buffer[3] & 0x7F );
}
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;
}
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 );
}
public void ShouldWriteAndReadByteArray(
[Values(10, 1000, 100000)]
int count
)
{
var stream = new MemoryStream();
byte[] array;
using(var writer = new PrimitiveWriter(stream))
{
array = new byte[count];
Helpers.Random.NextBytes(array);
writer.Write(array);
}
var position = stream.Position;
stream.Seek(0, SeekOrigin.Begin);
byte[] copy;
using(var reader = new PrimitiveReader(stream))
{
copy = reader.ReadBytes(count);
}
CollectionAssert.AreEqual(array, copy);
Assert.AreEqual(position, stream.Position, StreamCorruptedMessage);
}
static string ReadFixedASCIIString( PrimitiveReader reader, int count )
{
byte[] data = reader.ReadBytes( count );
int index = Array.IndexOf( data, (byte)0 );
return Encoding.ASCII.GetString( data, 0, index == -1 ? count : index );
}
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);
}
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 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);
}
public void ShouldWriteAndReadPartsOfByteArrays()
{
var arrays = new byte[100][];
for(var i = 0; i < arrays.Length; i++)
{
arrays[i] = Enumerable.Range(0, 256).Select(x => (byte)x).ToArray();
}
var stream = new MemoryStream();
using(var writer = new PrimitiveWriter(stream))
{
for(var i = 0; i < arrays.Length; i++)
{
writer.Write(arrays[i], i, arrays[i].Length - i);
}
}
var position = stream.Position;
stream.Seek(0, SeekOrigin.Begin);
using(var reader = new PrimitiveReader(stream))
{
for(var i = 0; i < arrays.Length; i++)
{
var writtenLength = arrays[i].Length - i;
var writtenArray = reader.ReadBytes(writtenLength);
var subarray = new byte[writtenLength];
Array.Copy(arrays[i], i, subarray, 0, writtenLength);
CollectionAssert.AreEqual(subarray, writtenArray);
}
}
Assert.AreEqual(position, stream.Position, StreamCorruptedMessage);
}
void ProcessMetadataCuesheet( int len, PrimitiveReader reader )
{
string catalogueNumber = reader.ReadASCIIString( 128 );
ulong leadInSamplesCount = reader.ReadUInt64();
byte format = reader.ReadByte(); // All bits other than 1 are reserved.
bool compactDisc = ( format & 0x01 ) != 0;
byte[] reserved = reader.ReadBytes( 258 );
byte trackCount = reader.ReadByte();
bool cdda = leadInSamplesCount != 0;
for( int i = 0; i < trackCount; i++ ) {
ulong trackOffset = reader.ReadUInt64();
byte trackNumber = reader.ReadByte();
bool leadOut = cdda ? trackNumber == 170 : trackNumber == 255;
string isrc = reader.ReadASCIIString( 12 );
byte trackFlags = reader.ReadByte(); // All bits other than 1 and 2 are reserved.
bool audio = ( trackFlags & 0x01 ) == 0;
bool preEmphasis = ( trackFlags & 0x02 ) != 0;
byte[] trackReserved = reader.ReadBytes( 13 );
byte indexCount = reader.ReadByte();
for( int j = 0; j < indexCount; j++ ) {
ulong indexOffset = reader.ReadUInt64();
byte indexPointNumber = reader.ReadByte();
byte[] indexReserved = reader.ReadBytes( 3 );
}
}
}
