/// <summary>
/// Writes the data element into the given buffer (at its current position).
/// </summary>
/// <param name="buffer">The buffer where the data element should be deserialized into.</param>
public void WriteData(RAMBuffer buffer)
{
buffer.WriteUShort((ushort)PlayerName.Length);
buffer.WriteString(PlayerName);
buffer.WriteFloat(InitialCameraX);
buffer.WriteFloat(InitialCameraY);
buffer.WriteShort(UnknownX);
buffer.WriteShort(UnknownY);
buffer.WriteByte(AlliedVictory);
ScenarioDataElementTools.AssertTrue(Diplomacy1.Count == Diplomacy2.Count);
buffer.WriteUShort((ushort)Diplomacy1.Count);
Diplomacy1.ForEach(d => buffer.WriteByte((byte)d));
Diplomacy2.ForEach(d => buffer.WriteUInteger((uint)d));
buffer.WriteUInteger(Color);
buffer.WriteFloat(Unknown1);
buffer.WriteUShort(Unknown3Count);
if (Unknown1 == 2)
{
ScenarioDataElementTools.AssertListLength(Unknown2, 8);
Unknown2.ForEach(b => buffer.WriteByte(b));
}
ScenarioDataElementTools.AssertListLength(Unknown3, Unknown3Count * 44);
Unknown3.ForEach(b => buffer.WriteByte(b));
ScenarioDataElementTools.AssertListLength(Unknown4, 7);
Unknown4.ForEach(b => buffer.WriteByte(b));
buffer.WriteInteger(Unknown5);
}
/// <summary>
/// Writes the data element into the given buffer (at its current position).
/// </summary>
/// <param name="buffer">The buffer where the data element should be deserialized into.</param>
public void WriteData(RAMBuffer buffer)
{
buffer.WriteUInteger(Unknown1);
buffer.WriteUInteger(Unknown2);
buffer.WriteInteger(AiPerFileContent.Length);
buffer.WriteString(AiPerFileContent);
}
/// <summary>
/// Writes the data element into the given buffer (at its current position).
/// </summary>
/// <param name="buffer">The buffer where the data element should be deserialized into.</param>
public void WriteData(RAMBuffer buffer)
{
buffer.WriteUInteger(Active);
buffer.WriteUInteger(Human);
buffer.WriteUInteger(CivId);
buffer.WriteUInteger(Unknown);
}
/// <summary>
/// Writes the data element into the given buffer (at its current position).
/// </summary>
/// <param name="buffer">The buffer where the data element should be deserialized into.</param>
public void WriteData(RAMBuffer buffer)
{
buffer.WriteUInteger(Enabled);
buffer.WriteUInteger(Looping);
buffer.WriteByte(State);
buffer.WriteByte(ShowAsObjective);
buffer.WriteInteger(ObjectiveDescriptionIndex);
buffer.WriteUInteger(Unknown);
if (Description.Length == 0 || Description.Last() != '\0')
{
Description += '\0';
}
buffer.WriteInteger(Description.Length);
buffer.WriteString(Description);
if (Name.Length == 0 || Name.Last() != '\0')
{
Name += '\0';
}
buffer.WriteInteger(Name.Length);
buffer.WriteString(Name);
ScenarioDataElementTools.AssertTrue(Effects.Count == EffectDisplayIndices.Count);
buffer.WriteInteger(Effects.Count);
Effects.ForEach(t => t.WriteData(buffer));
EffectDisplayIndices.ForEach(t => buffer.WriteInteger(t));
ScenarioDataElementTools.AssertTrue(Conditions.Count == ConditionDisplayIndices.Count);
buffer.WriteInteger(Conditions.Count);
Conditions.ForEach(t => t.WriteData(buffer));
ConditionDisplayIndices.ForEach(t => buffer.WriteInteger(t));
}
/// <summary>
/// Writes the data element into the given buffer (at its current position).
/// </summary>
/// <param name="buffer">The buffer where the data element should be deserialized into.</param>
public void WriteData(RAMBuffer buffer)
{
ScenarioDataElementTools.AssertListLength(StancesPerPlayer, 16);
StancesPerPlayer.ForEach(s => s.WriteData(buffer));
buffer.Write(new byte[11520]);
buffer.WriteUInteger(0xFFFFFF9D);
ScenarioDataElementTools.AssertListLength(AlliedVictoryObsolete, 16);
AlliedVictoryObsolete.ForEach(av => buffer.WriteUInteger(av));
}
/// <summary>
/// Serializes the data elements into the internal buffer.
/// </summary>
/// <remarks></remarks>
private void WriteData()
{
// Initialize buffer
if (_buffer == null)
{
_buffer = new RAMBuffer();
}
else if (_buffer.Length != 0)
{
_buffer.Clear();
}
// Write header
_buffer.WriteString("1.21", 4);
_buffer.WriteUInteger(4 + 4 + 4 + (uint)ScenarioInstructions.Length + 4 + 4);
_buffer.WriteInteger(2);
_buffer.WriteUInteger(LastSaveTimestamp);
_buffer.WriteInteger(ScenarioInstructions.Length);
_buffer.WriteString(ScenarioInstructions);
_buffer.WriteUInteger(0);
_buffer.WriteUInteger(PlayerCount);
// Create buffer for compressed data elements
RAMBuffer comprBuffer = new RAMBuffer();
Header.WriteData(comprBuffer);
MessagesCinematics.WriteData(comprBuffer);
PlayerAiResources.WriteData(comprBuffer);
GlobalVictory.WriteData(comprBuffer);
Diplomacy.WriteData(comprBuffer);
Disables.WriteData(comprBuffer);
Map.WriteData(comprBuffer);
Units.WriteData(comprBuffer);
PlayerDiplomacyVarious.WriteData(comprBuffer);
Triggers.WriteData(comprBuffer);
IncludedFiles.WriteData(comprBuffer);
// Compress data and copy to main buffer
using (MemoryStream output = new MemoryStream())
using (MemoryStream input = comprBuffer.ToMemoryStream())
{
// Create compressor stream
using (DeflateStream compressor = new DeflateStream(output, CompressionMode.Compress))
{
// Compress
input.CopyTo(compressor);
input.Close();
}
// Save compressed data into main buffer
_buffer.Write(output.ToArray());
}
}
/// <summary>
/// Writes the data element into the given buffer (at its current position).
/// </summary>
/// <param name="buffer">The buffer where the data element should be deserialized into.</param>
public void WriteData(RAMBuffer buffer)
{
buffer.WriteUInteger((uint)Type);
buffer.WriteUInteger(0x00000017);
buffer.WriteInteger(AiGoal);
buffer.WriteInteger(Amount);
buffer.WriteInteger(ResourceId);
buffer.WriteInteger(Diplomacy);
buffer.WriteInteger(SelectedUnitInstanceIds.Count);
buffer.WriteInteger(LocationUnitInstanceId);
buffer.WriteInteger(UnitType);
buffer.WriteInteger(PlayerSource);
buffer.WriteInteger(PlayerTarget);
buffer.WriteInteger(ResearchId);
buffer.WriteInteger(StringId);
buffer.WriteInteger(SoundId);
buffer.WriteInteger(DisplayTime);
buffer.WriteInteger(TriggerIndex);
buffer.WriteInteger(LocationX);
buffer.WriteInteger(LocationY);
buffer.WriteInteger(AreaBottomLeftX);
buffer.WriteInteger(AreaBottomLeftY);
buffer.WriteInteger(AreaTopRightX);
buffer.WriteInteger(AreaTopRightY);
buffer.WriteInteger(UnitClass);
buffer.WriteInteger(UnitType2);
buffer.WriteInteger(InstructionPanel);
if (Text.Length == 0 || Text.Last() != '\0')
{
Text += '\0';
}
buffer.WriteInteger(Text.Length);
buffer.WriteString(Text);
if (SoundFileName.Length == 0 || SoundFileName.Last() != '\0')
{
SoundFileName += '\0';
}
buffer.WriteInteger(SoundFileName.Length);
buffer.WriteString(SoundFileName);
SelectedUnitInstanceIds.ForEach(u => buffer.WriteUInteger(u));
}
/// <summary>
/// Writes the data element into the given buffer (at its current position).
/// </summary>
/// <param name="buffer">The buffer where the data element should be deserialized into.</param>
public void WriteData(RAMBuffer buffer)
{
buffer.WriteUInteger(0xFFFFFF9D);
buffer.WriteInteger(Player1CameraY);
buffer.WriteInteger(Player1CameraX);
buffer.WriteInteger(AiMapCode);
buffer.WriteUInteger(MapWidth);
buffer.WriteUInteger(MapHeight);
ScenarioDataElementTools.AssertListLength(Tiles, (int)MapWidth);
Tiles.ForEach(i =>
{
ScenarioDataElementTools.AssertListLength(i, (int)MapHeight);
i.ForEach(j => j.WriteData(buffer));
});
}
/// <summary>
/// Writes the data element into the given buffer (at its current position).
/// </summary>
/// <param name="buffer">The buffer where the data element should be deserialized into.</param>
public void WriteData(RAMBuffer buffer)
{
buffer.WriteUInteger(InstructionsStringDllId);
buffer.WriteUInteger(HintsStringDllId);
buffer.WriteUInteger(VictoryStringDllId);
buffer.WriteUInteger(LossStringDllId);
buffer.WriteUInteger(HistoryStringDllId);
buffer.WriteUInteger(ScoutsStringDllId);
buffer.WriteShort((short)InstructionsString.Length);
buffer.WriteString(InstructionsString);
buffer.WriteShort((short)HintsString.Length);
buffer.WriteString(HintsString);
buffer.WriteShort((short)VictoryString.Length);
buffer.WriteString(VictoryString);
buffer.WriteShort((short)LossString.Length);
buffer.WriteString(LossString);
buffer.WriteShort((short)HistoryString.Length);
buffer.WriteString(HistoryString);
buffer.WriteShort((short)ScoutsString.Length);
buffer.WriteString(ScoutsString);
buffer.WriteShort((short)PregameCinematicFileName.Length);
buffer.WriteString(PregameCinematicFileName);
buffer.WriteShort((short)VictoryCinematicFileName.Length);
buffer.WriteString(VictoryCinematicFileName);
buffer.WriteShort((short)LossCinematicFileName.Length);
buffer.WriteString(LossCinematicFileName);
buffer.WriteShort((short)BackgroundFileName.Length);
buffer.WriteString(BackgroundFileName);
if (Bitmap == null)
{
buffer.WriteUInteger(0);
buffer.WriteInteger(0);
buffer.WriteInteger(0);
buffer.WriteShort(1);
}
else
{
buffer.WriteUInteger(1);
buffer.WriteInteger(Bitmap.Width);
buffer.WriteInteger(Bitmap.Height);
buffer.WriteShort(-1);
Bitmap.SaveToBuffer(buffer, false);
}
}
/// <summary>
/// Writes the data element into the given buffer (at its current position).
/// </summary>
/// <param name="buffer">The buffer where the data element should be deserialized into.</param>
public void WriteData(RAMBuffer buffer)
{
buffer.WriteUInteger(UnknownPlayerCount);
ScenarioDataElementTools.AssertListLength(PlayerDiplomacyVariousEntries, 8);
PlayerDiplomacyVariousEntries.ForEach(e => e.WriteData(buffer));
buffer.WriteULong(Unknown);
}
/// <summary>
/// Writes the data element into the given buffer (at its current position).
/// </summary>
/// <param name="buffer">The buffer where the data element should be deserialized into.</param>
public void WriteData(RAMBuffer buffer)
{
buffer.WriteFloat(Gold);
buffer.WriteFloat(Wood);
buffer.WriteFloat(Food);
buffer.WriteFloat(Stone);
buffer.WriteFloat(Ore);
buffer.WriteUInteger(Padding);
buffer.WriteFloat(PopulationLimit);
}
/// <summary>
/// Writes the data element into the given buffer (at its current position).
/// </summary>
/// <param name="buffer">The buffer where the data element should be deserialized into.</param>
public void WriteData(RAMBuffer buffer)
{
buffer.WriteFloat(PositionX);
buffer.WriteFloat(PositionY);
buffer.WriteFloat(PositionZ);
buffer.WriteUInteger(Id);
buffer.WriteUShort(UnitId);
buffer.WriteByte(State);
buffer.WriteFloat(Rotation);
buffer.WriteUShort(Frame);
buffer.WriteInteger(GarrisonId);
}
/// <summary>
/// Writes the data element into the given buffer (at its current position).
/// </summary>
/// <param name="buffer">The buffer where the data element should be deserialized into.</param>
public void WriteData(RAMBuffer buffer)
{
ScenarioDataElementTools.AssertListLength(DisabledTechsPerPlayer, 16);
DisabledTechsPerPlayer.ForEach(p => buffer.WriteInteger(p.Count));
DisabledTechsPerPlayer.ForEach(p =>
{
p.ForEach(e => buffer.WriteUInteger(e));
buffer.Write(new byte[4 * (30 - p.Count)]);
});
ScenarioDataElementTools.AssertListLength(DisabledUnitsPerPlayer, 16);
DisabledUnitsPerPlayer.ForEach(p => buffer.WriteInteger(p.Count));
DisabledUnitsPerPlayer.ForEach(p =>
{
p.ForEach(e => buffer.WriteUInteger(e));
buffer.Write(new byte[4 * (30 - p.Count)]);
});
ScenarioDataElementTools.AssertListLength(DisabledBuildingsPerPlayer, 16);
DisabledBuildingsPerPlayer.ForEach(p => buffer.WriteInteger(p.Count));
DisabledBuildingsPerPlayer.ForEach(p =>
{
p.ForEach(e => buffer.WriteUInteger(e));
buffer.Write(new byte[4 * (20 - p.Count)]);
});
buffer.WriteUInteger(Unused1);
buffer.WriteUInteger(Unused2);
buffer.WriteUInteger(FullTechMode);
ScenarioDataElementTools.AssertListLength(StartingAges, 16);
StartingAges.ForEach(a => buffer.WriteInteger(a));
}
/// <summary>
/// Writes the data element into the given buffer (at its current position).
/// </summary>
/// <param name="buffer">The buffer where the data element should be deserialized into.</param>
public void WriteData(RAMBuffer buffer)
{
buffer.WriteUInteger(NextUnitIdToPlace);
buffer.WriteFloat(1.22f);
ScenarioDataElementTools.AssertListLength(PlayerNames, 16);
PlayerNames.ForEach(p => buffer.WriteString(p, 256));
ScenarioDataElementTools.AssertListLength(PlayerNameDllIds, 16);
PlayerNameDllIds.ForEach(p => buffer.WriteUInteger(p));
ScenarioDataElementTools.AssertListLength(PlayerData, 16);
PlayerData.ForEach(p => p.WriteData(buffer));
buffer.WriteUInteger(Unknown1);
buffer.WriteByte(0);
buffer.WriteFloat(Unknown2);
buffer.WriteShort((short)OriginalFileName.Length);
buffer.WriteString(OriginalFileName);
}
/// <summary>
/// Writes the data element into the given buffer (at its current position).
/// </summary>
/// <param name="buffer">The buffer where the data element should be deserialized into.</param>
public void WriteData(RAMBuffer buffer)
{
buffer.WriteUInteger((uint)Type);
buffer.WriteUInteger(0x00000010);
buffer.WriteInteger(Amount);
buffer.WriteInteger(ResourceId);
buffer.WriteInteger(UnitInstanceId);
buffer.WriteInteger(UnitLocation);
buffer.WriteInteger(UnitType);
buffer.WriteInteger(Player);
buffer.WriteInteger(ResearchId);
buffer.WriteInteger(Timer);
buffer.WriteInteger(Unknown);
buffer.WriteInteger(AreaBottomLeftX);
buffer.WriteInteger(AreaBottomLeftY);
buffer.WriteInteger(AreaTopRightX);
buffer.WriteInteger(AreaTopRightY);
buffer.WriteInteger(UnitClass);
buffer.WriteInteger(UnitType2);
buffer.WriteInteger(AiSignal);
}
/// <summary>
/// Wandelt die Struktur in ein exportierbares Binärformat um.
/// </summary>
/// <returns></returns>
public RAMBuffer ToBinary()
{
// Puffer erstellen
RAMBuffer buff = new RAMBuffer();
// DRS-Dateiname
buff.WriteUInteger((uint)DRSFile.Length);
buff.WriteString(DRSFile);
// Datei-ID
buff.WriteUInteger(FileID);
// Ressourcen-Typ
buff.WriteUInteger((uint)ResourceType.Length);
buff.WriteString(ResourceType);
// Data
buff.WriteUInteger((uint)Data.Length);
buff.Write(Data);
// Fertig
return(buff);
}
/// <summary>
/// Writes the data element into the given buffer (at its current position).
/// </summary>
/// <param name="buffer">The buffer where the data element should be deserialized into.</param>
public void WriteData(RAMBuffer buffer)
{
buffer.WriteUInteger(Gold);
buffer.WriteUInteger(Wood);
buffer.WriteUInteger(Food);
buffer.WriteUInteger(Stone);
buffer.WriteUInteger(Ore);
buffer.WriteUInteger(Padding);
}
/// <summary>
/// Writes the data element into the given buffer (at its current position).
/// </summary>
/// <param name="buffer">The buffer where the data element should be deserialized into.</param>
public void WriteData(RAMBuffer buffer)
{
buffer.WriteInteger(Files.Count > 0 ? 1 : 0);
buffer.WriteUInteger(EsOnlyDataIncluded);
if (EsOnlyDataIncluded > 0)
{
ScenarioDataElementTools.AssertListLength(EsOnlyData, 396);
EsOnlyData.ForEach(b => buffer.WriteByte(b));
}
if (Files.Count > 0)
{
buffer.WriteInteger(Files.Count);
Files.ForEach(f => f.WriteData(buffer));
}
}
/// <summary>
/// Writes the data element into the given buffer (at its current position).
/// </summary>
/// <param name="buffer">The buffer where the data element should be deserialized into.</param>
public void WriteData(RAMBuffer buffer)
{
ScenarioDataElementTools.AssertListLength(UnknownStrings, 32);
UnknownStrings.ForEach(s => { buffer.WriteShort((short)s.Length); buffer.WriteString(s); });
ScenarioDataElementTools.AssertListLength(AiNames, 16);
AiNames.ForEach(s => { buffer.WriteShort((short)s.Length); buffer.WriteString(s); });
ScenarioDataElementTools.AssertListLength(AiFiles, 16);
AiFiles.ForEach(f => f.WriteData(buffer));
ScenarioDataElementTools.AssertListLength(AiTypes, 16);
AiTypes.ForEach(t => buffer.WriteByte(t));
buffer.WriteUInteger(0xFFFFFF9D);
ScenarioDataElementTools.AssertListLength(ResourceEntries, 16);
ResourceEntries.ForEach(e => e.WriteData(buffer));
}
/// <summary>
/// Writes the data element into the given buffer (at its current position).
/// </summary>
/// <param name="buffer">The buffer where the data element should be deserialized into.</param>
public void WriteData(RAMBuffer buffer)
{
ScenarioDataElementTools.AssertListLength(Stances, 16);
Stances.ForEach(s => buffer.WriteUInteger(s));
}
/// <summary>
/// Speichert die enthaltene Bitmap in den angegebenen Puffer.
/// </summary>
/// <param name="buffer">Der Puffer, in den das Bild gespeichert werden soll.</param>
/// <param name="writeFileHeader">Optional. Gibt an, ob der Dateiheader geschrieben werden oder direkt mit der BITMAPINFOHEADER-Struktur begonnen werden soll.</param>
public void SaveToBuffer(RAMBuffer buffer, bool writeFileHeader = true)
{
// Bilddatenbreite ggf. auf ein Vielfaches von 4 Bytes erhöhen
int width = _header.width; // Hilfsvariable zur Performanceerhöhung (immer gleichwertig mit _header.width)
int width2 = width;
while (width2 % 4 != 0)
{
width2++;
}
// Bilddaten-Binär-Zielarray erstellen
_imageDataBin = new byte[width2 * Math.Abs(_header.height)];
// Bilddaten in Zielarray schreiben
int height2 = Math.Abs(_header.height);
for (int x = 0; x < width2; x++) // Start: Links
{
for (int y = 0; y < height2; y++) // Start: Oben
{
if (x >= width)
{
// Falls x außerhalb der Bildbreite liegt, Füllbyte einsetzen
_imageDataBin[y * width2 + x] = 0;
}
else
{
// Normaler Pixel: Farbtabellenindex schreiben, dabei Bottom-Up-Richtung beachten
_imageDataBin[y * width2 + x] = _imageData[(height2 - y - 1) * width + x];
}
}
}
// Header vorbereiten (einige wurden zwar schon definiert, aber lieber alle beisammen)
_header.type = 19778;
_header.fileSize = (uint)(44 + 256 * 4 + _imageDataBin.Length);
_header.reserved = 0;
_header.offsetData = (uint)(44 + 256 * 4);
_header.imageHeaderSize = 40;
_header.width = width;
_header.height = height2;
_header.layerCount = 1;
_header.bitsPerPixel = 8;
_header.compression = Header.COMPR_RGB;
_header.size = (uint)(height2 * width);
_header.xDPI = 0;
_header.yDPI = 0;
_header.colorCount = 0;
_header.colorImportantCount = 0;
// Header schreiben
if (writeFileHeader)
{
buffer.WriteUShort(_header.type);
buffer.WriteUInteger(_header.fileSize);
buffer.WriteUInteger(_header.reserved);
buffer.WriteUInteger(_header.offsetData);
}
buffer.WriteUInteger(_header.imageHeaderSize);
buffer.WriteInteger(_header.width);
buffer.WriteInteger(_header.height);
buffer.WriteUShort(_header.layerCount);
buffer.WriteUShort(_header.bitsPerPixel);
buffer.WriteUInteger(_header.compression);
buffer.WriteUInteger(_header.size);
buffer.WriteInteger(_header.xDPI);
buffer.WriteInteger(_header.yDPI);
buffer.WriteUInteger(_header.colorCount);
buffer.WriteUInteger(_header.colorImportantCount);
// Farbtabelle schreiben
_colorTable.ToBinary(ref buffer);
// Bilddaten schreiben
buffer.Write(_imageDataBin);
}
/// <summary>
/// Writes the data element into the given buffer (at its current position).
/// </summary>
/// <param name="buffer">The buffer where the data element should be deserialized into.</param>
public void WriteData(RAMBuffer buffer)
{
buffer.WriteUInteger(0xFFFFFF9D);
buffer.WriteUInteger(ConquestRequired);
buffer.WriteUInteger(Unused1);
buffer.WriteUInteger(NumberOfRelicsRequired);
buffer.WriteUInteger(Unused2);
buffer.WriteUInteger(ExploredPercentRequired);
buffer.WriteUInteger(Unused3);
buffer.WriteUInteger(AllCustomConditionsRequired);
buffer.WriteUInteger((uint)Mode);
buffer.WriteUInteger(ScoreRequired);
buffer.WriteUInteger(TimeRequired);
}
/// <summary>
/// Schreibt die enthaltenen Daten in das interne RAMBuffer-Objekt.
/// </summary>
/// <remarks></remarks>
public void WriteData()
{
// Puffer initialisieren
_buffer = new RAMBuffer();
// --- HEADER ---
WriteString(_buffer, _header.Copyright, 40);
WriteString(_buffer, _header.Version, 4);
WriteString(_buffer, _header.FileType, 12);
_buffer.WriteUInteger(_header.TableCount);
// ErsteDateiOffset wird vor den Tabellen berechnet, daher erstmal 0
_buffer.WriteUInteger(0);
// Erstes Tabellen-Offset ausrechnen Hilft bei der Geschwindigkeitserhöhung beim TABELLEN-Prozess
uint aktTableOffset = (uint)(_buffer.Position + _tableInfos.Count * 12);
// --- TABELLENINFORMATIONEN ---
TableInfo currTableInfo;
for (int i = 0; i < _tableInfos.Count; ++i)
{
// Tabelleninformationen holen
currTableInfo = _tableInfos[i];
// Werte schreiben
_buffer.WriteByte(currTableInfo.Unknown1);
WriteString(_buffer, currTableInfo.ResourceType, 3);
_buffer.WriteUInteger(aktTableOffset);
_buffer.WriteUInteger(currTableInfo.FileCount);
// Offset erhöhen
aktTableOffset += currTableInfo.FileCount * 12;
}
// Erstes Datei-Offset ausrechnen Hilft bei der Geschwindigkeitserhöhung beim DATEIEN-Prozess
uint aktFileOffset = (uint)_buffer.Position;
for (int i = 0; i < _tables.Count; ++i)
{
aktFileOffset += (uint)(_tables[i].Entries.Count * 12);
}
// Header->ErsteDateiOffset
uint aktPos = (uint)_buffer.Position;
_buffer.Position = 60;
_buffer.WriteUInteger(aktFileOffset);
_buffer.Position = (int)aktPos;
// --- TABELLEN ---
Table currTable;
TableEntry currEntry;
for (int i = 0; i < _tables.Count; ++i)
{
// Tabelle abrufen
currTable = _tables[i];
// Einträge schreiben
for (int j = 0; j < currTable.Entries.Count; ++j)
{
// Eintrag abrufen
currEntry = currTable.Entries[j];
// Werte schreiben
_buffer.WriteUInteger(currEntry.FileID);
_buffer.WriteUInteger(aktFileOffset);
_buffer.WriteUInteger(currEntry.FileSize);
// Offset erhöhen
aktFileOffset += currEntry.FileSize;
}
}
// --- DATEIEN ---
foreach (Table aktT in _tables)
{
// Alle Einträge durchlaufen
foreach (TableEntry currE in aktT.Entries)
{
// Zum Eintrag gehörige Datei suchen
foreach (KeyValuePair <uint, byte[]> currFile in _files)
{
// Datei gefunden?
if (currE.FileID == currFile.Key)
{
_buffer.Write(currFile.Value);
break;
}
}
}
}
}