Binäre Dateien für Anfänger

    • Studio

    Diese Seite verwendet Cookies. Durch die Nutzung unserer Seite erklären Sie sich damit einverstanden, dass wir Cookies setzen. Weitere Informationen

    • Binäre Dateien für Anfänger

      Binäre Dateien
      Für Anfänger


      Vorwort:
      Dieses Tutorial richtet sich an Programmier-Anfänger bzw Programmierer die bis dato Text-Dateien zur Speicherung von sensiblen Daten (wie z.B: Spielständen) verwendet haben
      und keinerlei Erfahrung in punkto Binärdateien haben.

      Falls du (der Leser) von Binärdateien gehört hast, aber nicht verstehst wie genau diese funktionieren, so kann dieses Tutorial auch für dich Hilfreich sein.

      Dieses Tutorial besteht größtenteils aus einem Theorieteil, bei dem erklärt wird wie Binärdateien aufgebaut sind, was für Vorteile die gegenüber Textdateien haben und auf was man beim verwenden dieser beachten sollte.
      Jedoch wird zwischendurch auch auf einfache Praxisbeispiele eingegangen. Am Ende gibt es eine kleine Sammlung an Beispielen.
      (... die mit der Zeit evtl erweitert werden.)



      _______________________________________________________________________


      Fangen wir doch gleich mal mit der wesentlichen Frage an:
      „Wieso sollte ich Binärdateien gegenüber Textdateien verwenden?“
      Hauen wir euch doch mal ins kalte Wasser und führen einen kleinen Vergleich zwischen Text- und Binärformat durch.

      Vorteile von Binären Files gegenüber Textfiles
      Spoiler anzeigen
      1. Binäre Dateien können wesentlich kleiner sein als Text-dateien obwohl sie essentiell die gleichen Informationen beinhalten

      Links die Textdatei und rechts die Binärdatei. (Achtet auf die Dateigröße)

      2.Binäre Dateien sind nicht so leicht entschlüsselbar wie Textdateien.

      Textdatei: (in Text-Editor)


      Binärdatei (in Text-editor)

      Texteditoren sind nicht dafür geeignet Binär-Dateien anzuzeigen.

      Man könnte die Binäre Datei in einem Editor öffnen der mit reinen Binärdateien umgehen kann, jedoch wird man auf den ersten Blick (ohne reverse-engineering) so schnell keinen richtigen Plan haben was genau da gespeichert wurde.

      (Hier: Binärdatei in „Hex-Editor MX“ geöffnet)


      Wisst ihr wo hier z.B: die Zahl „234223“ gespeichert wurde? Nein? Keine Sorge. Ich würde das auch nicht wissen wenn ich die Datei nicht selbst erstellt hätte.


      Wieso sind Binärdateien kleiner als Textdateien?
      Spoiler anzeigen

      Um diese Frage zu beantworten, müssen wir erstmal verstehen wie Dateien unter Windows aufgebaut sind und wie die Textdateien da gespeichert werden.

      „Binär“ ist eine Informationsspeicherung von nur 2 Werten: 0 oder 1.
      Der ganze Computer arbeitet auf Basis von Binären Rechenoperationen.
      U.a. können Zahlen in Binär dargestellt werden.
      Die Zahl 37 ist z.B: 100101 in Binär.

      Binärdateien sind genau auf diesem Prinzip aufgebaut. Intern besitzen sie lauter 0er und 1en die im Zusammenhang die nötige Information ergeben.

      Das Dateisystem von Windows erlaubt es jedoch nicht einzelne Bits (also 0er oder 1en) in die Datei zu schreiben. Die kleinste mögliche Einheit die wir in eine Datei schreiben können sind Bytes.

      Bytes bestehen aus genau 8 Bits. Das bedeutet dass die Zahl (in Binär) minimal „00000000“ (=0 in Dezimal) bis maximal „11111111“ ( = 255 in Dezimal) sein kann.

      Wenn wir also einen Wert speichern wollen der zwischen 0 und 255 liegt, dann brauchen wir dafür nur 1 Byte.

      -----------------------------------------------------------

      Textdateien sind intern genauso aufgebaut. Wenn man sich die ASCII Tabelle
      anschaut, so merkt man pararellen mit der Bytespeicherung. Jedes Zeichen (Buchstabe, Zahl, Sonderzeichen,etc..) das in einem Texteditor angezeigt wird, hat eigentlich eine 8Bit große (=1 Byte) Zahl im Hintergrund stehen die dieses Zeichen repräsentiert.

      Beispiele: (aus Ascii tabelle)
      Das Zeichen „C“ ist in Binär „01000011“ was in Dezimal der Zahl 67 entspricht.
      Das Zeichen „5“ ist in Binär „00110101“ was in Dezimal die Zahl 53 entspricht.

      (Der Text-editor weiss, dass die Zahl 67 (aus dem Binären konvertiert) dem Zeichen „C“ entspricht und die Zahl 53 dem Zeichen „5“.)


      ACHTUNG:
      In Textdateien wird nicht zwischen Zahlen und Buchstaben unterschieden. In Texteditoren gibt es nur Zeichen! Schaut euch die Ascii-tabelle an um zu sehen, welches Symbol für welchen dezimalen Wert steht.


      Jedes Zeichen verbraucht genau 1 Byte. (da 1 Zeichen mit 8 Bit dargestellt wird.)
      Als beispiel, die Zeichen
      „123“ würden in Binär so ausschauen:
      00110001|00110010|00110011 (Die Trennzeichen habe ich nur aus optischen Gründen hinzugefügt)
      In dezimal schaut das so aus:
      49|50|51 (Trennzeichen auch nur aus optischen Gründen hinzugefügt.

      --------------------------------------------------

      Seht ihr wo uns das langsam hinführt?

      Wenn wir die Zahl „123“ in eine Textdatei speichern, dann verbraucht diese Zahl genau 3 Byte, weil wir 3 Zeichen benutzen müssen um diese Zahl als Text darstellen zu können.

      Wenn wir das aber in eine Binärdatei speichern würden, bräuchten wir nur genau 1 Byte.
      (Da 1 Byte in binär eine Zahl zwischen 0 bis maximal 255 darstellen kann.)

      Wenn wir diese Zahl in Binär speichern würden, würden wir nur 1/3 der Speichermenge einer Textdatei mit demselben Inhalt verwenden.

      Deshalb war die Binärdatei im oberen vergleich mehr als doppelt so klein als die Textversion.




      Was wenn ich eine Zahl speichern möchte, die größer ist als 255?
      Spoiler anzeigen

      Programmierer die sich mit komplexeren Sprachen wie C++,C# oder Java auseinandergesetzt haben, werden dies leicht beantworten können.
      Wir verwenden einfach mehr Bytes für das darstellen einer Zahl.

      Nehmen wir mal an, wir dass wir die Zahl 4572 speichern wollen.
      1 Byte kann nur maximal einen Wert bis 255 speichern.
      Nun gut, was wenn wir aber 2 Bytes für eine Zahl verwenden würden?
      2 Bytes sind 16 Bit (2*8 )
      Das heisst wir können damit eine Zahl von
      0000000000000000 (=0) bis 1111111111111111 (=65535 in Dezimal) darstellen.

      4572 liegt deutlich unter 65535, von daher reichen uns 2 Bytes für diese Zahl.


      4572 ist in Binär: „1000111011100“. Das sind insgesamt 13 Bits die die Zahl benötigt.
      Da wir aber nur in Bytes speichern können, müssen wir 2 Bytes (=16 Bits) verwenden damit wir diese Zahl darstellen können. (Da 1 Byte mit 8 Bit zu wenig wären wie man sehen kann…)
      Die fehlenden 3 Bit werden beim Speichern vom System automatisch am Anfang als 0en drangehängt:
      0001000111011100 > die Zahl 4572 in 16 Bit


      Das kann man soweit ausweiten wie man möchte. Wenn man eine Zahl verwenden möchte die noch größer ist als 65535 (2 Bytes), so kann man einfach die Byteanzahl erhöhen.
      Mit 3 Bytes wäre der maximale Wert 16777215



      Kann ich Vorzeichen in Binären Dateien verwenden?
      Spoiler anzeigen

      Ja, kannst du.
      Nehmen wir z.B: 1 Byte her. Wir müssen in diesen 8 Bit irgendwo die Information für ein Vorzeichen speichern. Was machen wir in dem Fall? Wir nehmen das linke äußerste Bit von dem einem Byte und reservieren es für das Vorzeichen. Dadurch können wir mit 0 oder 1 dem System sagen, ob die Zahl ein positives oder negatives Vorzeichen hat. (z.B: 0 ist positiv, 1 ist negativ.)
      Beispiel:
      01001010
      Das erste Bit (die „0“) wäre das Vorzeichen.

      Dadurch entsteht aber ein Problem: Da wir 1 Bit für das Vorzeichen reservieren, bleibt für die eigentliche Zahl nur noch 7 Bit übrig. Mit den 7 Bit kann man eine Zahl bis zu 127 darstellen.
      Dadurch aber dass das äußerste 8te Bit ein Vorzeichen ist, kann man den Wertebereich von -127 bis + 127 abdecken.

      Beispiel:
      127 würde in 7 Bit so ausschauen:
      1111111 (7 Bit)

      In 8 Bit: ( so wie es Dateisystem handhabt. 1 Bit wäre das vorzeichen)
      Die Zahl +127 würde den Wert 01111111 haben, während
      -127 den Wert 11111111 hätte.


      Man nennt dass auch „signed“ bzw „unsigned“.
      „signed Values“ sind Variablen die ein Vorzeichen besitzen (und dementsprechend 1 bit dafür reservieren)
      Während „unsigned Values“ Variablen sind, die alle Bits für die eigentlichen Wert verwenden (dementsprechend aber nur 1 Vorzeichen haben können)

      Keine Angst, das müssen wir nicht manuell machen.
      Der Game Maker macht die ganzen Bitberechnungen automatisch. Wir müssen ihm nur sagen ob wir ein Vorzeichen haben wollen oder nicht.


      Wie erkennt man, wann eine Zahl beginnt und wann sie endet? Gibt es irgendein Trennzeichen wie den Zeilenumbruch?
      Spoiler anzeigen
      Die meisten (ich sag jetzt mal „Anfänger“) die versuchen ein Speichersystem zu programmieren, trennen ihre Informationen mit Zeilenumbrüchen. Dadurch ist es für sie einfach die Informationen zu trennen und sich diese einfach über die „file_text_read_string()“ oder „file_text_read_real()“ Funktionen auszulesen. Nach jedem auslesen springt man in die nächste Zeile und liest sich die wieder mit einer dieser Funktionen aus.

      In Binärdateien gibt es keine Trennzeichen. Es gibt nur Bytes die sequentiell (also nacheinander) in einer Reihe angeordnet sind.
      Wenn wir also die Informationen auslesen wollen, müssen wir erstmal wissen in welcher Reihenfolge wir sie gespeichert haben.

      ------------------------------------------------------------------
      Nehmen wir mal an wir wollen 2 Informationen in eine Binärdatei speichern.
      Die erste Information sind die Lebenspunkte vom Spieler die den Wert 90 haben. (maximaler wert ist 100).
      Die 2te Information ist die Zahl 4572 die die Punkte des Spielers darstellt. (maximaler Wert = 5000).

      Für die Lebenspunkte brauchen wir nur 1 Byte, da der Wert mit Sicherheit nie 255 überschreiten wird.
      Für die Punktzahl brauchen wir aber 2 Bytes, da die maximale Zahl 5000 für nur 1 Byte viel zu groß ist.

      -----------------------------------------------------------
      Wenn wir diese Zahlen (90 und 4572 ) nacheinander speichern, so bekommen wir solch ein Ergebnis:

      01011010|00010001|11011100

      Falls jemand diese Datei aufmachen würde, würde er nicht wissen was für eine Information dort steht. Das können entweder 3 einzelne Zahlen oder Buchstaben sein, das kann aber auch als eine 3Byte große ganze Zahl angesehen werden. Aussenstehende Personen die nicht wissen wie wir die Informationen gespeichert haben, können daraus nur schwer Schlüsse ziehen.

      (Würde die Person denken dass die 3 Bytes eine ganze Zahl sein sollen, dann würde er beim Ausrechnen ins Dezimalsystem auf den Wert „1475703“ kommen) > hat nicht wirklich was mit den Lebenspunkten oder gar der Punktzahl gemein.

      Wir haben aber den entscheidenden Vorteil: Wir wissen wie wir die Informationen gespeichert haben:

      01011010|00010001|11011100

      Lebenspunkte (1Byte)
      Punktezahl (2Byte)


      Wir müssen also beim Auslesen der Datei wissen, wie sie gespeichert wurde und wieviel Bytes der jeweilige Wert in der Datei belegt.
      In dem Fall soll er als erstes 1 Byte auslesen und danach 2 Byte.

      Die Reihenfolge und Bytemenge pro Wert muss beachtet werden!
      Man muss wissen an welcher Stelle welcher Wert anfängt und wieviel Bytes dieser besitzt!



      Praxisbeispiel in GM: Studio
      Spoiler anzeigen

      Dasselbe Prinzip das ich hier zeigen werde, kann auch in GM 8.1 mit der http DLL als auch mit der Faucet-Networking DLL umgesetzt werden. Beide DLLs können einen Buffer beschreiben und diese als Binäre Datei speichern als auch wieder auslesen.

      Erstellen wir mal ein neues Projekt in GM Studio.
      Dann erstellt ein neues Objekt mit dem Namen „obj_controller“.

      Packt diesen code in das create-event:

      GML-Quellcode

      1. if (file_exists(working_directory+"/buffertest.bin")){
      2. file_delete(working_directory+"/buffertest.bin");
      3. }
      4. buffer = buffer_create(1, buffer_grow, 1);
      5. buffer_write(buffer,buffer_u8,100);
      6. buffer_save(buffer,working_directory+"/buffertest.bin");
      7. buffer_delete(buffer);
      Alles anzeigen


      Was genau bewirken die Codezeilen? Finden wir es heraus:

      GML-Quellcode

      1. if (file_exists(working_directory+"/buffertest.bin")){
      2. file_delete(working_directory+"/buffertest.bin");
      3. }

      Dürfte einfach sein. Falls die Datei schon existiert, so löschen wir diese.

      GML-Quellcode

      1. buffer = buffer_create(1, buffer_grow, 1);


      Wir erstellen einen neuen Buffer.

      Um Verwirrung vorzubeugen:
      Wir speichern alle Werte in einen "Buffer" der im RAM sitzt. Nicht direkt in die Datei!
      Der Buffer ist praktisch ein temporärer Speicher der Beschrieben bzw gelesen werden kann.
      Wenn wir mit dem beschreiben des Buffers fertig sind, müssen wir ihn nurnoch als Datei speichern.
      (Dies geschieht mit "buffer_save();" welches wir am ende aufrufen)


      Das erste Argument steht für die Buffergröße in Bytes.
      Falls ihr eine fest definierte Größe haben wollt, so könnt ihr hier eure Byteanzahl angeben.
      Wir belassen sie jedoch auf 1 da wir einen dynamischen Buffer verwenden, welcher seine byte-größe an der Menge seiner Daten anpasst. (deshalb können wir die standard-Buffergröße auf 1 belassen) Den dynamischen Buffer definieren wir im 2ten Argument.

      Das 2te Argument „buffer_grow“ definiert einen dynamischen Buffer der mit jeden zuwachs an Daten zusätzlichen Speicher beansprucht. Falls wir also 5 Bytes hinzufügen und er keinen Platz mehr hat, so holt er sich vom Arbeitsspeicher die 5 bytes und beansprucht sie für sich um die Daten da reinzuquetschen.

      Das dritte Argument sollte der einfachheit halber auf 1 stehen. Die Bedeutung dahinter zu erklären würde alles nur unnötig kompliziert machen. (Kurzgefasst: belasst sie immer auf 1)

      GML-Quellcode

      1. buffer_write(buffer,buffer_u8,100);


      Dieser Befehl schreibt einen Wert in einer definierten Bytegröße in den Buffer.
      Das erste Argument ist der Buffer den wir vorher definiert haben.

      Das 2te Argument ist die Bytegröße. Der GM besitzt Konstanten die man dafür verwendet.
      In dem Falle sagen wir „buffer_u8“.
      „u8“ steht dabei für unsigned 8bit.
      Das bedeutet dass wir 8 bit (=1 byte) für den folgenden Wert beanspruchen wollen.
      „Unsigned“ bedeutet dass wir kein Vorzeichen haben. (es werden also alle 8 bit für den Wert verwendet > es wird kein Bit für das Vorzeichen verschwendet.)

      GML-Quellcode

      1. buffer_save(buffer,working_directory+"/buffertest.bin");


      Mit diesem Befehl speichern wir unseren Buffer in unser Arbeitsverzeichnis auf der Festplatte.
      Dieses liegt auf Windows im „Appdata“ Ordner. Näheres dazu ein Stück weiter unten.

      Buffer_save() wird erst dann aufgerufen, wenn wir ALLE Daten in den Buffer geschrieben haben.

      GML-Quellcode

      1. buffer_delete(buffer);

      Löscht den Buffer aus dem RAM und gibt dessen Speicher frei.

      Laden der Datei:


      Das laden der Datei schaut dann in etwa so aus:

      GML-Quellcode

      1. buffer = buffer_load(working_directory+"/buffertest.bin");//lade den buffer aus der Datei
      2. p_id = buffer_read(buffer,buffer_u8);//Lese das eine Byte aus
      3. buffer_delete(buffer);
      4. show_message(string(p_id));



      Bei dem Befehl

      GML-Quellcode

      1. p_id = buffer_read(buffer,buffer_u8);

      Ist zu beachten, dass ihr genauso wie beim Schreiben der Datei, die Größe des Wertes übergeben müsst. Hier übergeben wir „buffer_u8“, also dass der Wert 8 Bit (=1 Byte) groß ist.



      Wo befindet sich die gespeicherte Datei?
      Spoiler anzeigen
      Unter „C:\Users\<Nutzername>\AppData\Local\<Projektname>“

      Falls ihr den appdata Ordner nicht sehen könnt, versucht auf ihn manuell zuzugreifen.
      Öffnet euer Suchfenster und tippt „%appdata%“ ein und bestätigt die eingabe mit der „Enter“ Taste.



      Nun sollte sich der Explorer mit dem Appdata Ordner öffnen.
      Falls ihr euch in einem „Roaming“ Ordner befinden solltet, so klickt oben in der Pfadleiste auf den „Appdata“ Ordner.


      Wenn ihr im Appdata Ordner seid, klickt auf den „Local“ Ordner:


      Im „Local“ Ordner solltet ihr den Ordner aufsuchen der genauso heißt wie euer GM: Studio Projekt. (Hier heisst das Projekt "Binary_0") Dort sollte sich die Binärdatei befinden.



      CodeBeispiele
      Spoiler anzeigen


      Speichern und laden von mehreren Werten

      GML-Quellcode

      1. if (file_exists(working_directory+"/buffertest.bin")){
      2. file_delete(working_directory+"/buffertest.bin");
      3. }
      4. //speichere Datei: (mit "dummy" werten)
      5. buffer = buffer_create(1, buffer_grow, 1);
      6. buffer_write(buffer,buffer_u8,1);//player_id -> 0-255
      7. buffer_write(buffer,buffer_s32,456753);//x-koordinate 32bit (=4byte) mit vorzeichen (signed)-> -2147483647 bis +2147483647
      8. buffer_write(buffer,buffer_s32,234223);//y-koordinate 32 bit (=4byte) mit vorzeichen (signed)-> -> -2147483647 bis +2147483647
      9. buffer_write(buffer,buffer_u8,90);//lebenspunkte 0-255
      10. buffer_write(buffer,buffer_u16,2000);// 16-bit (=2 byte) munition 0-65535
      11. buffer_write(buffer,buffer_u8,133);//ausdauer 0-255
      12. buffer_write(buffer,buffer_u8,100);//wurfmesser 0-255
      13. buffer_save(buffer,working_directory+"/buffertest.bin"); // speichert den kompletten Buffer (der im Ram sitzt) und der unsere Werte besitzt in eine Datei
      14. buffer_delete(buffer);
      15. //----------------------------------------------------------
      16. //Lese Datei aus:
      17. var pid,px,py,p_hp,p_mun,m_stamina,p_messer;
      18. buffer = buffer_load(working_directory+"/buffertest.bin");
      19. p_id = buffer_read(buffer,buffer_u8);//player_id
      20. px = buffer_read(buffer,buffer_u32);//x-koordinate
      21. py = buffer_read(buffer,buffer_u32);//y-koordinate
      22. p_hp = buffer_read(buffer,buffer_u8);//lebenspunkte
      23. p_mun = buffer_read(buffer,buffer_u16);//munition
      24. p_stamina = buffer_read(buffer,buffer_u8);//ausdauer
      25. p_messer = buffer_read(buffer,buffer_u8);//wurfmesser
      26. buffer_delete(buffer);//Lösche den Buffer um memory Leaks zu verhindern.
      27. show_message(string(p_id)+"|"+string(px)+"|"+string(py)+"|"+string(p_hp)+"|"+string(p_mun)+"|"+string(p_stamina)+"|"+string(p_messer));
      Alles anzeigen


      Wichtig ist hierbei zu wissen in welcher Reihenfolge ihr die Variablen gespeichert habt und wieviel bits bzw bytes ihr verwendet habt.

      _________________________________________________________________________


      Speichern und laden von Strings

      GM: Studio besitzt funktionen zum speichern und laden von Strings. Ich mag es jedoch etwas komplizierter zu realisieren, dafür aber direkt die Kontrolle über die Strings zu haben.
      Dafür habe ich 2 Scripts entworfen:


      SPEICHERN-Skript:

      GML-Quellcode

      1. //buffer_write_chars(buffer,string);
      2. var buff,str;
      3. buff = argument0;
      4. str = argument1;
      5. var str_len;
      6. str_len = string_length(str);
      7. buffer_write(buff,buffer_u8,str_len);//speichert die länge eines Strings in den Buffer (max 255 zeichen)
      8. var h;
      9. for(h=1;h<=str_len;h+=+1){//durchlaufe den String
      10. var wbyte;
      11. wbyte = real(ord(string_char_at(str,h)));//konvertiert das jeweilige Zeichen was dem String entnommen wurde in den ASCII Code
      12. buffer_write(buff,buffer_u8,wbyte);//Speichert jedes einzelne Zeichen des Strings in den Buffer
      13. }
      Alles anzeigen



      LADEN-Skript:

      GML-Quellcode

      1. //buffer_read_chars(buffer);
      2. var anz,buff;
      3. buff = argument0;
      4. var ret;
      5. ret = "";
      6. anz = buffer_read(buff,buffer_u8);//anzahl an Zeichen im String (max 255)
      7. var h;
      8. for(h=1;h<=anz;h+=+1){//durchläuft die anzahl an bytes durch, die wir vorher ausgelesen haben.
      9. var t;
      10. t= chr(buffer_read(buff,buffer_u8));//liest den Ascii-Code aus und konviertiert es in ein Zeichen
      11. ret=ret+t;//fügt das zeichen dem finalen string zu.
      12. }
      13. return ret;
      Alles anzeigen


      Verwendungsbeispiel:

      GML-Quellcode

      1. if (file_exists(working_directory+"/buffertest.bin")){//Lösche die datei falls sie existiert
      2. file_delete(working_directory+"/buffertest.bin");
      3. }
      4. //erstelle Datei:
      5. buffer = buffer_create(1, buffer_grow, 1);
      6. buffer_write_chars(buffer,"Test123");//schreibe den Text in den Buffer
      7. buffer_save(buffer,working_directory+"/buffertest.bin");//speicher den Buffer
      8. buffer_delete(buffer);
      9. //Lade die Datei:
      10. var text;
      11. buffer = buffer_load(working_directory+"/buffertest.bin");//lade den Buffer
      12. text = buffer_read_chars(buffer);//lese den text aus
      13. buffer_delete(buffer);//lösche den Buffer
      14. show_message(string(text));//gib den text aus
      Alles anzeigen




      Ich hoffe dass ich Anfängern einen "einfachen" wenn auch ausführlichen Einblck in Binäre Dateien liefern konnte. Es ist mein erstes Tutorial, daher entschuldige ich mich für eventuelle Fehler bzw umständliche Erklärungen.

      Dieser Beitrag wurde bereits 15 mal editiert, zuletzt von LEWA ()

    • Danke LEWA ,

      Es war gut erklärt und die Screens waren auch hilfreich. Zuerst dachte ich so; Oh je, und wo ist da eine verständlich gemachte praktische Anleitung? Aber am Ende war sie da und sie war vollkommen verständlich ohne den Gamemaker parallel dazu aufmachen zu müssen :)

      ancient-pixel.com
      youtube.com/user/SebastianMerkl <<< ich freu mich über einen Besuch ;)
    • Wie sieht's eigentlich mit der Endianess aus? Kann man sich darauf verlassen, dass der GM (insbesondere unter Berücksichtigung, dass er sich mit Studio nun nicht mehr nur auf Windowssysteme beschränkt) überall die gleiche Endianess verwendet (und auch zukünftig verwenden wird)? Ansonsten solltest du noch ne Warnung dransetzen, keine Binärdateien als Austauschformat zu verwenden.
    • CAS schrieb:

      Wie sieht's eigentlich mit der Endianess aus? Kann man sich darauf verlassen, dass der GM (insbesondere unter Berücksichtigung, dass er sich mit Studio nun nicht mehr nur auf Windowssysteme beschränkt) überall die gleiche Endianess verwendet (und auch zukünftig verwenden wird)? Ansonsten solltest du noch ne Warnung dransetzen, keine Binärdateien als Austauschformat zu verwenden.

      Ich werde diesbezüglich Yoyogames mal anschreiben und fragen ob sie bei jeder Platform dieselbe Byte-Reihenfolge verwenden. Ich könnte zwar einige experimente durchführen um zu schauen wie die Endianess bei Studio
      (oder gar GM8.1 mit den DLLs) realisiert wurde, bin jedoch auf die wenigen Platformen die ich zur verfügung stehen habe beschränkt. (Dies wäre u.a. Windows, Android und HTML5.)
      Letztendlich weiss auch nur Yoyogames ob sie in Zukunft irgendwelche Änderungen an der Binären speicherung planen. Im Voraus wäre eine Warnung bezüglich solcher inkompatibilitäten nicht verkehrt.

      /Edit:
      Freut mich dass das Tutorial gut ankommt. :)
    • Die Verwendung der Buffer - Funktionen für diesen Zweck werden in der Hilfe ausdrücklich nicht empfohlen:

      NOTE: This function is very limited and it is designed for the beginner to get a checkpoint system up and running quickly, but more advanced users may prefer to code their own system using the File functions, due to the fact that the game will not save any of the dynamic resources like data structures, surfaces, added backgrounds and sprites etc..


      Mit den "file_bin" Funktionen kann man auch nur einzelne Bytes schreiben und ist somit in Sachen Endianness auch auf der sicheren Seite.

      EDIT: Ups, die falsche Funktion nachgeschlagen (hatte bei game_save_buffer nachgeschaut). Jedenfalls kann man die "file_bin" Funktionen verwenden wenn man sich Sorgen um die Endianness macht...

      Dieser Beitrag wurde bereits 1 mal editiert, zuletzt von ghost ()