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.

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.

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

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.

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!

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:


Was genau bewirken die Codezeilen? Finden wir es heraus:


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



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)



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.)



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.


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:




Bei dem Befehl

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.

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.

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




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:



LADEN-Skript:


Verwendungsbeispiel: