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; } }