public List<KeyValuePair<string, List<string>>> LTX_Texte = new List<KeyValuePair<string, List<string>>>(); //Liste von Dateinamen und einer Liste mit den zugehörigen Texten
#endregion Fields
#region Methods
public void addLTX(ref byte[] data, CDSAFileLoader.CFileSet LTX)
{
if (data == null || LTX == null)
return;
CDebugger.addDebugLine("Texte: " + LTX.filename + " wurde hinzugefügt");
// alle Texte der Datei auslesen
Int32 position = LTX.startOffset;
List<string> textList = new List<string>();
string text = CHelpFunctions.readDSAString(ref data, ref position, 0, LTX.endOffset);
textList.Add(text);
position++;
while (position < LTX.endOffset)
{
text = CHelpFunctions.readDSAString(ref data, ref position, 0, LTX.endOffset);
textList.Add(text);
position++;
}
//dateinamen auslesen
//int pos = s.LastIndexOf("\\");
//string filename = s.Substring(pos + 1);
this.LTX_Texte.Add(new KeyValuePair<string, List<string>>(LTX.filename, textList));
}
public void addRouten(ref byte[] data, CDSAFileLoader.CFileSet LROUT, CDSAFileLoader.CFileSet HSROUT, CDSAFileLoader.CFileSet SROUT)
{
this.itsLRout = this.loadRout(ref data, LROUT);
this.itsHSRout = this.loadRout(ref data, HSROUT);
this.itsSRout = this.loadRout(ref data, SROUT);
CDebugger.addDebugLine("Ruten wurden erfolgreich geladen");
}
public CTown(ref byte[] data, CDSAFileLoader.CFileSet town)
{
this.townEvents.Clear();
//schauen ob es eine große oder kleine Stadt ist
bool BigCity = false;
for (int i = town.startOffset + 256; i < (town.startOffset + 256 + 64); i += 4) //64 leere Bytes
{
if (data[i] != 0x00 && data[i] != 0xFF ||
data[i + 1] != 0x00 && data[i + 1] != 0xFF ||
data[i + 2] != 0x00 || data[i + 3] != 0x00)
{
BigCity = true;
break;
}
}
if (BigCity)
{
this.townLängeWO = 32;
this.townLängeSN = 16;
this.townData = new byte[32, 16];
}
else
{
this.townLängeWO = 16;
this.townLängeSN = 16;
this.townData = new byte[16, 16];
}
//Werte auslesen
int position = town.startOffset;
for (int y = 0; y < this.townLängeSN; y++)
{
for (int x = 0; x < this.townLängeWO; x++)
{
this.townData[x, y] = data[position];
position++;
}
}
//bestimmen des offsets für die stadtevents
if (BigCity)
position = town.startOffset + 576;
else
position = town.startOffset + 320;
Int32 blockLength = 6;
while ((position + blockLength) < town.endOffset)
{
this.townEvents.Add(new CTownEvent(ref data, position));
position += blockLength;
}
}
public void addMonsters(ref byte[] data, CDSAFileLoader.CFileSet monster_dat, CDSAFileLoader.CFileSet monstername, DSAVersion version)
{
itsMonsterStats.Clear();
if (data == null)
return;
if (monster_dat != null)
{
//blocklänge 44Bytes
Int32 blockLength = 44;
if (version == DSAVersion.Schweif)
blockLength = 48;
Int32 position = monster_dat.startOffset;
while ((position + blockLength) < monster_dat.endOffset)
{
itsMonsterStats.Add(new CMonsterStats(ref data, position, version));
position += blockLength;
}
CDebugger.addDebugLine("Monster: MONSTER.DAT wurde erfolgreich extrahiert");
}
else
CDebugger.addDebugLine("Monster: MONSTER.DAT konnte nicht extrahiert werden");
if (monstername != null)
{
itsMonsterNames.Clear();
// alle Texte der Datei auslesen
Int32 position = monstername.startOffset;
string text = CHelpFunctions.readDSAString(ref data, ref position, 0, monstername.endOffset);
itsMonsterNames.Add(text);
position++;
while ((position) < monstername.endOffset)
{
text = CHelpFunctions.readDSAString(ref data, ref position, 0, monstername.endOffset);
itsMonsterNames.Add(text);
position++;
}
CDebugger.addDebugLine("Monster: MONSTERNAME wurde erfolgreich extrahiert");
}
else
CDebugger.addDebugLine("Monster: MONSTERNAME konnte nicht extrahiert werden");
}
public void addItems(ref byte[] data, CDSAFileLoader.CFileSet items_dat, CDSAFileLoader.CFileSet itemname, DSAVersion version)
{
if (data == null)
return;
if (items_dat != null)
{
//blocklänge 12Bytes
Int32 blockLength = 12;
if (version == DSAVersion.Schweif)
blockLength = 14;
Int32 position = items_dat.startOffset;
while ((position + blockLength) < items_dat.endOffset)
{
itsItems.Add(new CItem(ref data, position, version));
position += blockLength;
}
CDebugger.addDebugLine("Items: ITEM.DAT wurde erfolgreich extrahiert");
}
else
CDebugger.addDebugLine("Items: ITEM.DAT konnte nicht extrahiert werden");
if (itemname != null)
{
// alle Texte der Datei auslesen
Int32 position = itemname.startOffset;
string text = CHelpFunctions.readDSAString(ref data, ref position, 0, itemname.endOffset);
itsItemNames.Add(text);
position++;
while (position < itemname.endOffset)
{
text = CHelpFunctions.readDSAString(ref data, ref position, 0, itemname.endOffset);
itsItemNames.Add(text);
position++;
}
CDebugger.addDebugLine("Items: ITEMNAME wurde erfolgreich extrahiert");
}
else
CDebugger.addDebugLine("Items: ITEMNAME konnte nicht extrahiert werden");
}
private List<List<Point>> loadRout(ref byte[] data, CDSAFileLoader.CFileSet ROUT)
{
List<Int32> offsets = new List<Int32>();
List<List<Point>> rout = new List<List<Point>>();
Int32 position = ROUT.startOffset;
Int32 value = CHelpFunctions.byteArrayToInt32(ref data, position);
position += 4;
while (value >= 0 && position < ROUT.endOffset)
{
offsets.Add(value);
value = CHelpFunctions.byteArrayToInt32(ref data, position);
position += 4;
}
Int32 beginOfData = position;
for (int i = 0; i < offsets.Count; i++)
{
rout.Add(new List<Point>());
position = beginOfData + offsets[i];
Int16 x = CHelpFunctions.byteArrayToInt16(ref data, position);
position += 2;
Int16 y = CHelpFunctions.byteArrayToInt16(ref data, position);
position += 2;
while (x >= 0 && y >= 0 && position < ROUT.endOffset)
{
rout[i].Add(new Point(x, y));
x = CHelpFunctions.byteArrayToInt16(ref data, position);
position += 2;
y = CHelpFunctions.byteArrayToInt16(ref data, position);
position += 2;
}
}
return rout;
}
//fügt den Bildern ein einzelnes Bild hinzu
public void addPictureToList(ref byte[] data, CDSAFileLoader.CFileSet NVF, DSAVersion version)
{
if (data == null || NVF == null)
return;
this.itsImages.Add(new KeyValuePair<string, List<Image>>(NVF.filename, this.loadNVF(ref data, NVF, version)));
}
private List<Image> loadAmigaImage(ref byte[] data, CDSAFileLoader.CFileSet NVF, DSAVersion version)
{
List<Image> images = new List<Image>();
int beginOfDataBlock;
int dataBlocklength = 0;
int headerblocklength;
int offset = NVF.startOffset;
//-------------Header auslesen----------------------------
int anzahlBilder = CHelpFunctions.byteArrayToInt16(ref data, offset + 1);
int[] width = new int[anzahlBilder];
int[] height = new int[anzahlBilder];
Int32[] depackLengths = new Int32[anzahlBilder];
Int32 unpackesDataLength = 0;
if ((data[offset] & 0x01) == 0)
headerblocklength = 4;
else
headerblocklength = 8;
int position = offset + 3;
//int helpvalue = 0; //gibt die Länge eines Datenblocks an
if ((data[offset] & 0x01) != 0)
{
//unterschiedliche Auflösungen der Bilder
for (int i = 0; i < anzahlBilder; i++)
{
width[i] = CHelpFunctions.byteArrayToInt16(ref data, position);
height[i] = CHelpFunctions.byteArrayToInt16(ref data, position + 2);
unpackesDataLength += width[i]*height[i];
int value = CHelpFunctions.byteArrayToInt32(ref data, position + 4);
dataBlocklength += value;
depackLengths[i] = value;
position += headerblocklength;
}
}
else
{
//gleiche Auflösungen der Bilder
int tempwidth = CHelpFunctions.byteArrayToInt16(ref data, position);
int tempheight = CHelpFunctions.byteArrayToInt16(ref data, position + 2);
position += 4;
for (int i = 0; i < anzahlBilder; i++)
{
width[i] = tempwidth;
height[i] = tempheight;
unpackesDataLength += tempwidth*tempheight;
int value = CHelpFunctions.byteArrayToInt32(ref data, position);
dataBlocklength += value;
depackLengths[i] = value;
position += headerblocklength;
}
}
beginOfDataBlock = position; //am ende des headers beginnt der Datenblock
//---------Prüfen ob Farbpalette am ende des Datenblocks vorhanden ist-----------------
bool hasFarbpalette = ((beginOfDataBlock + dataBlocklength) < NVF.endOffset);
Color[] colors = null;
if (hasFarbpalette)
{
position = beginOfDataBlock + dataBlocklength;
UInt32 anzahlFarben = (UInt16)CHelpFunctions.byteArrayToInt16(ref data, position);
//---auslesen der Farbpalette---
try
{
position += 2;
colors = new Color[anzahlFarben];
for (int i = 0; i < anzahlFarben; i++)
{
colors[i] = Color.FromArgb((byte)(data[position++] * 4), (byte)(data[position++] * 4), (byte)(data[position++] * 4));
}
}
catch (SystemException)
{
CDebugger.addDebugLine("Fehler beim Laden der Farbpaltte in der Datei " + NVF.filename + " (Amiga)");
return images;
}
}
position = beginOfDataBlock;
CFarbPalette.palettenTyp typ = this.getPalettenTyp(NVF.filename, version);
//---------Bilddaten auslesen-----------
for (int i = 0; i < anzahlBilder; i++)
{
byte[] bytes = CHelpFunctions.unpackAmiga2Data(ref data, position, depackLengths[i]);
Int32 bytePosition = 0;
Bitmap image = new Bitmap(width[i], height[i]);
for (int y = 0; y < image.Height; y++)
{
for (int x = 0; x < image.Width; x++)
{
if (!hasFarbpalette)
{
image.SetPixel(x, y, CFarbPalette.getColor(typ, bytes[bytePosition]));
}
else
image.SetPixel(x, y, colors[bytes[bytePosition] % colors.Length]);
bytePosition++;
}
}
position += depackLengths[i];
images.Add(image);
}
return images;
}
private List<Image> loadUncompressedImage(ref byte[] data, CDSAFileLoader.CFileSet NVF, DSAVersion version)
{
List<Image> images = new List<Image>();
int offset = NVF.startOffset;
int anzahlBilder = CHelpFunctions.byteArrayToInt16(ref data, offset + 1);
int[] width = new int[anzahlBilder];
int[] height = new int[anzahlBilder];
int headerblocklength = 0; //die länge des Variablen Headerblock (Auflösung + gepackte Dateilänge)(8 Bytes) oder (gepackte Dateilänge)(4 Bytes)
int beginOfDataBlock;
int dataBlocklength = 0;
if ((data[offset] & 0x01) == 0)
headerblocklength = 0;
else
headerblocklength = 4;
int position = offset + 3;
//---------bestimmen der Datenblock und Bild Größen-----------------
//int helpvalue = 0; //gibt die Länge eines Datenblocks an
if ((data[offset] & 0x01) != 0)
{
//unterschiedliche Auflösungen der Bilder
for (int i = 0; i < anzahlBilder; i++)
{
width[i] = CHelpFunctions.byteArrayToInt16(ref data, position);
height[i] = CHelpFunctions.byteArrayToInt16(ref data, position + 2);
dataBlocklength += width[i] * height[i];
position += headerblocklength;
}
}
else
{
//gleiche Auflösungen der Bilder
int tempwidth = CHelpFunctions.byteArrayToInt16(ref data, position);
int tempheight = CHelpFunctions.byteArrayToInt16(ref data, position + 2);
position += 4;
for (int i = 0; i < anzahlBilder; i++)
{
width[i] = tempwidth;
height[i] = tempheight;
dataBlocklength += tempwidth * tempheight;
}
}
beginOfDataBlock = position;
bool hasFarbPalette = ((beginOfDataBlock + dataBlocklength) < NVF.endOffset);
position = beginOfDataBlock + dataBlocklength;
Color[] colors = null;
if (hasFarbPalette)
{
int anzahlFarben = CHelpFunctions.byteArrayToInt16(ref data, position);
position += 2;
colors = new Color[anzahlFarben];
for (int i = 0; i < anzahlFarben; i++)
{
colors[i] = Color.FromArgb((byte)(data[position++] * 4), (byte)(data[position++] * 4), (byte)(data[position++] * 4));
}
}
position = beginOfDataBlock;
CFarbPalette.palettenTyp typ = this.getPalettenTyp(NVF.filename, version);
for (int i = 0; i < anzahlBilder; i++)
{
Bitmap image = new Bitmap(width[i], height[i]);
//keine farbpalette
for (int y = 0; y < height[i]; y++)
{
for (int x = 0; x < width[i]; x++)
{
if (hasFarbPalette)
image.SetPixel(x, y, colors[data[position]]);
else
image.SetPixel(x, y, CFarbPalette.getColor(typ, data[position]));
position++;
}
}
images.Add(image);
}
return images;
}
//fügt den Animationen ein Archiv hinzu
public void addArchivToList(ref byte[] data, CDSAFileLoader.CFileSet ARCHIV, CDSAFileLoader.CFileSet TAB, DSAVersion version)
{
if (data == null || ARCHIV == null || TAB == null)
return;
CDebugger.addDebugLine("Bild Archiv " + ARCHIV.filename + " wird geladen. Bitte warten...");
List<Int32> offsets = new List<int>();
//TAB enthält offsets mit Int32
for (Int32 i = TAB.startOffset; i < TAB.endOffset; i += 4)
{
offsets.Add(CHelpFunctions.byteArrayToInt32(ref data, i)); //letzter eintrag in der TAB ist das offset des endes des letzten bildes
}
CDSAFileLoader.CFileSet fileSet;
List<List<Image>> list = new List<List<Image>>(); ;
for (int i = 0; i < offsets.Count - 1; i++)
{
try
{
fileSet = new CDSAFileLoader.CFileSet(ARCHIV.filename, ARCHIV.startOffset + offsets[i], ARCHIV.startOffset + offsets[i + 1]);
list.Add(this.loadNVF(ref data, fileSet, version));
}
catch (SystemException e)
{
CDebugger.addErrorLine("Fehler beim Entpacken des Archivs " + ARCHIV.filename+" Bild "+i.ToString()+": "+e.Message);
}
}
//this.itsImages.Add(new KeyValuePair<string, List<Image>>(ARCHIV.filename, images));
this.itsAnimations.Add(new KeyValuePair<string, List<List<Image>>>(ARCHIV.filename, list));
CDebugger.addDebugLine(list.Count.ToString() + " Animationen wurden aus dem Archiv " + ARCHIV.filename + " geladen");
}
public void addMapInfo(ref byte[] data, CDSAFileLoader.CFileSet mapInfos_INF)
{
}
private List<Image> loadRLEImage(ref byte[] data, CDSAFileLoader.CFileSet NVF, DSAVersion version)
{
List<Image> images = new List<Image>();
int beginOfDataBlock;
int dataBlocklength = 0;
int headerblocklength;
int offset = NVF.startOffset;
//-------------Header auslesen----------------------------
int anzahlBilder = CHelpFunctions.byteArrayToInt16(ref data, offset + 1);
int[] width = new int[anzahlBilder];
int[] height = new int[anzahlBilder];
if ((data[offset] & 0x01) == 0)
headerblocklength = 4;
else
headerblocklength = 8;
int position = offset + 3;
//int helpvalue = 0; //gibt die Länge eines Datenblocks an
if ((data[offset] & 0x01) != 0)
{
//unterschiedliche Auflösungen der Bilder
for (int i = 0; i < anzahlBilder; i++)
{
width[i] = CHelpFunctions.byteArrayToInt16(ref data, position);
height[i] = CHelpFunctions.byteArrayToInt16(ref data, position + 2);
int value = CHelpFunctions.byteArrayToInt32(ref data, position + 4);
dataBlocklength += value;
position += headerblocklength;
}
}
else
{
//gleiche Auflösungen der Bilder
int tempwidth = CHelpFunctions.byteArrayToInt16(ref data, position);
int tempheight = CHelpFunctions.byteArrayToInt16(ref data, position + 2);
position += 4;
for (int i = 0; i < anzahlBilder; i++)
{
width[i] = tempwidth;
height[i] = tempheight;
int value = CHelpFunctions.byteArrayToInt32(ref data, position);
dataBlocklength += value;
position += headerblocklength;
}
}
beginOfDataBlock = position; //am ende des headers beginnt der Datenblock
//---------Prüfen ob Farbpalette am ende des Datenblocks vorhanden ist-----------------
bool hasFarbpalette = ((beginOfDataBlock + dataBlocklength) < NVF.endOffset);
Color[] colors = null;
if (hasFarbpalette)
{
position = beginOfDataBlock + dataBlocklength;
UInt32 anzahlFarben = (UInt16)CHelpFunctions.byteArrayToInt16(ref data, position);
//---auslesen der Farbpalette---
try
{
position += 2;
colors = new Color[anzahlFarben];
for (int i = 0; i < anzahlFarben; i++)
{
colors[i] = Color.FromArgb((byte)(data[position++] * 4), (byte)(data[position++] * 4), (byte)(data[position++] * 4));
}
}
catch (SystemException)
{
CDebugger.addDebugLine("Fehler beim Laden der Farbpaltte in der Datei " + NVF.filename + " (RLE)");
return images;
}
}
position = beginOfDataBlock;
CFarbPalette.palettenTyp typ = this.getPalettenTyp(NVF.filename, version);
//---------Bilddaten auslesen-----------
for (int i = 0; i < anzahlBilder; i++)
{
Bitmap image = new Bitmap(width[i], height[i]);
//---zum Entpacken---
bool unpacking = false; //gibt an, ob gerade entpackt wird
byte wiederholungen = 0;
byte aktuelleWiederholung = 0;
byte value = 0;
//-------------------
for (int y = 0; y < height[i]; y++)
{
for (int x = 0; x < width[i]; x++)
{
if (data[position] != 0x7F && !unpacking)
{
//hier ist keine komopression
if (!hasFarbpalette)
image.SetPixel(x, y, CFarbPalette.getColor(typ, data[position]));
else
image.SetPixel(x, y, colors[data[position] % colors.Length]);
position++;
}
else
{
//entpacken...
if (!unpacking)
{
// starten eines neuen entpackvorgangen
position++;
wiederholungen = data[position++];
aktuelleWiederholung = 0;
value = data[position++];
unpacking = true;
if (!hasFarbpalette)
image.SetPixel(x, y, CFarbPalette.getColor(this.getPalettenTyp(NVF.filename, version), value));
else
image.SetPixel(x, y, colors[value % colors.Length]);
aktuelleWiederholung++;
}
else
{
// es läuft bereits ein entpackvorgang
if (!hasFarbpalette)
image.SetPixel(x, y, CFarbPalette.getColor(this.getPalettenTyp(NVF.filename, version), value));
else
image.SetPixel(x, y, colors[value % colors.Length]);
if (++aktuelleWiederholung >= wiederholungen)
unpacking = false;
}
}
}
}
images.Add(image);
}
return images;
}
//----------------------------------------------------------
private List<Image> loadNVF(ref byte[] data, CDSAFileLoader.CFileSet NVF, DSAVersion version)
{
List<Image> images = new List<Image>();
byte[] unpackedData = null;
CImageHeader header = this.checkForSpezialFile(NVF.filename, version); // header == null wenn es keine spezielle Datei ist und einen eigenen Header besitzt
//----------------------------------------
// schauen ob das Bild gepackt ist
if (checkForAmigaPackedFile(NVF.filename, version))
{
try
{
unpackedData = CHelpFunctions.unpackAmiga2Data(ref data, NVF.startOffset, NVF.endOffset - NVF.startOffset);
NVF.endOffset = unpackedData.Length;
NVF.startOffset = 0;
}
catch (SystemException)
{
CDebugger.addErrorLine("Fehler beim entpacken der Datei " + NVF.filename + " (amiga)");
return images;
}
}
else if (checkForRLEPackedFile(NVF.filename, version))
{
if (header == null)
{
CDebugger.addErrorLine("kein Header für die RLE gepackte Datei " + NVF.filename + " gefunden");
return images;
}
try
{
unpackedData = CHelpFunctions.unpackRLEFile(ref data, NVF.startOffset, NVF.endOffset - NVF.startOffset, (UInt32)(header.height*header.width + 2 + 3*header.anzahlFarben));
NVF.endOffset = unpackedData.Length;
NVF.startOffset = 0;
}
catch (SystemException)
{
CDebugger.addErrorLine("Fehler beim entpacken der Datei " + NVF.filename + " (RLE)");
return images;
}
}
else
unpackedData = data;
//----------------------------------------
int offset = NVF.startOffset;
if (NVF.filename.Substring(0, 4) == "ANIS")
{
images.AddRange(this.loadANISImages(ref data, NVF));
return images;
}
else if (header == null)
{
//header vorhanden
byte crunchmode = unpackedData[offset];
if (crunchmode <= 1)
{
try
{
//unkomrimiert
images.AddRange(this.loadUncompressedImage(ref unpackedData, NVF, version));
}
catch (SystemException)
{
CDebugger.addErrorLine("Fehler beim laden des Bildes: " + NVF.filename + "(Unkomprimiert)");
return images;
}
}
else if (crunchmode == 2 || crunchmode == 3)
{
try
{
//Amiga Power Pack 2.0 Kompression
images.AddRange(this.loadAmigaImage(ref unpackedData, NVF, version));
}
catch (SystemException)
{
CDebugger.addErrorLine("Fehler beim laden des Bildes: " + NVF.filename + "(Amiga)");
return images;
}
}
else if (crunchmode == 4 || crunchmode == 5)
{
try
{
//RLE Kompression
images.AddRange(this.loadRLEImage(ref unpackedData, NVF, version));
}
catch (SystemException)
{
CDebugger.addErrorLine("Fehler beim laden des Bildes: " + NVF.filename + "(RLE)");
return images;
}
}
else
{
CDebugger.addErrorLine("Unbekannter Crunchmode: " + crunchmode.ToString() + " in der Datei " + NVF.filename);
return images;
}
}
else
{
//Bild ist nicht gepackt
//besitzt aber auch keinen Header und beginnt direkt mit den Bilddaten
try
{
images.AddRange(this.loadImageWithoutHeader(ref unpackedData, NVF, header, version));
}
catch (SystemException)
{
CDebugger.addErrorLine("Fehler beim laden des Bildes: " + NVF.filename + "(kein Header)");
return images;
}
}
return images;
}
private void loadDSA1(ref byte[] data, CDSAFileLoader.CFileSet TLK)
{
int position = TLK.startOffset;
Int32 offsetTextBlock = TLK.startOffset + CHelpFunctions.byteArrayToInt32(ref data, position) + 6; //warum +6--> weil header genau 6 bytes hat
position += 4;
Int16 anzahlGesprächspartner = CHelpFunctions.byteArrayToInt16(ref data, position);
position += 2;
for (int i = 0; i < anzahlGesprächspartner; i++)
{
this.itsDSA1Partner.Add(new CGesprächspartner(ref data, position, DSAVersion.Schick));
position += 38;
}
while (position < offsetTextBlock)
{
this.itsDSA1DialogZeile.Add(new CDialogLayoutZeile(ref data, position));
position += 8;
}
position = offsetTextBlock;
do
{
string text = CHelpFunctions.readDSAString(ref data, position, 0);
this.itsTexte.Add(text);
position += text.Length + 1;
}
while (position < TLK.endOffset);
}
/**
* Spezial-Ladefunktion für ANIS
*/
private List<Image> loadANISImages(ref byte[] data, CDSAFileLoader.CFileSet NVF)
{
List<Image> images = new List<Image>();
int position = NVF.startOffset;
// ANIS-Header einlesen
int imagedataoffset = CHelpFunctions.byteArrayToInt32(ref data, position);
int paletteoffset = CHelpFunctions.byteArrayToInt32(ref data, position+4);
int iwidth = CHelpFunctions.byteArrayToInt16(ref data, position+8);
int iheight = (int)data[position + 10];
int numelements = (int)data[position + 11]; //Anzahl der Subelemente auslesen
//Offsets der Subelemente auslesen
List<int> elementoffsets = new List<int>(numelements);
position = NVF.startOffset + 12;
for (int i = 0; i < numelements; i++)
{
elementoffsets.Add(CHelpFunctions.byteArrayToInt32(ref data, position));
position += 4;
}
//Subelement infos auslesen
List<CBOBElement> subElements = new List<CBOBElement>(numelements);
foreach (int offset in elementoffsets)
{
subElements.Add(new CBOBElement(ref data, NVF.startOffset + offset));
}
// Farbpalette auslesen
Color[] colors = null;
position = NVF.startOffset + paletteoffset + 6; //Anzahl der Farben steht nicht drin, sondern muss berechnet werden
int anzahlFarben = (NVF.endOffset - position) / 3;
try
{
colors = new Color[anzahlFarben];
for (int i = 0; i < anzahlFarben; i++)
{
colors[i] = Color.FromArgb(Math.Min(255, data[position++] * 4), Math.Min(255, data[position++] * 4), Math.Min(255, data[position++] * 4));
}
}
catch (SystemException e)
{
CDebugger.addErrorLine("Fehler beim laden der Farbpalette der Datei " + NVF.filename + ": " + e.Message);
return images;
}
//////////////////////////////////////
// Hauptbild entpacken //
//////////////////////////////////////
position = NVF.startOffset + imagedataoffset;
int packedLength = CHelpFunctions.byteArrayToInt32(ref data, position);
bool packed = true;
byte[] bytes = null;
if (packedLength > iwidth * iheight)
{
// daten dürften ungepackt sein
bytes = new byte[iwidth * iheight];
Buffer.BlockCopy(data, position, bytes, 0, iwidth * iheight);
packed = false;
}
else
bytes = CHelpFunctions.unpackAmiga2Data(ref data, position, packedLength);
Bitmap image = new Bitmap(iwidth, iheight);
int positionInUnpackedData = 0;
int x = 0, y = 0;
try
{
for (y = 0; y < iheight; y++)
{
for (x = 0; x < iwidth; x++)
{
image.SetPixel(x, y, colors[bytes[positionInUnpackedData] % colors.Length]);
positionInUnpackedData++;
}
}
}
catch (SystemException e)
{
CDebugger.addErrorLine("Fehler beim Bild befüllen auf " + x + "/" + y + ", position " + positionInUnpackedData + ", Größe " + bytes.Length + ": " + e.Message);
}
images.Add(image);
if (packed)
position += packedLength;
else
position += (iwidth * iheight);
//////////////////////////////////////
// Subelemente entpacken //
//////////////////////////////////////
//int bobCount = 0;
foreach (CBOBElement bob in subElements)
{
//bobCount++;
//CDebugger.addDebugLine("BobCount: " + bobCount.ToString() + "/" + subElements.Count);
packedLength = CHelpFunctions.byteArrayToInt32(ref data, position);
positionInUnpackedData = 0;
//prüfen ob die Daten gepackt sind...falls es mal Probleme gibt, könnte man auch einfach Versuchen sie zu entpacken und dann auf "null" zu prüfen
if (packedLength > bob.width * bob.height * bob.bilder.Count)
{
// daten dürften ungepackt sein
bytes = new byte[bob.width * bob.height * bob.bilder.Count];
Buffer.BlockCopy(data, position, bytes, 0, bob.width * bob.height * bob.bilder.Count);
packed = false;
}
else
bytes = CHelpFunctions.unpackAmiga2Data(ref data, position, packedLength);
foreach (CBOBElement.CEinzelbild einzelbild in bob.bilder)
{
image = new Bitmap(bob.width, bob.height);
try
{
for (y = 0; y < bob.height; y++)
{
for (x = 0; x < bob.width; x++)
{
image.SetPixel(x, y, colors[bytes[positionInUnpackedData++] % colors.Length]);
}
}
images.Add(image);
}
catch (SystemException e)
{
CDebugger.addErrorLine("Fehler beim Bild befüllen auf " + x.ToString() + "/" + y.ToString() + ", position " + positionInUnpackedData + ", Größe " + bytes.Length + ": " + e.Message);
}
}
if (packed)
position += packedLength;
else
position += (bob.width * bob.height * bob.bilder.Count);
}
return images;
}
private void addTexture(ref byte[] data, CDSAFileLoader.CFileSet NVF)
{
try
{
Int32 currentPosition = NVF.startOffset;
while (currentPosition < NVF.endOffset - 4)
{
if (data[currentPosition] == 'R' && data[currentPosition + 1] == 'O' && data[currentPosition + 2] == 'H' && data[currentPosition + 3] == 0)
break;
else
currentPosition++;
}
currentPosition += 4;
int width = (CHelpFunctions.byteArrayToInt16(ref data, currentPosition) + 1);
currentPosition += 2;
int height = (CHelpFunctions.byteArrayToInt16(ref data, currentPosition) + 1);
currentPosition += 2;
int colorCount = CHelpFunctions.byteArrayToInt16(ref data, currentPosition);
currentPosition += 2;
if (colorCount <= 0)
{
CDebugger.addErrorLine("unable to load textrue " + NVF.filename + Environment.NewLine + "header error");
return;
}
Color[] colors = new Color[colorCount];
for (int i = 0; i < colors.Length; i++)
{
int r = data[currentPosition++];
int g = data[currentPosition++];
int b = data[currentPosition++];
if (r > 64 || g > 64 || b > 64)
{
CDebugger.addErrorLine("the color of texture " + NVF.filename + " is out of range");
}
colors[i] = Color.FromArgb(r*4, g*4, b*4);
}
Bitmap image = new Bitmap(width, height);
for (int y = 0; y < image.Height; y++)
{
for (int x = 0; x < image.Width; x++)
{
image.SetPixel(x, y, colors[data[currentPosition]]);
currentPosition++;
}
}
this.itsTextures.Add(new KeyValuePair<string, Image>(NVF.filename, image));
}
catch (Exception e)
{
CDebugger.addErrorLine("unable to load textrue " + NVF.filename + Environment.NewLine +e.Message);
}
}
private void loadDSA2_dialog(ref byte[] data, CDSAFileLoader.CFileSet TLK)
{
int position = TLK.startOffset;
Int16 numberDialogs = CHelpFunctions.byteArrayToInt16(ref data, position);
position += 2;
List<CGesprächspartner> partner = new List<CGesprächspartner>(numberDialogs);
for (int i = 0; i < numberDialogs; i++)
{
partner.Add(new CGesprächspartner(ref data, position, DSAVersion.Schweif));
position += 12;
}
for (int i = 0; i < numberDialogs; i++)
{
int numberLayouts = CHelpFunctions.byteArrayToInt16(ref data, position);
position += 2;
List<CDialogLayoutZeile> layout = new List<CDialogLayoutZeile>(numberLayouts);
for (int j = 0; j < numberLayouts; j++)
{
layout.Add(new CDialogLayoutZeile(ref data, position));
position += 8;
}
this.itsDSA2Dialog.Add(new KeyValuePair<CGesprächspartner, List<CDialogLayoutZeile>>(partner[i], layout));
}
position += 4;
do
{
string text = CHelpFunctions.readDSAString(ref data, position, 0);
this.itsTexte.Add(text);
position += text.Length + 1;
}
while (position < TLK.endOffset);
}
private void loadDSA2_info(ref byte[] data, CDSAFileLoader.CFileSet TLK)
{
int length = TLK.endOffset - TLK.startOffset;
if (length <= 0)
{
CDebugger.addErrorLine("Fehler beim Laden des Info Dialogs " + TLK.filename + " (offset Problem)");
return;
}
Byte[] bytes = new byte[TLK.endOffset - TLK.startOffset];
Array.Copy(data, TLK.startOffset, bytes, 0, length);
List<byte> converted = new List<byte>(bytes);
for (int i = bytes.Length - 1; i >= 0; i--)
{
switch (bytes[i])
{
case 129:
converted.RemoveAt(i);
converted.InsertRange(i, new Byte[] { 117, 101 }); //ü -> ue
break;
case 132:
converted.RemoveAt(i);
converted.InsertRange(i, new Byte[] { 97, 101 }); //ä -> ae
break;
case 142:
converted.RemoveAt(i);
converted.InsertRange(i, new Byte[] { 64, 69 }); //Ä -> AE
break;
case 148:
converted.RemoveAt(i);
converted.InsertRange(i, new Byte[] { 111, 101 }); //ö -> oe
break;
case 153:
converted.RemoveAt(i);
converted.InsertRange(i, new Byte[] { 79, 69 }); //Ö -> OE
break;
case 154:
converted.RemoveAt(i);
converted.InsertRange(i, new Byte[] { 85, 69 }); //Ü -> UE
break;
case 225:
converted.RemoveAt(i);
converted.InsertRange(i, new Byte[] { 115, 115 }); //ß -> ss
break;
}
}
bytes = converted.ToArray();
DSA2InfoDialog infoDialog = new DSA2InfoDialog();
DSA2InfoDialog.TOPIC topic = null;
try
{
using (StreamReader reader = new StreamReader(new MemoryStream(bytes)))
{
string line;
bool currentlyReadingATopic = false;
while ((line = reader.ReadLine()) != null)
{
string[] values;
if (line.Contains("#"))
values = getSubStringsFromStringLine(line.Substring(0, line.IndexOf('#')));
else
values = getSubStringsFromStringLine(line);
if (values.Length <= 0)
continue;
if (currentlyReadingATopic)
{
if (values[0] == "TOPIC")
{
if (topic != null)
infoDialog.itsTopics.Add(topic);
topic = new DSA2InfoDialog.TOPIC();
topic.NAME = values[1];
}
else if (values[0] == "END")
{
if (topic != null)
infoDialog.itsTopics.Add(topic);
topic = null;
break;
}
else if (values.Length == 3)
{
DSA2InfoDialog.TOPIC.TOPICLine topicLine = new DSA2InfoDialog.TOPIC.TOPICLine();
topicLine.value_1 = Convert.ToInt32(values[0]);
topicLine.valie_2 = Convert.ToInt32(values[1]);
topicLine.text = values[2];
topic.itsTopics.Add(topicLine);
}
else if (values.Length == 1)
{
topic.itsTopics[topic.itsTopics.Count - 1].text += Environment.NewLine + values[0];
}
else
{
CDebugger.addErrorLine("Fehler beim laden des Dialogs " + TLK.filename + " (Unerwarteter Zustand beim lesen eines TOPICS)");
break;
}
}
else
{
if (values[0] == "PIC")
{
infoDialog.PIC = Convert.ToInt32(values[1]);
}
else if (values[0] == "TOLERANCE")
{
infoDialog.TOLERANCE = Convert.ToInt32(values[1]);
}
else if (values[0] == "NAME")
{
infoDialog.Name = values[1];
}
else if (values[0] == "TOPIC")
{
currentlyReadingATopic = true;
if (topic != null)
infoDialog.itsTopics.Add(topic);
topic = new DSA2InfoDialog.TOPIC();
topic.NAME = values[1];
}
else
{
CDebugger.addErrorLine("Fehler beim laden des Dialogs " + TLK.filename + " (Unbekannte Konstante " + values[0] + ")");
continue;
}
}
}
if (topic != null)
infoDialog.itsTopics.Add(topic);
this.itsDSA2InfoDialog = infoDialog;
}
}
catch (SystemException e)
{
CDebugger.addErrorLine("Fehler beim Laden des Dialogs " + TLK.filename + Environment.NewLine + e.ToString());
}
this.isDSA2InfoDialog = true;
}
public CDungeon(ref byte[] data, CDSAFileLoader.CFileSet dungeon, CDSAFileLoader.CFileSet dungeonEvent)
{
this.floors.Clear();
this.fights.Clear();
this.doors.Clear();
this.stairs.Clear();
Int32 position = dungeon.startOffset;
Int32 blockLength = 16*20;
while ((position + blockLength) <= dungeon.endOffset)
{
this.floors.Add(new CFloor(ref data, position));
position += blockLength;
}
//-------------Kämpfe-------
position = dungeonEvent.startOffset + 4;
blockLength = 14;
while ((position + blockLength) <= dungeonEvent.endOffset)
{
//auf ende Prüfen
if ((data[position] == 0xFF) && (data[position + 1] == 0xFF))
{
bool end = true;
for (int i = position + 2; i < (position + blockLength); i++)
{
if (data[i] != 0)
end = false;
}
if (end)
{
position += blockLength;
break;
}
}
//---------------------------
this.fights.Add(new CDungeonFight(ref data, position));
position += blockLength;
}
//-------------Türen-------
blockLength = 5;
while ((position + blockLength) <= dungeonEvent.endOffset)
{
//auf ende Prüfen
if ((data[position] == 0xFF) && (data[position + 1] == 0xFF))
{
bool end = true;
for (int i = position + 2; i < (position + blockLength); i++)
{
if (data[i] != 0)
end = false;
}
if (end)
{
position += blockLength;
break;
}
}
//---------------------------
this.doors.Add(new CDungeonDoor(ref data, position));
position += blockLength;
}
//-------------Treppen-------
blockLength = 4;
while ((position + blockLength) <= dungeonEvent.endOffset)
{
//auf ende Prüfen
if ((data[position] == 0xFF) && (data[position + 1] == 0xFF))
{
bool end = true;
for (int i = position + 2; i < (position + blockLength); i++)
{
if (data[i] != 0)
end = false;
}
if (end)
{
position += blockLength;
break;
}
}
//---------------------------
this.stairs.Add(new CDungeonStair(ref data, position));
position += blockLength;
}
}
private List<Image> loadImageWithoutHeader(ref byte[] data, CDSAFileLoader.CFileSet NVF, CImageHeader header, DSAVersion version)
{
List<Image> images = new List<Image>();
if (header == null)
{
CDebugger.addErrorLine("Fehler beim laden der Datei " + NVF.filename + " (es wurde kein Header übergeben)");
return images;
}
//int position = NVF.startOffset + header.height * header.width;
int position = NVF.endOffset - header.anzahlFarben*3 - 2;
Color[] colors = null;
int helpvalue = 0;
int anzahlFarben = 0;
if (header.anzahlFarben != 0)
{
anzahlFarben = CHelpFunctions.byteArrayToInt16(ref data, position);
if (anzahlFarben != header.anzahlFarben)
CDebugger.addErrorLine("Anzahl der Farben in der Datei " + NVF.filename + " wurde nicht korrekt angegeben (" + anzahlFarben.ToString() + ")");
helpvalue = 2;
position += 2;
try
{
colors = new Color[anzahlFarben];
for (int i = 0; i < anzahlFarben; i++)
{
colors[i] = Color.FromArgb((byte)(data[position++] * 4), (byte)(data[position++] * 4), (byte)(data[position++] * 4));
}
}
catch(SystemException)
{
CDebugger.addErrorLine("Fehler beim Laden der Farbpaltte in der Datei " + NVF.filename + " (kein Header)");
return images;
}
}
position = NVF.startOffset;
CFarbPalette.palettenTyp typ = this.getPalettenTyp(NVF.filename, version);
while ((position + header.height*header.width + anzahlFarben + helpvalue) <= NVF.endOffset) //solange das ende der Datei nicht erreicht ist, sind noch bilder vorhanden
{
Bitmap image = new Bitmap(header.width, header.height);
for (int y = 0; y < header.height; y++)
{
for (int x = 0; x < header.width; x++)
{
if (header.anzahlFarben == 0)
image.SetPixel(x, y, CFarbPalette.getColor(typ, data[position]));
else
image.SetPixel(x, y, colors[data[position] % colors.Length]);
position++;
}
}
images.Add(image);
}
return images;
}
public void addMap(ref byte[] data, CDSAFileLoader.CFileSet mapLayout_MAD)
{
int position = mapLayout_MAD.startOffset;
if (mapLayout_MAD.endOffset < (position + 4))
return;
this._width = CHelpFunctions.byteArrayToInt16(ref data, position);
position += 2;
this._deepth = CHelpFunctions.byteArrayToInt16(ref data, position);
position += 2;
this._Map = new SMADLayout[this._width, this._deepth];
for (int y = 0; y < this._deepth; y++)
{
for (int x = 0; x < this._width; x++)
{
this._Map[x, y] = new SMADLayout(data[position], data[position + 1]);
position += 2;
if (mapLayout_MAD.endOffset < position)
break;
}
if (mapLayout_MAD.endOffset < position)
break;
}
}
public void addKämpfe(ref byte[] data, CDSAFileLoader.CFileSet fight_lst)
{
this.itsFight_LST.Clear();
if (data == null)
return;
if (fight_lst != null)
{
Int32 blockLength = 216;
Int32 AnzahlEinträge = CHelpFunctions.byteArrayToInt16(ref data, 0);
Int32 counter = 0;
Int32 position = fight_lst.startOffset + 2;
while (((position + blockLength) < fight_lst.endOffset) && (counter < AnzahlEinträge))
{
this.itsFight_LST.Add(new CFight_LST(ref data, position));
position += blockLength;
counter++;
}
CDebugger.addDebugLine("Kampf: FIGHT.LST wurde erfolgreich extrahiert");
}
else
CDebugger.addDebugLine("Kampf: FIGHT.LST konnte nicht extrahiert werden");
}
//-----------------------------------------
public CDialog(ref byte[] data, CDSAFileLoader.CFileSet TLK, DSAVersion version)
{
this.itsDSA1DialogZeile.Clear();
this.itsDSA1Partner.Clear();
this.itsTexte.Clear();
if (data == null || TLK == null)
return;
switch (version)
{
case DSAVersion.Blade:
case DSAVersion.Schick:
this.loadDSA1(ref data, TLK);
break;
case DSAVersion.Schweif:
bool found = false;
for (int i = TLK.startOffset; i < (TLK.endOffset - 3); i++)
{
if (data[i] == 'P' && data[i + 1] == 'I' && data[i + 2] == 'C')
{
found = true;
break;
}
}
if (found)
this.loadDSA2_info(ref data, TLK);
else
this.loadDSA2_dialog(ref data, TLK);
break;
}
}
