public void addDialoge(ref byte[] data, List<CDSAFileLoader.CFileSet> TLKs, DSAVersion version)
{
foreach (CDSAFileLoader.CFileSet set in TLKs)
{
this.itsDialoge.Add(new KeyValuePair<string, CDialog>(set.filename, new CDialog(ref data, set, version)));
}
CDebugger.addDebugLine("Dialoge wurden erfolgreich geladen");
}
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");
}
public Image getMonsterImageByID(Int32 MonsterBildID, DSAVersion version)
{
switch (version)
{
case DSAVersion.Blade:
case DSAVersion.Schick:
return this.getMonsterImageByID_DSA_1(MonsterBildID);
case DSAVersion.Schweif:
return this.getMonsterImageByID_DSA_2(MonsterBildID);
default:
return null;
}
}
//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)));
}
public void addPictures(ref byte[] MAIN_DAT, List<CDSAFileLoader.CFileSet> MAIN_NVFs, DSAVersion version)
{
if (MAIN_DAT == null || MAIN_NVFs == null)
return;
if (MAIN_NVFs.Count == 0)
CDebugger.addDebugLine("Bilder: keine NVF Dateien gefunden");
else
CDebugger.addDebugLine("Bilder: es wurden " + MAIN_NVFs.Count.ToString() + " NVF Dateien gefunden");
foreach (CDSAFileLoader.CFileSet fileset in MAIN_NVFs)
{
this.itsImages.Add(new KeyValuePair<string, List<Image>>(fileset.filename, this.loadNVF(ref MAIN_DAT, fileset, version)));
}
}
//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");
}
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;
}
private CFarbPalette.palettenTyp getPalettenTyp(string filename, DSAVersion version)
{
switch (version)
{
case DSAVersion.Blade:
case DSAVersion.Schick:
foreach (string s in itsTownPictures_SCHICK)
{
if (s == filename)
return CFarbPalette.palettenTyp.Town_Pal;
}
foreach (string s in itsFightPictures_SCHICK)
{
if (s == filename)
return CFarbPalette.palettenTyp.Fight_Pal;
}
foreach (string s in itsCharMenüPictures_SCHICK)
{
if (s == filename)
return CFarbPalette.palettenTyp.CharMenü_Pal;
}
if (filename == "ATTIC")
return CFarbPalette.palettenTyp.Logo_Attic;
if (filename == "DSALOGO.DAT")
return CFarbPalette.palettenTyp.GEN_Pal;
if (filename == "GENTIT.DAT")
return CFarbPalette.palettenTyp.GEN_Pal;
if (filename == "ROALOGUS.DAT")
return CFarbPalette.palettenTyp.GEN_Pal;
return CFarbPalette.palettenTyp.default_Pal;
case DSAVersion.Schweif:
return CFarbPalette.palettenTyp.default_Pal;
default:
return CFarbPalette.palettenTyp.default_Pal;
}
}
public CMonsterStats(ref byte[] data, Int32 position, DSAVersion version)
{
switch (version)
{
case DSAVersion.Blade:
case DSAVersion.Schick:
this.MonsterID = data[position];
this.MonsterGraphicID = data[position + 1];
this.RS = (sbyte)data[position + 2];
this.MU_Würfel[0] = data[position + 3]; this.MU_Würfel[1] = data[position + 4];
this.KL_Würfel[0] = data[position + 5]; this.KL_Würfel[1] = data[position + 6];
this.CH_Würfel[0] = data[position + 7]; this.CH_Würfel[1] = data[position + 8];
this.FF_Würfel[0] = data[position + 9]; this.FF_Würfel[1] = data[position + 10];
this.GE_Würfel[0] = data[position + 11]; this.GE_Würfel[1] = data[position + 12];
this.IN_Würfel[0] = data[position + 13]; this.IN_Würfel[1] = data[position + 14];
this.KK_Würfel[0] = data[position + 15]; this.KK_Würfel[1] = data[position + 16];
this.LE_Würfel[0] = data[position + 17]; this.LE_Würfel[1] = data[position + 18];
this.AE_Würfel[0] = data[position + 19]; this.AE_Würfel[1] = data[position + 20];
this.MR_Würfel[0] = data[position + 21]; this.MR_Würfel[1] = data[position + 22];
this.erstAP = data[position + 23];
this.Anzahl_Attacken = data[position + 24];
this.AT = (sbyte)data[position + 25];
this.PA = (sbyte)data[position + 26];
this.Schaden_1_Angriff_Würfel[0] = data[position + 27]; this.Schaden_1_Angriff_Würfel[1] = data[position + 28];
this.Schaden_2_Angriff_Würfel[0] = data[position + 29]; this.Schaden_2_Angriff_Würfel[1] = data[position + 30];
this.BP = data[position + 31];
this.Immunität_gegen_Normale_Waffen = data[position + 32];
this.ID_Magierklasse = (sbyte)data[position + 33];
this.Stufe = data[position + 34];
this.Größenklasse = data[position + 35];
this.MonsterTyp = data[position + 36];
this.Anzahl_Geschosse = data[position + 37];
this.Schaden_Schusswaffen_Würfel[0] = data[position + 38]; this.Schaden_Schusswaffen_Würfel[1] = data[position + 39];
this.Anzahl_Wurfwaffen = data[position + 40];
this.Schaden_Wurfwaffen_Würfel[0] = data[position + 41]; this.Schaden_Wurfwaffen_Würfel[1] = data[position + 42];
this.Flucht_Bei_XX_LP = data[position + 43];
break;
case DSAVersion.Schweif:
this.MonsterID = data[position];
this.MonsterGraphicID = data[position + 1];
this.RS = (sbyte)data[position + 2];
this.unbekannterWert_1_DSA_2 = data[position + 3];
this.MU_Würfel[0] = data[position + 4]; this.MU_Würfel[1] = data[position + 5];
this.KL_Würfel[0] = data[position + 6]; this.KL_Würfel[1] = data[position + 7];
this.CH_Würfel[0] = data[position + 8]; this.CH_Würfel[1] = data[position + 9];
this.FF_Würfel[0] = data[position + 10]; this.FF_Würfel[1] = data[position + 11];
this.GE_Würfel[0] = data[position + 12]; this.GE_Würfel[1] = data[position + 13];
this.IN_Würfel[0] = data[position + 14]; this.IN_Würfel[1] = data[position + 15];
this.KK_Würfel[0] = data[position + 16]; this.KK_Würfel[1] = data[position + 17];
this.LE_Würfel[0] = data[position + 18]; this.LE_Würfel[1] = data[position + 19];
this.AE_Würfel[0] = data[position + 20]; this.AE_Würfel[1] = data[position + 21];
this.MR_Würfel[0] = data[position + 22]; this.MR_Würfel[1] = data[position + 23];
this.erstAP = data[position + 24];
this.Anzahl_Attacken = data[position + 25];
this.AT = (sbyte)data[position + 26];
this.PA = (sbyte)data[position + 27];
this.Schaden_1_Angriff_Würfel[0] = data[position + 28]; this.Schaden_1_Angriff_Würfel[1] = data[position + 29];
this.Schaden_2_Angriff_Würfel[0] = data[position + 30]; this.Schaden_2_Angriff_Würfel[1] = data[position + 31];
this.BP = data[position + 32];
this.Immunität_gegen_Normale_Waffen = data[position + 33];
this.ID_Magierklasse = (sbyte)data[position + 34];
this.Stufe = data[position + 35];
this.Größenklasse = data[position + 36];
this.MonsterTyp = data[position + 37];
this.unbekannterWert_2_DSA_2 = data[position + 38];
this.unbekannterWert_3_DSA_2 = data[position + 39];
//-------------------------------------------
this.Anzahl_Geschosse = data[position + 40];
this.Schaden_Schusswaffen_Würfel[0] = data[position + 41]; this.Schaden_Schusswaffen_Würfel[1] = data[position + 42];
this.Anzahl_Wurfwaffen = data[position + 43];
this.Schaden_Wurfwaffen_Würfel[0] = data[position + 44]; this.Schaden_Wurfwaffen_Würfel[1] = data[position + 45];
this.Flucht_Bei_XX_LP = data[position + 46];
this.unbekannterWert_4_DSA_2 = data[position + 47];
break;
}
}
public string AnziehbarAnPositionToString(DSAVersion version)
{
switch (version)
{
case DSAVersion.Blade:
case DSAVersion.Schick:
if ((this.ItemTyp & 0x01) != 0)
{
switch (this.AnziehbarAnPosition)
{
case 0:
return ("Kopf(" + AnziehbarAnPosition.ToString() + ")");
case 1:
return ("Arme(" + AnziehbarAnPosition.ToString() + ")");
case 2:
return ("Brust(" + AnziehbarAnPosition.ToString() + ")");
case 5:
return ("Beine(" + AnziehbarAnPosition.ToString() + ")");
case 6:
return ("Schuhe(" + AnziehbarAnPosition.ToString() + ")");
case 9:
return ("Schildhand(" + AnziehbarAnPosition.ToString() + ")");
}
}
else if ((this.ItemTyp & 0x02) != 0)
{
switch (this.AnziehbarAnPosition)
{
case 0:
return ("Waffenlos(Pfeile|Bolzen)(" + AnziehbarAnPosition.ToString() + ")");
case 1:
return ("Hiebwaffe(" + AnziehbarAnPosition.ToString() + ")");
case 2:
return ("Stichwaffe(" + AnziehbarAnPosition.ToString() + ")");
case 3:
return ("Schwerter(" + AnziehbarAnPosition.ToString() + ")");
case 4:
return ("Äxte(" + AnziehbarAnPosition.ToString() + ")");
case 5:
return ("Speere(" + AnziehbarAnPosition.ToString() + ")");
case 6:
return ("Zweihänder(" + AnziehbarAnPosition.ToString() + ")");
case 7:
return ("Schusswaffe(" + AnziehbarAnPosition.ToString() + ")");
case 8:
return ("Wurfwaffe(" + AnziehbarAnPosition.ToString() + ")");
}
}
else if (AnziehbarAnPosition == 0)
return ("Gegenstand(" + AnziehbarAnPosition.ToString() + ")");
break;
//-------------------------------------------------------------
case DSAVersion.Schweif:
if ((this.ItemTyp & 0x01) != 0)
{
switch (this.AnziehbarAnPosition)
{
case 0:
return ("Kopf(" + AnziehbarAnPosition.ToString() + ")");
case 1:
return ("Arme(" + AnziehbarAnPosition.ToString() + ")");
//case 2:
// return ("Brust(" + AnziehbarAnPosition.ToString() + ")");
case 5:
return ("Beine(" + AnziehbarAnPosition.ToString() + ")");
//case 6:
// return ("Schuhe(" + AnziehbarAnPosition.ToString() + ")");
case 9:
return ("Schildhand(" + AnziehbarAnPosition.ToString() + ")");
case 10:
return ("Brust(" + AnziehbarAnPosition.ToString() + ")");
case 14:
return ("Schuhe(" + AnziehbarAnPosition.ToString() + ")");
}
}
else if ((this.ItemTyp & 0x02) != 0)
{
switch (this.AnziehbarAnPosition)
{
case 0:
return ("Waffenlos(Pfeile|Bolzen)(" + AnziehbarAnPosition.ToString() + ")");
case 1:
return ("Hiebwaffe(" + AnziehbarAnPosition.ToString() + ")");
case 2:
return ("Stichwaffe(" + AnziehbarAnPosition.ToString() + ")");
case 3:
return ("Schwerter(" + AnziehbarAnPosition.ToString() + ")");
case 4:
return ("Äxte(" + AnziehbarAnPosition.ToString() + ")");
case 5:
return ("Speere(" + AnziehbarAnPosition.ToString() + ")");
case 6:
return ("Zweihänder(" + AnziehbarAnPosition.ToString() + ")");
case 7:
return ("Schusswaffe(" + AnziehbarAnPosition.ToString() + ")");
case 8:
return ("Wurfwaffe(" + AnziehbarAnPosition.ToString() + ")");
}
}
else if ((this.ItemTyp & 0x08) != 0)
{
switch (this.AnziehbarAnPosition)
{
case 0:
return ("Trinken(" + AnziehbarAnPosition.ToString() + ")");
case 1:
return ("Essen(" + AnziehbarAnPosition.ToString() + ")");
}
}
else if ((this.ItemTyp & 0x20) != 0)
{
switch (this.AnziehbarAnPosition)
{
case 0:
return ("Kräuter(" + AnziehbarAnPosition.ToString() + ")");
case 1:
return ("Trank(" + AnziehbarAnPosition.ToString() + ")");
}
}
else if (AnziehbarAnPosition == 0)
return ("Gegenstand(" + AnziehbarAnPosition.ToString() + ")");
break;
}
return ("???(" + AnziehbarAnPosition.ToString() + ")");
}
public CItem(ref byte[] data, int position, DSAVersion version)
{
switch (version)
{
case DSAVersion.Blade:
case DSAVersion.Schick:
this.IconID = CHelpFunctions.byteArrayToInt16(ref data, position);
this.ItemTyp = data[position + 2];
this.AnziehbarAnPosition = data[position + 3];
this.Gewicht = CHelpFunctions.byteArrayToInt16(ref data, position + 5);
this.Preis_Grundeinheit = data[position + 7];
this.Preis = CHelpFunctions.byteArrayToInt16(ref data, position + 8);
this.SortimentsID = data[position + 10];
this.Magisch = data[position + 11];
break;
case DSAVersion.Schweif:
this.IconID = CHelpFunctions.byteArrayToInt16(ref data, position);
this.ItemTyp = data[position + 2];
//position 3 + 5 sind noch unbekannt
this.erweiterterTyp = data[position + 3];
this.AnziehbarAnPosition = data[position + 4];
this.unbekannt_2_DSA2 = data[position + 5];
this.Gewicht = CHelpFunctions.byteArrayToInt16(ref data, position + 6);
this.Preis = CHelpFunctions.byteArrayToInt16(ref data, position + 8);
this.Preis_Grundeinheit = data[position + 10];
this.SortimentsID = data[position + 11];
this.Magisch = data[position + 12];
break;
}
}
//---------------------------------
public CGesprächspartner(ref byte[] data, Int32 position, DSAVersion version)
{
switch (version)
{
case DSAVersion.Blade:
case DSAVersion.Schick:
this.loadDSA1(ref data, position);
break;
case DSAVersion.Schweif:
this.loadDSA2(ref data, position);
break;
}
}
private bool checkForRLEPackedFile(string filename, DSAVersion version)
{
switch(version)
{
case DSAVersion.Blade:
case DSAVersion.Schick:
foreach (string s in this.itsRLEPackedFiles_DSAGEN)
{
if (s == filename)
return true;
}
return false;
case DSAVersion.Schweif:
foreach (string s in this.itsRLEPackedFiles_SCHWEIF)
{
if (s == filename)
return true;
}
return false;
default:
return false;
}
}
public bool unpackAll(string directoryPath)
{
CDebugger.clearDebugText();
this.itsDSAGENOffsets.Clear();
this.itsSCHICKFilenames.Clear();
this.itsSCHICKOffsets.Clear();
this.SCHICK_DAT = null;
this.DSAGEN_DAT = null;
foreach (DSA2_Archiv archiv in this.DSA2_Archive)
{
archiv.data_Install = null;
archiv.data_CD = null;
archiv.entries_Install.Clear();
archiv.entries_CD.Clear();
}
bool found = false;
List<string> files = new List<string>();
files.AddRange(Directory.GetFiles(directoryPath));
if (files.Count == 0)
{
CDebugger.addErrorLine("keine .exe Dateien gefunden");
return false;
}
foreach (string filepath in files)
{
if (String.Compare("SCHICKM.EXE", Path.GetFileName(filepath), true) == 0)
{
Properties.Settings.Default.DefaultDSAPath = directoryPath;
Properties.Settings.Default.Save();
CDebugger.addDebugLine("SCHICKM.EXE wurde erkannt ");
this.loadFilenames_DSA_1(filepath); // dateinamen sind in der exe verankert
foreach (string s in files)
{
if (this.SCHICK_DAT == null && String.Compare("SCHICK.DAT", Path.GetFileName(s), true) == 0)
this.unpack_SCHICK(s);
if (this.DSAGEN_DAT == null && String.Compare("DSAGEN.DAT", Path.GetFileName(s), true) == 0)
this.unpack_DSAGEN(s);
}
if (this.SCHICK_DAT == null || this.DSAGEN_DAT == null)
{
CDebugger.addErrorLine("Fehler beim laden der .DAT Dateien");
return false;
}
found = true;
this._version = DSAVersion.Schick;
break;
}
else if (String.Compare("BLADEM.EXE", Path.GetFileName(filepath), true) == 0)
{
Properties.Settings.Default.DefaultDSAPath = directoryPath;
Properties.Settings.Default.Save();
CDebugger.addDebugLine("BLADEM.EXE wurde erkannt ");
this.loadFilenames_DSA_1(filepath); // dateinamen sind in der exe verankert
foreach (string s in files)
{
if (this.SCHICK_DAT == null && String.Compare("BLADE.DAT", Path.GetFileName(s), true) == 0)
this.unpack_SCHICK(s);
if (this.DSAGEN_DAT == null && String.Compare("DSAGEN.DAT", Path.GetFileName(s), true) == 0)
this.unpack_DSAGEN(s);
}
if (this.SCHICK_DAT == null || this.DSAGEN_DAT == null)
{
CDebugger.addErrorLine("Fehler beim laden der .DAT Dateien");
return false;
}
found = true;
this._version = DSAVersion.Blade;
break;
}
else if (String.Compare("SCHWEIF.EXE", Path.GetFileName(filepath), true) == 0)
{
Properties.Settings.Default.DefaultDSAPath = directoryPath;
Properties.Settings.Default.Save();
CDebugger.addDebugLine("SCHWEIF.EXE wurde erkannt ");
this._version = DSAVersion.Schweif;
string[] helper = Directory.GetDirectories(directoryPath);
foreach (var s in helper)
{
if (String.Compare(new DirectoryInfo(s).Name, "DATA", true) == 0)
{
this.unpack_SCHWEIF(s);
found = true;
break;
}
}
if (!found)
{
CDebugger.addErrorLine("DATA Verzeichnis wurde nicht gefunden");
return false;
}
break;
}
else if (String.Compare("STAR.EXE", Path.GetFileName(filepath), true) == 0)
{
Properties.Settings.Default.DefaultDSAPath = directoryPath;
Properties.Settings.Default.Save();
CDebugger.addDebugLine("STAR.EXE wurde erkannt ");
this._version = DSAVersion.Schweif;
string[] helper = Directory.GetDirectories(directoryPath);
foreach (var s in helper)
{
if (String.Compare(new DirectoryInfo(s).Name, "DATA", true) == 0)
{
this.unpack_SCHWEIF(s);
found = true;
break;
}
}
if (!found)
{
CDebugger.addErrorLine("DATA Verzeichnis wurde nicht gefunden");
return false;
}
break;
}
}
if (!found)
{
CDebugger.addErrorLine("DSA Version konnte nicht erkannt werden");
string[] exe_Files = Directory.GetFiles(directoryPath, "*.exe");
string[] EXE_Files = Directory.GetFiles(directoryPath, "*.EXE");
CDebugger.addErrorLine("es wurden " + (exe_Files.Length + EXE_Files.Length).ToString() + " .exe Dateien gefunden:");
if (exe_Files.Length > 0)
{
foreach (string s in exe_Files)
CDebugger.addErrorLine(" - exe: " + s);
foreach (string s in EXE_Files)
CDebugger.addErrorLine(" - EXE: " + s);
}
return false;
}
return true;
}
private CImageHeader checkForSpezialFile(string filename, DSAVersion version)
{
switch (version)
{
case DSAVersion.Blade:
case DSAVersion.Schick:
foreach (KeyValuePair<string,CImageHeader> pair in this.itsSpezialFiles_SCHICK)
{
if (pair.Key == filename)
return pair.Value;
}
foreach (KeyValuePair<string, CImageHeader> pair in this.itsSpezialFiles_DSAGEN)
{
if (pair.Key == filename)
return pair.Value;
}
return null;
case DSAVersion.Schweif:
foreach (KeyValuePair<string,CImageHeader> pair in this.itsSpezialFiles_SCHWEIF)
{
if (pair.Key == filename)
return pair.Value;
}
return null;
default:
return null;
}
}
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> 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;
}
//----------------------------------------------------------
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;
}
//-----------------------------------------
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;
}
}
