Dieses Mal werden wir (fast) alles wissenswerte über die Datei Anweisungen der Acknex Engine lernen. Schauen wir uns dazu zunächst die Datentypen an, die regelmäßig in Spielen vorkommen und von der Engine verarbeitet werden können.
Zunächst ist da die wichtige var, in der Zahlen gespeichert werden. Diese können aus einer Datei mit Hilfe von file_var_read gelesen und mit file_var_write wieder geschrieben werden. Klingt einfach, oder? Schauen wir uns ein Beispiel an, der erste Codeteil in unserem Workshop (wie überraschend!):
var var_handle;
var my_variable;
STRING variable_str = " "; // the string can store up to 6 characters (6 digits for our number)
TEXT variable_txt =
{
pos_x = 20;
pos_y = 20;
string (variable_str); // the string will store the "number" (a string which will be converted to a number afterwards)
flags = VISIBLE;
}
function write_variable()
{
variable_txt.visible = ON;
inkey (variable_str); // store the input inside the string named variable_str
my_variable = str_to_num(variable_str); // convert the string to a "real" variable and store it inside my_variable;
var_handle = file_open_write ("variables.txt"); // open this file for writing (create it if it doesn't exist)
file_var_write (var_handle, my_variable); // the variable was written inside the "variables.txt" file
file_close (var_handle); // close the file, we won't be needing it from now on
}
on_f1 = write_variable;
Die Funktion write_variable() läuft jedes Mal, wenn der Spieler die F1 Taste drückt. Die erste Codezeile zeigt variable_txt an. Das ist wichtig, denn die folgenden Zeilen erwarten die Eingabe des Spielers und speichern diese in variable_str, dem String, der zu variable_txt gehört.
Da inkey sich erstmal nicht um Zahlen kümmert, muss variable_str noch in eine Zahl umgewandelt werden, was mit str_to_num getan werden kann.
Nochmal zusammengefasst: wenn die Funktion läuft, zeigt sie den Cursor an und der Spieler kann eine Zahl eingeben, aber die Eingabe ist selbst keine Zahl, sondern ein String, der z.B. "123" ist, wenn eben dies eingegeben wurde. Die dritte Codezeile wandelt dann den String "123" in die Zahl 123 um, dieses Mal eine echte Variable, die für mathematische Operationen genutzt werden kann, usw.
Zeit, die letzten drei Zeilen zu betrachten; diese Art von Code werden wir oft benötigen:
var_handle = file_open_write ("variables.txt"); // open this file for writing (create it if it doesn't exist)
Diese Zeile öffnet eine Datei namens "variables.txt" zum Schreiben und liefert das Resultat der Operation als Variable zurück, genauer gesagt einen Handle, der die Datei eindeutig identifiziert. Wenn die Anweisung glückt (die Datei kann erstellt werden oder existiert bereits), wird var_handle auf das handle der Datei gesetzt; falls die Datei nicht erzeugt werden kann (weil nicht genug Platz ist oder bereits eine schreibgeschützte Datei des Namens existiert, etc.), wird var_handle auf 0 gesetzt.
file_var_write (var_handle, my_variable); // the variable was written inside the "variables.txt" file
Wie Sie sehen hat file_var_write eine simple Syntax: Man benötigt nur einen Handle für die Datei und den Namen der Variable (oder einfach eine Zahl), die hineingeschrieben werden soll.
file_close (var_handle); // close the file, we won't be needing it from now on
Diese einfache Anweisung schließt die Datei mit dem entsprechenden Handle. Wir haben die Vaiable hineingeschrieben, also kann dies nun ohne weiteres geschehen. Wenn Sie die Funktion noch nicht getestet haben, starten Sie jetzt script41.wdl und drücken Sie dann F1. Geben Sie eine Zahl ein (ich habe einfach 123 eingegeben) und drücken Sie Enter; Sie sollten etwas in der folgenden Art sehen:
Verlassen Sie die Engine; in Ihrem Ordner sollte sich eine Datei namens "variables.txt" befinden. Öffnen Sie diese und Sie werden sehen, dass Ihre Eingabe in der Datei steht. Starten wir nun script41.wdl erneut; der Bildschirm sieht folgendermaßen aus:
Drücken Sie nun F2, um folgendes zu sehen:
Wie Sie vermutlich schon erraten haben, startet F2 eine Funktion, die den Wert der Variablen aus variables.txt liest und auf dem Bildschirm anzeigt. Schauen wir uns den Code an:
var stored_variable = 0; // this variable will store the value which was stored inside variables.txt
function read_variable()
{
var_handle = file_open_read("variables.txt");
stored_variable = file_var_read (var_handle);
file_close (var_handle);
}
PANEL variable_pan
{
pos_x = 70;
pos_y = 20;
digits (0, 0, "The value of the variable is: %.0f", *, 1, stored_variable);
flags = VISIBLE;
}
on_f2 = read_variable;
Die erste Codezeile öffnet die Datei namens "variables.txt" zum Lesen und weist wie oben einen Handle zu. Wir verwenden hier die gleiche Variable für den Handle, da wir nicht vorhaben, gleichzeitig lesend und schreibend auf die Datei zuzugreifen.
Die zweite Codezeile liest die Variable aus variables.txt (unser var_handle ist auf diese Datei eingestellt) und speichert das Ergebnis in "stored_variable". Wir haben die Zahl zurück und können damit nun machen was wir wollen. Die letzte Codezeile schließt die Datei wieder, da sie nicht mehr gebraucht wird.
Ich zeige den Inhalt von stored_variable mit Hilfe eines Panels an, aber Sie können alles Mögliche damit tun; zum Beispiel können Sie einen High Score für Ihr Spiel speichern, bevor das Spiel verlassen wird und diesen beim Neustart wieder einlesen.
Aber wie kann man mehrere Variablen in eine Datei schreiben oder aus dieser lesen ohne viel Code schreiben zu müssen? Die einfache Antwort: verwenden Sie file_var_read und file_var_write Anweisungen einfach in einer Schleife. Schauen wir uns gleich ein Beispiel an: Starten Sie das Skript, drücken Sie auf "1" und verlassen Sie dann die Engine. Sie werden eine Datei namens "numbers.txt" in Ihrem Verzeichnis finden, die folgendes enthält:
Wie Sie sich vorstellen können, habe ich keine 100 file_var_write Anweisungen genutzt, um diese Zahlen alle zu schreiben; der Code ist sogar recht einfach:
var numbers_handle;
function write_100_numbers()
{
var i = 1;
numbers_handle = file_open_write ("numbers.txt"); // open this file for writing (create it if it doesn't exist)
while (i <= 100)
{
file_var_write (numbers_handle, i); // file_var_write adds a "space" after each number automatically
i += 1;
}
file_close (numbers_handle); // close the file, we won't be needing it from now on
}
on_1 = write_100_numbers;
Wir öffnen die Datei für den Schreibzugriff (das muss nur einmal geschehen!) und durchlaufen dann eine Schleife, die 100 Mal die file_var_write Anweisung aufruft. Schließlich wird die Datei wieder geschlossen.
Das ist im Wesentlichen alles, was Sie über das Lesen und Schreiben von Variablen wissen müssen. Kommen wir zu etwas komplexeren Dingen: Lesen und Schreiben von Strings.
var string_handle;
STRING string_str = " "; // the string can store up to 20 characters
TEXT string_txt =
{
pos_x = 20;
pos_y = 200;
string (string_str); // player's input will be stored inside this string
flags = VISIBLE;
}
function write_strings() // writes and appends strings
{
string_txt.visible = ON; // make the text visible (displays the cursor as well)
string_handle = file_open_append("strings.txt"); // open this file for appending (create it if it doesn't exist)
while (1)
{
inkey (string_str); // store the input inside the string named string_str
if (!str_cmpi(string_str, "end")) // if the player didn't type "end" yet
{
file_str_write (string_handle, string_str); // the string is written inside the "strings.txt" file
file_asc_write (string_handle, 13); // write the following string on a separate line
file_asc_write (string_handle, 10); // using asc(13) = carriage return + asc(10) = line feed
str_cpy (string_str, ""); // reset the input string - makes the input look better
}
else // the player has typed "end"
{
break; // so we exit the "while" loop
}
}
file_close (string_handle); // close the file, we won't be needing it from now on
sys_exit(NULL); // shut down the engine
}
on_f3 = write_strings;
Das sieht schon etwas komplizierter aus; ich habe einen String mit Namen string_str definiert, der bis zu 20 Zeichen aufnehmen kann und einen Text, der auf diesen zurückgreift. Die Funktion write_strings() startet durch Druck auf F3 und macht den Text sichtbar, ehe sie die Datei strings.txt im "Append"-Modus öffnet, also zum Anfügen von Daten.
Im vorigen Beispiel haben wir file_open_write verwendet, wodurch eine neue Datei erzeugt wird oder eine existierende Datei geöffnet wird, die in diesem Fall aber (wichtig!) gelöscht und quasi überschrieben wird. Die neue Anweisung - file_open_append - verhindert diese Löschung und hängt die neuen Daten hinten an die Datei an.
Ein Beispiel? Stellen wir uns vor, dass Sie ein Programm schreiben, welches eine Liste der besten Bücher verwaltet, die Sie je gelesen haben. Momentan sieht books.txt folgendermaßen aus:
John Doe - There's a tree in each one of us
Jane Doe - The mirror behind the mirror
Joan Doe - A bit of monkey
Und nun finden Sie das großartige Buch namens "The criminal keyboard", lesen es und beschließen, es zu der Liste hinzuzufügen. Wenn Sie die Liste mit file_open_write öffnen und den Titel hineinschreiben, sieht books.txt danach so aus:
Jenny Doe - The criminal keyboard
Alle vorigen Strings wurden entfernt! Zum Glück können Sie auch file_open_append verwenden, wonach books.txt dann folgendermaßen aussieht:
John Doe - There's a tree in each one of us
Jane Doe - The mirror behind the mirror
Joan Doe - A bit of monkey
Jenny Doe - The criminal keyboard
Mit all diesen Informationen im Hinterkopf können wir uns nun erneut der Funktion zum Schreiben der Strings widmen:
function write_strings() // writes and appends strings
{
string_txt.visible = ON; // make the text visible (displays the cursor as well)
string_handle = file_open_append("strings.txt"); // open this file for appending (create it if it doesn't exist)
while (1)
{
inkey (string_str); // store the input inside the string named string_str
if (!str_cmpi(string_str, "end")) // if the player didn't type "end" yet
{
file_str_write (string_handle, string_str); // the string is written inside the "strings.txt" file
file_asc_write (string_handle, 13);
file_asc_write (string_handle, 10);
str_cpy (string_str, ""); // reset the input string - makes the input look better
}
else // the player has typed "end"
{
break; // so we exit the "while" loop
}
}
file_close (string_handle); // close the file, we won't be needing it from now on
sys_exit(NULL); // shut down the engine
}
Die Schleife wartet bis der Spieler einen String eingegeben hat und prüft dann, ob es sich um die Zeichenkombination "end" handelt. Ist dies nicht der Fall, wird der String mit file_str_write in die geöffnete strings.txt Datei geschrieben. Die folgenden beiden Zeilen verwenden die file_asc_write Anweisung und stellen sicher, dass jeder String eine eigene Zeile in der Datei erhält; die erste Zeile schreibt ein Byte mit ASCII-Wert 13 (Carriage Return) und danach ein Byte mit Wert 10 (Line Feed).
Es mag etwas kompliziert aussehen, aber es ist der sicherste Weg, einen Zeilenumbruch zu erzeugen, genau als wenn Sie in Ihrem Lieblings-Texteditor die Return-Taste drücken. Die gute Nachricht ist, dass diese beiden Zeilen auf allen Windows Systemen (und nicht nur dort) funktionieren. Wir werden uns file_asc_write später noch genauer ansehen, aber merken Sie sich im Moment zunächst nur diese beiden Zeilen in dieser Reihenfolge, wenn Sie einen Zeilenumbruch erstellen möchten.
Zurück zu unserer Schleife; der String wurde in die Datei geschrieben und der Zeilenumbruch erzeugt und nun wird string_str zurückgesetzt, indem "" hineinkopiert wird, also ein leerer String und er nun bereit ist, eine neue Eingabe aufzunehmen. Das heißt, der Spieler kann so viele Strings eingeben wie er mag und sie alle werden in strings.txt geschrieben. Wenn Ihnen das zu langweilig wird, geben Sie einfach "end" ein (ohne Anführungszeichen) und drücken dann Enter - dann wird der "else" Teil ausgeführt und mit break aus der Schleife ausbrechen, wonach dann strings.txt geschlossen und die Engine beendet wird.
In allen Beispielen habe ich *.txt Dateien benutzt, aber Sie können Ihre Dateien anders benennen und ihnen auch andere Endungen geben, wie z.B. hotinfo.dbl - der Code wird funktionieren, wenn die Funktionen zum Lesen und Schreiben auf den gleichen Dateinamen zugreifen.
Testen wir die neue Funktion: Starten Sie das Skript, drücken Sie F3 und geben dann einen kurzen Text ein (ich habe die Länge auf 20 Zeichen begrenzt, aber es ist kein Problem, die Länge von string_str zu erhöhen) und drücken Sie dann Enter. Wiederholen Sie dies ein paar Mal und geben Sie dann "end" (ohne Anführungszeichen) ein, damit die Engine beendet wird.
In Ihrem Ordner sollte sich nun eine Datei strings.txt befinden, die Ihre Eingaben enthält. Hier ist der Inhalt meiner Datei:
Starten Sie das Skript erneut, drücken Sie wieder F3 und fügen Sie einen oder mehr Strings hinzu. Geben Sie wieder "end" ein, um die Datei zu schließen; sie sollte so aussehen:
Wie Sie sehen hat file_open_append gut funktioniert; wir konnten neue Daten anfügen ohne die alten Daten zu beschädigen.
Schauen wir uns nun die Funktion an, welche die Strings erneut einliest.
var eof_reached = 0; // will be set to -1 when the end of the file (eof) is reached
TEXT string_array = // creates an array of strings using a text
{
pos_x = 300;
pos_y = 200;
strings = 20;
string = " "; // stores up to 20 characters for each string
string = " ";
..........................................
flags = VISIBLE;
}
function read_strings()
{
var n = 0;
string_handle = file_open_read("strings.txt"); // open the strings.txt file
while (eof_reached != -1) // the end of the file wasn't reached yet?
{
eof_reached = file_str_read(string_handle, string_array.string[n]); // then read a string from the file
n += 1; // move on to the following string
}
file_close (string_handle); // all the strings are read here, so close the file
}
on_f4 = read_strings;
Ich habe einen Text mit 20 Strings definiert (diese habe ich nicht alle oben gezeigt). Dieser Text hat zwei Funktionieren:
1) Zum Einen fungiert er als String Array und kann 20 Strings mit je 20 Elementen speichern.
2) Zum anderen wird er die Strings aus der Datei anzeigen.
Die Funktion read_strings() öffnet die Datei string.txt zum Lesen und läst alle Daten darauf bis eof_reached auf -1 gesetzt ist. Manchmal weiß man vorher nicht, wie viele Einträge eine Datei enthält, also hilft file_str_read dabei, indem -1 zurückgeliefert wird, sobald das Ende der Datei erreicht ist. Die Schleife läuft bis dies geschieht und liest dabei die Strings aus der Datei und speichert sie im string_array.string[0] bis string_array.string[19]. Sie können einen größeren Array verwenden wenn Sie wollen, aber ich dachte, dass 20 Strings für dieses Beispiel ausreichen.
Wenn das Dateiende erreicht ist, liefert file_str_read den Wert -1 zurück und die Schleife wird beendet und die Datei geschlossen. Schauen wir uns das Ergebnis an; starten Sie das Skript und drücken dann F4.
Es hat funktioniert! Richten wir nun unsere Aufmerksamkeit auf die wirkungsvollsten Anweisungen: file_asc_write und file_asc_read. Warum sind sie so wirkungsvoll? Sie können file_var_write, file_var_read, file_str_write und file_str_read problemlos ersetzen, aber das Gegenteil ist nicht wahr.
Woher kommt diese Macht? File_asc_write und file_asc_read lesen und schreiben die Dateien Byte für Byte, sind also nicht auf die Zeichen beschränkt, die man auf einer Tastatur finden kann; mit ihnen hat man Zugriff auf den gesamten erweiterten ASCII Zeichensatz. Ich habe alle ASCII Codes in einer Tabelle gesammelt - sehen wir uns diese an.
Wenn Sie immer schon mal seltsame Symbole in eine Datei schreiben wollten, jetzt ist Ihre Zeit dafür gekommen! Mit diesen Anweisungen können Sie (zum Beispiel) eine Bitmap öffnen, einige Farben ändern und diese wieder speichern. Oder Sie können eine Programm schreiben, mit dem Sie Dateien zippen und entzippen können, alles in C-Skript mit Hilfe dieser beiden Anweisungen - das ist alles möglich.
Unser Beispiel ist nicht ganz so kompliziert: wir warten bis der Spieler einen Text eingibt, verschlüsseln diesen und speichern ihn in einer Datei. Dann lesen wir diesen, entschlüsseln ihn wieder und zeigen ihn an. Mit diesem Codeteil können Sie Daten verschlüsselt abspeichern: Passworte, High Score, etc. Schauen wir uns den Code an:
var encrypted_handle;
var number_of_characters; // will store the number of characters for encrypted_str
STRING encrypted_str = " "; // the string can store up to 50 characters
STRING temp_str = " "; // temporary string with up to 50 characters
TEXT encrypted_txt =
{
pos_x = 20;
pos_y = 500;
string (encrypted_str); // player's input will be stored inside this string
flags = VISIBLE;
}
function encrypt_strings() // allows the player to input a string, encrypts it and writes it inside the encrypted.txt file
{
var string_index = 0;
var temp_number;
encrypted_txt.visible = ON;
encrypted_handle = file_open_write("encrypted.txt"); // open this file for writing (create it if it doesn't exist)
inkey (encrypted_str); // store player's input inside the string named encrypted_str
number_of_characters = str_len(encrypted_str); // get the length of the strings
while (string_index < number_of_characters) // go through all the characters of the string, one by one
{
str_cpy (temp_str, encrypted_str); // first of all, copy encrypted_str to temp_str (we don't want to destroy it)
str_clip(temp_str, string_index); // cut the needed number of characters from the beginning of the string
str_trunc(temp_str, number_of_characters - string_index - 1); // and cut from the end as well
temp_number = str_to_asc(temp_str); // now we've only got a single char in temp_str, so let's convert it to ascii
temp_number += 100; // this part encrypts the numbers by adding 100 to them; feel free to use any number here
file_asc_write (encrypted_handle, temp_number); // now write the encrypted bytes to the disk
string_index += 1; // move on to the following character in the string
}
file_close (encrypted_handle); // close the file, we won't be needing it from now on
}
on_f5 = encrypt_strings;
Wie Sie sehen erledigt die Funktion encrypt_strings() alles Wichtige; sie zeigt den encrypted_txt Text an, der die Eingabe des Spielers in encrypted_str aufnehmen wird und öffnet dann encrpted.txt im Schreibmodus. Mit str_len ermittle ich die Anzahl der Zeichen des eingegebenen Strings und speichere das Ergebnis in der Variable number_of_characters.
Die Schleife läuft durch, bis alle diese Zeichen Stück für Stück eingelesen und verarbeitet wurden. Falls der Spieler (zum Beispiel) den String "HELLO WORLD" eingegeben hat, wird die Schleife 11 Mal durchlaufen und jedes Zeichen folgendermaßen verarbeiten:
Schauen wir uns die Schleife näher an:
while (string_index < number_of_characters) // go through all the characters of the string, one by one
{
str_cpy (temp_str, encrypted_str); // first of all, copy encrypted_str to temp_str (we don't want to destroy it)
str_clip(temp_str, string_index); // cut the needed number of characters from the beginning of the string
str_trunc(temp_str, number_of_characters - string_index - 1); // and cut from the end as well
temp_number = str_to_asc(temp_str); // now we've only got a single char in temp_str, so let's convert it to ascii
temp_number += 100; // this part encrypts the numbers by adding 100 to them; feel free to use any number here
file_asc_write (encrypted_handle, temp_number); // now write the encrypted bytes to the disk
string_index += 1; // move on to the following character in the string
}
file_close (encrypted_handle); // close the file, we won't be needing it from now on
Die erste Zeile kopiert den Original-String in temp_str. Das ist wichtig, weil wir ihn etwas zerstückeln wollen und das Original behalten möchten. Wie Sie im Bild sehen, entfernt die Anweisung str_clip die gegebene Anzahl Zeichen vom Anfang des Strings, wohingegen str_trunc den String an seinem Ende kürzt.
Eine Variable namens string_index zusammen mit str_clip schneidet nun immer mehr Zeichen vorn ab, je länger die Schleife läuft und "number_of_characters - string_index - 1" Zeichen werden hinten entfernt, wodurch nur ein einziges Zeichen von temp_str übrigbleibt. Im Beispiel bedeutet dies, dass während die Schleife läuft, temp_str erst auf "H" gestezt wird, dann auf "E", dann auf "L", "L", "O", " ", "W" und so weiter.
temp_number = str_to_asc(temp_str); // now we've only got a single char in temp_str, so let's convert it to ascii
Die obige Zeile liefert zu unserem Zeichen den ASCII-Code als Zahl zurück; wir können ja keine ASCII Bytes in die Dateien schreiben, wenn wir nicht mit dem ASCII-Code arbeiten, richtig?
temp_number += 100; // this part encrypts the numbers by adding 100 to them; feel free to use any number here
Ob Sie es glauben oder nicht, diese Zeile ist für die Verschlüsselung zuständig; sie addiert einfach 100 zum ASCII Code des Zeichens und macht es somit unleserlich, weil die "normalen" ASCII-Codes auf der Tastatur zwischen 0 und 127 liegen und die neuen Zeichen damit zwischen 100 und 227. Sie können auch eine andere Zahl verwenden, solange Sie sicherstellen, dass die Werte 255 (den größten Wert in der ASCII Tabelle) nicht überschreiten.
file_asc_write (encrypted_handle, temp_number); // now write the encrypted bytes to the disk
string_index += 1; // move on to the following character in the string
Die letzten beiden Zeilen der Schleife schreiben das Byte in die Datei mit dem entsprechenden Handle und sagen der Schleife, dass mit dem nächsten Zeichen fortgefahren werden soll. Schauen wir uns die Funktion an: drücken Sie F5, geben Sie eine Zeichenkette mit maximal 50 Zeichen ein und drücken Sie dann Enter. Vergessen Sie nicht, die Engine zu beenden.
Hier ist meine Zeichenkette; schauen wir uns den Inhalt der encrypted.txt Datei an:
Sieht gut aus, wenn man bedenkt, wie wenig Aufwand es eigentlich war... ich weiß, dass Sie müde sind, aber schauen wir uns die letzte Funktion noch an, die den Text entschlüsselt und anzeigt:
var decrypted_handle;
STRING decrypted_str = " "; // the string can store up to 50 characters
STRING temporary_str;
TEXT decrypted_txt =
{
pos_x = 320;
pos_y = 500;
string (decrypted_str); // displays the decrypted string
flags = VISIBLE;
}
function decrypt_strings()
{
var n = 0;
var temp_number;
str_cpy(decrypted_str, ""); // reset the string
decrypted_handle = file_open_read("encrypted.txt"); // open the file
if (decrypted_handle) // the file exists?
{
while (n < file_length(decrypted_handle)) // read every byte until we reach the end of the file
{
temp_number = file_asc_read(decrypted_handle); // read a byte
temp_number -= 100; // subtract the same "100" value from it
str_for_asc(temporary_str, temp_number); // convert it to a character
str_cat(decrypted_str, temporary_str); // and add it to the decrypted_str
n += 1; // move on to the following byte
}
file_close (decrypted_handle); // the job is done here, so close the file
}
else // the file doesn't exist, decrypted_handle is set to 0
{
str_cpy (decrypted_str, "Encrypted.txt doesn't exist. Press F5 to create it"); // display this message
while (key_any) {wait (1);} // wait until all the keys are released
while (!key_any) {wait (1);} // wait until a key is pressed
}
}
on_f6 = decrypt_strings();
Wie Sie sehen öffnet die Funktion encrypted.txt zum Lesen und dann geschieht etwas Interessantes: es wird geprüft, ob decrypted_handle gültig ist oder nicht. Ich gebe zu, dass ich bei den vorigen Funktionen ein wenig geschummelt habe; ich habe stillschweigend angenommen, dass die benötigten Dateien alle im workshop41 Ordner vorhanden sind. Wenn Sie mein Programm gern zum Absturz bringen möchten, löschen Sie einfach die variables.txt Datei, starten dann das Skript und drücken F2, ohne vorher mit F1 die Datei neu zu erzeugen - folgende Fehlermeldung erwartet Sie:
Ok, genießen Sie den Triumph... mein Code hat nicht berücksichtigt, dass die Datei variables.txt nicht existieren könnte. Aber selbst wenn Sie das gleiche mit der encrypted.txt versuchen, werden Sie nicht viel zu lachen haben, denn die Funktion decrypt_strings() rechnet mit der Möglichkeit, dass encrypted.txt nicht vorhanden sein könnte und in diesem Fall (wenn decrypted_handle gleich 0 ist) reagiert sie folgendermaßen:
else // the file doesn't exist, decrypted_handle is set to 0
{
str_cpy (decrypted_str, "Encrypted.txt doesn't exist. Press F5 to create it"); // display this message
while (key_any) {wait (1);} // wait until all the keys are released
while (!key_any) {wait (1);} // wait until a key is pressed
}
Wie Sie sehen wird eine Meldung angezeigt und dann gewartet bis der Spieler alle Tasten losläßt und dann eine weitere Taste drückt. Dies soll sicherstellen, dass der Spieler die Fehlermeldung sieht. Versuchen Sie einmal, encrypted.txt zu löschen, die Funktion wird trotzdem keinen Absturz verursachen.
Und nun sehen wir uns an was geschieht, wenn die richtige, noch existierende Datei geöffnet wird:
if (decrypted_handle) // the file exists?
{
while (n < file_length(decrypted_handle)) // read every byte until we reach the end of the file
{
temp_number = file_asc_read(decrypted_handle); // read a byte
temp_number -= 100; // subtract the same "100" value from it
str_for_asc(temporary_str, temp_number); // convert it to a character
str_cat(decrypted_str, temporary_str); // and add it to the decrypted_str
n += 1; // move on to the following byte
}
file_close (decrypted_handle); // the job is done here, so close the file
}
Zunächst lesen wir den Inhalt der Datei Byte für Byte bis die Zahl erreicht wird, die der Länge der Datei entspricht. Ja, file_length tut genau dies, die Dateilänge (in Bytes) wird berechnet. Die erste Zeile der Schleife nutzt file_asc_read, um ein Byte zu lesen und speichert dieses in temp_number; davon wird dann der Wert 100 abgezogen, um die "Verschlüsselung" zu entfernen und schließlich wird mit str_for_asc wieder das entsprechende Zeichen erzeugt.
Da wir den String Byte für Byte aus seinen Zeichen zusammensetzen, brauchen wir noch str_cat, um all diese Stringteile zusammenzusetzen. Unser decrypted_str wächst also (im obigen Beispiel) auf folgende Weise, wenn die Schleife läuft:
decrypted_str = "H"
decrypted_str = "HE"
decrypted_str = "HEL"
decrypted_str = "HELL"
decrypted_str = "HELLO"
decrypted_str = "HELLO "
decrypted_str = "HELLO W"
..............................
decrypted_str = "HELLO WORLD"
Testen wir diese Funktion! Starten Sie das Skript und drücken Sie F6; wenn Sie verschlüsselte Daten gespeichert haben, sollten diese entschlüsselt in voller Pracht erscheinen.
Und dies ist das Ende des Workshops. Es hat etwas länger gedauert als ich dachte, aber ich hoffe, dass Sie sich nun mit den Datei-Funktionen der Acknex Engine auskennen. Vergessen Sie nicht, dass die beste Art programmieren zu lernen darin besteht, zu programmieren! Experimentieren Sie mit den Anweisungen und schreiben Sie eigene Programme, die mit den file_var, file_str und file_asc Anweisungen arbeiten.