/// <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>
/// 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;
}
}
}
}
}
/// <summary>
/// Schreibt einen String der gegebenen Länge. Falls der String kürzer ist, wird der Rest mit 0-Bytes aufgefüllt.
/// </summary>
/// <param name="buffer">Der Puffer, in den der String geschrieben werden soll.</param>
/// <param name="value">Der zu schreibende String.</param>
/// <param name="length">Die Soll-Länge des zu schreibenden Strings.</param>
private void WriteString(RAMBuffer buffer, string value, int length)
{
// Byte-Array anlegen
byte[] val = new byte[length];
// String in Byte-Array kopieren, dabei maximal length Zeichen berücksichtigen
Encoding.Default.GetBytes(value.Substring(0, Math.Min(length, value.Length))).CopyTo(val, 0);
// Wert in den Puffer schreiben
buffer.Write(val);
}
/// <summary>
/// Schreibt alle Farbdaten als Bitmap-Farbtabelle in den angegebenen Puffer.
/// </summary>
/// <param name="buffer">Der zu verwendende Puffer.</param>
public void ToBinary(ref RAMBuffer buffer)
{
// Einträge einzeln durchgehen
for(int i = 0; i < 256; i++)
{
// 4 Bytes nehmen (d.h. einen Tabelleneintrag)
byte[] b = { _colors[i].B, _colors[i].G, _colors[i].R, 0 };
// Bytes schreiben
buffer.Write(b);
}
}
