Motu's Kurs - Basiswissen1

Als allererstes klicken sie jetzt bitte einmal auf „Program“ und „Debug enabled“. Das aktiviert den Debugger, der verhindert, dass ein Programm den Computer zum Absturz bringen kann in dem man zum Beispiel an falsche Speicheradressen Daten kopiert oder andere kritischen Fehler verursacht. Der Nachteil ist, dass das Programms etwas langsamer ausgeführt wird, aber zum testen ist er sehr gut geeignet, da wirklich hardwarenahe Fehler einen dazu zwingen können den Computer neu zu starten (nicht panisch werden wenn das später mal passiert, ist ganz normal und es gibt Schlimmeres).

Dieses Tutorium beschäftigt sich mit den wichtigsten Befehlen in Blitz Basic. Es erläutert wie sie im Syntax (Aufbau der Befehls) aussehen müssen, damit der Compiler den Befehl akzeptiert. Außerdem gibt das Tutorium einige einfache Anwendungsbeispiele die sowohl im Text stehen als auch als Quellcode-Dateien in den Ordnern zu den jeweiligen Tutorien vorliegen. Da dies das erste Tutorium ist, gehe ich nicht davon aus, das der Leser irgendwelche Vorkenntnisse aus anderen Tutorien hat. Deshalb verwende ich zur Bildschirmausgabe den Befehl Print. Dieser Befehl sollte jedoch später in den eigenen Programmen vermieden werden, da er nicht besonders flexibel ist. Ich empfehle immer, Text statt Print zu verwenden - warum werde ich später noch erklären. Also fangen wir doch gleich an, und zwar mit dem Ihnen vielleicht schon aus anderen BASIC-Dialekten bekannten Print-Befehl.

Print schreibt einen Text auf den Bildschirm. Dieser Text muss in Anführungszeichen gesetzt sein. Schreiben wir doch gleich einmal ein „Hallo Welt“-Programm, wie es für den ersten Schritt in einer unbekannten Programmiersprache üblich ist. Klicken sie auf "File" und dann auf "New". Ein neues Programmfenster wird sich öffnen, das den Namen "untitled" trägt. Schreiben sie nun in dieses Fenster:

Print "Hallo Welt"

Fertig! Alternativ können sie es auch aus der Hilfe kopieren. Einfach den Text mit der Maus markieren und auf Strg + C drücken. Dann in das Programmfenster wechseln und Strg + V drücken (diese Art Text zu kopieren kann Ihnen auch während der eigentlichen Programmierung später hilfreich sein, da es so recht schnell geht Programmzeilen zu verschieben oder zu vervielfältigen).

Nun muss das Programm nur noch gestartet werden. Das geht mit der Taste F5 oder über den Menüpunkt "Program" und "Run program". Jetzt sollte es eigentlich losgehen, doch was ist das? Auf dem Bildschirm erscheint ein Fenster. Save Program as... Dieses Fenster wird immer automatisch aufgerufen wenn sie versuchen ein nicht gespeichertes Programm zum Laufen zu bringen. Dies soll verhindert das Informationen verloren gehen. Gehen sie in das Verzeichnis in dem sie ihr Programm speichern möchten. Dann geben sie noch einen Namen an, zum Beispiel "Hallo Welt.bb" und klicken auf „Save“.

Nun wir das Programm ausgeführt. Es öffnet sich ein Windows Fenster und der Text „Hallo Welt“ taucht auf dem Bildschirm auf. Gut nicht? Ein lauffähiges Programm mit nur einer Zeile Text. Das geht nicht in jeder Programmiersprache...

Jetzt erweitern wir das Programm noch etwas, so dass es so aussieht:

Print "Hallo Welt"
Print "Ich bin toll"
Print "Ich kann mit Print umgehen"

Nach dem erneuten ausführen tauchen die drei Zeilen untereinander auf dem Bildschirm auf. Das zeigt, dass Print nach jeder Zeile einen Zeilenumbruch vornimmt, also in der nächsten Zeile weiter schreibt. Der Befehl Print kann aber noch mehr. Versuchen sie einmal dieses Zeile:

Print "Hallo Welt" + ", es ist ein schöner Tag"

Der Text "Hallo Welt" wird mit ", es ist ein schöner Tag" zusammengesetzt. Das kann sehr praktisch sein, wenn man mehrere Informationen in einer Zeile unterbringen will. Doch was genau passiert hier? "Hallo Welt" ist eine so genannte Zeichenkette die wir auch als String bezeichnen, weil das der englische Name dafür ist. ", es ist ein schöner Tag" ist auch ein String. Strings sind aneinander hängende Zeichen in einer festen Reihenfolge. Addiert man in Blitz Basic zwei Strings miteinander, so wird der zweite an den ersten angehängt. Versuchen wir noch etwas anderes:

Print "Hallo Welt " + 10

Wenn man dieses Programm ausführt wird auf dem Bildschirm der Text Hallo Welt 10 auftauchen. Die Zahl 10 ist jedoch kein String, sondern eine Zahl. In vielen anderen Programmiersprachen würde das so nicht funktionieren. In Quick-Basic beispielsweise muss man die Funktion STR$ auf eine Zahl anwenden um sie in einen String zu verwandeln. Blitz Basic nimmt diese Operation jedoch automatisch für sie vor. Immer wenn bei einer Operation, wie zum Beispiel beim zusammenfügen zweier Komponenten, die beiden Teile vom Typ her nicht zusammen passen (z.B. weil wie in unserem Beispiel eine ein String und die andere eine Zahl ist) werden sie aneinander angepasst. Wer das für unsauber hält kann die Umwandlung auch selbst vornehmen, indem er die Zahl mit der Funktion STR$ selbst in einen String umwandelt.

Print Str$(10) + Str$(100)

Dieses Programm liefert als Ergebnis 10100. Weil die beiden Strings "10" und "100" aneinander gehängt werden. Ganz anders sieht das Ergebnis so aus:

Print 10 + 100

In diesem Fall handelt es sich um zwei Zahlen, das heißt es wird keine Typumwandlung vorgenommen und die Zahlen werden addiert. Im Fenster erscheint dann das Ergebnis dieser Addition, also:

110

Statt einem festen Wert wie in unseren Beispielen kann man aber auch Variablen mit Print ausgeben. Was sind Variablen? Eine Variable kann Informationen speichern, zum Beispiel einen String oder eine Zahl. Es gibt unterschiedliche Arten von Variablen:

String-Variablen speichern eine Zeichenkette (z.B. "Hallo Welt"; "100"; "Blitz Basic ist toll!").

Integer-Variablen speichern ganze Zahlen (z.B. 1; 207053; 42).

Fliesskomma-Variablen speichern Zahlen mit Nachkommastellen – wobei am Computer ein Punkt statt eines Kommata benutzt wird (z.B. 83.76552; 52.234; 100).

Was sollte man über die verschiedenen Variablentypen sonst noch wissen?

Eine String-Variable kann bis zu 255 Zeichen enthalten – das sollte eigentlich immer ausreichen. Eine Integer-Variable kann in Blitz Basic einen sehr hohen Wert annehmen (etwas über 2.000.000.000) und auch negative Zahlen bis zu dieser Grenze enthalten (damit entspricht sie nicht der Quick-Basic Integer, sondern ist eher mit Quick-Basics Long-Variable vergleichbar)! Fliesskomma-Variablen (englisch: Floatingpoint oder kurz Float) sollten nur verwendet werden wenn auch wirklich Nachkommastellen gebraucht werden, da das Rechnen mit ihnen langsamer ist als mit Integer-Variablen! Sie können ebenfalls negative Werte annehmen und bis zu sieben Nachkommastellen haben.

Um eine Variable zu definieren gibt es zwei Möglichkeiten: Local definiert eine lokale Variable, die nur in der aktuellen Funktion funktioniert und Global definiert eine Variable so, dass sie im ganzen Programm verfügbar ist. Was Funktionen sind, und wie man sie benutzt wir später noch genau erklärt, für unsere Beispiele benutzen wir erst einmal Global. Hier ein Programm das alles was wir bis jetzt über Variablen gelernt haben vereint:

Global IchBinEinString$
Global IchBinEinInteger
Global IchBinEinFloat#

IchBinEinString = "Hallo"
IchBinEinInteger = 100
IchBinEinFloat = 45.10

Print IchBinEinString$
Print IchBinEinInteger
Print IchBinEinFloat#

Dieses Beispiel Programm definiert zuerst drei unterschiedliche Variablen, eine Zeichenkette (String), eine ganze Zahl (Integer) und eine Fliesskomma (Float). Danach setzt es die Variablen auf einen ihrem Typ entsprechendem Wert und gibt sie am Schluss aus. Variablen sind für die Programmierung absolut unverzichtbar. Egal was man programmiert, kaum ein Programm kommt ohne Variablen aus. Eine wichtige Frage, die man sich vor jeder Variablendefinition stellen sollte, ist, was soll die Variable machen? Denn danach entscheidet sich nicht nur der Name, der möglichst treffend sein sollte, sondern auch welchen Typ die Variable haben sollte. Soll die Variable beispielsweise den Namen des Spielers speichern, so ist ein String angebracht. Integer sind für jede ganze Zahl die abgespeichert werden soll geeignet, wie etwa Lebenspunkte. Float-Variablen sind eigentlich nur für mathematische Rechnungen wichtig und man sollte so weit wie möglich auf sie verzichten, da die Rechnung mit Float wie bereits gesagt viel langsamer läuft als die Rechnung mit Interger. In komplexen Spielen, in denen Faktoren wie beispielsweise Gravitation eine Rolle spielen, lassen sie sich aber nicht ganz vermeiden.

Wenn Sie sich das Programm oben noch einmal anschauen dürfte Ihnen etwas auffallen:

Man definiert einen String, indem man direkt hinter die Variable bei deren Definition ein $-Zeichen setzt (ohne Leerzeichen!). Ein Interger ist der Standartvariablentyp und benötigt daher kein zusätzliches Zeichen. Eine Float wird durch eine # gekennzeichnet. Außerdem sieht man in dem Programm, das die Sonderzeichen hinter der Variable in dem später Programm nicht gesetzt werden müssen, aber gesetzt werden können! Der Übersichtlichkeit halber sollte man das tun, damit man nicht mit seinen Variablentypen durcheinander kommt. Man kann es aber auch weglassen, wenn einem die ganzen $ und # Zeichen zu viel Tipparbeit sind. Ich empfehle aber immer die Zeichen mitzusetzen.

Jetzt haben wir schon eine Menge gelernt. Schreiben wir doch mal ein Programm das etwas Sinnvolles tut. Nehmen wir an ein armer Schüler darf keinen Taschenrechner benutzen und soll dennoch haufenweise Zahle miteinander multiplizieren (Ich weiß ihr würdet jetzt lieber anfangen „Diablo“ zu programmieren, doch jeder fängt nun mal klein an). Er schreibt sich also ein tolles Programm:

Global Ergebnis, Zahl1, Zahl2
Zahl1 = 10
Zahl2 = 15
Ergebnis = Zahl1 * Zahl2
Print Ergebnis

Auf den ersten Blick fällt schon mal auf, dass man mehrere Variablen in einer Zeile definieren kann. Soweit so gut. Was ihn jedoch stört, ist, dass er jedes Mal die Zahlen in dem Blitz Basic-Editor eingeben muss. Also verwendet er einen neuen Befehl den er sich aus der Hilfe geangelt hat. Input ließt eine Variable vom Benutzer ein (auch ein Befehl den ich erfahrenen Programmieren nicht ans Herz lege, später lernen wir bessere aber kompliziertere Alternativen).

Er modifiziert sein Programm also ein wenig:

Global Ergebnis, Zahl1, Zahl2
Zahl1 = Input ()
Zahl2 = Input ()
Ergebnis = Zahl1 * Zahl2
Print Ergebnis

Input ist eine Funktion. Eine Funktion wird aufgerufen, indem man eine Variable auf die Funktion setzt. Die Funktion gibt dann an die Variable einen Wert zurück, so wie eine Rechnung an eine Variable einen Wert zurückgibt. Wenn man beispielsweise a = 1 + 1 schreibt, enthält a danach den Wert 2. Setzt man a = input (), so enthält a danach den Wert den der Benutzer eingegeben hat. An Funktionen kann man Parameter übergeben. An Input kann man, wenn man möchte, einen Text übergeben, der dann vor dem Eingabepfeil steht. Das nächste Beispiel verdeutlicht dies:

Global Ergebnis, Zahl1, Zahl2
Zahl1 = Input ("erste Zahl : ")
Zahl2 = Input ("zweite Zahl: ")
Ergebnis = Zahl1 * Zahl2
Print "Das Ergebnis lautet: " + Ergebnis

An die Funktion Input wird das Parameter "erste Zahl" bzw. "zweite Zahl" übergeben. Das verleiht dem Ganzen gleich eine bessere Optik und auch jemand der das Programm nicht selbst geschrieben hat kann es so benutzen. An einige Funktionen, wie Input, kann man Parameter übergeben, muss es aber nicht. Es gibt auch Funktionen an die man Parameter übergeben muss! Eine solche wollen wir uns gleich einmal selber schreiben. Es gibt nämlich zusätzlich zu den vordefinierten Funktionen, die der Programmierer von Blitz Basic geschrieben hat, auch die Möglichkeit selbst Funktionen zu entwerfen. Und zwar soll die Funktion zwei Zahlen a und b miteinander multiplizieren. Ich gebe zu, das ist eigentlich sinnlos, da es genau dafür schon einen Befehl gibt, aber es soll ja auch nur zeigen wie Funktionen definiert werden und nicht wie man multipliziert...

Print Multi(100, 10)
End

Function Multi (Zahl1, Zahl2)
Return (Zahl1 * Zahl2)
End Function

Sieht auf den ersten Blick irgendwie anders aus als die Programme die wir zuvor betrachtet haben. Nicht unschuldig daran ist, dass wir diesmal die Varibalen einfach nicht definiert haben! Das muss man nicht, man sollte es in größeren Programmen aber der Übersicht wegen tun – außerdem sind so alle Variablen als local definiert!

Was aber macht dieses Programm? Zuerst schreibt es etwas auf den Bildschirm, und zwar den Wert den die Funktion Multi zurückgibt wenn man an Multi die Parameter 100 und 10 übergibt. Danach wird das Hauptprogramm mit End abgeschlossen.

Doch was tut die Funktion, die wir selbst definiert haben? Zuerst einmal setzt sie die Variablen Zahl1 und Zahl2 auf die Werte, die an die Funktion gegeben wurden. 100 an Zahl1 und 10 an Zahl2. Dann wird der Befehl Return aufgerufen. Return gibt den Funktionswert zurück. In diesem Fall das Ergebnis der Rechnung

Zahl1 * Zahl2

Außerdem verlässt Return gleich noch die Funktion und das Programm kehrt an die Stelle zurück wo sie aufgerufen wurde. Zum Schluss wird das Ende der Funktion noch mit End Function definiert. Das muss immer getan werden, auch wenn diese Stelle vom Programm nie erreicht werden kann, damit der Compiler weiß, wo die Funktion zu Ende ist. Steht hinter Return kein Parameter gibt die Funktion eine 0 zurück. Das ist Sinnvoll wenn die Funktionen keinen Wert errechnen, sondern nur Befehle ausführen soll.

Gut, jetzt können wir mit einfachen Variablen und Funktionen umgehen. Jetzt kommen noch die komplexeren Variablenstrukturen (Arrays) und die sogenannten Schleifen. Danach kann es dann richtig losgehen. Zuerst einmal die Arrays. Arrays sind Variablenfelder, in denen man mehrere Variablen speichern kann. Möchte man beispielsweise ein Strategiespiel programmieren, so gibt es Unmengen an Einheiten. Und wer möchte schon für jede mögliche Einheit alle Bewegungen, Befehle und Verhaltensweisen extra programmieren? Keiner, gut. Denn genau für solche und ähnliche Probleme können Arrays verwendet werden. Unser Beispiel wird jedoch nicht ganz so komplex wie ein Strategiespiel sein. Es geht darum, dass in einem Spiel zehn Spieler sich am Anfang mit Namen eintragen können sollen. Das sieht nun so aus:

Local x
Dim SpielerName$(10)

For x = 1 To 10 Step 1
SpielerName$(x) = Input ("Spieler Nr." + x)
Next

For x = 10 To 1 Step -1
Print "Spieler " + x + ":" + SpielerName$(x)
Next

So etwas, jetzt erkläre ich doch gleich die Schleifen mit. Aber was soll's... Also, zuerst definiere ich eine lokale Variable x und dann ein Array SpielerName$(10). Das Array hat eine Länge von 10 Variablen (1 bis 10). Durch diese eine Definition habe ich auf einmal die Variablen SpielerName$(1), SpielerName$(2), SpielerName$(3) ... bis SpielerName$(10) definiert. Mit einem einzigen Befehl! Und noch einen weiteren Vorteil haben Arrays: Um den Index (die Zahl in der Klammer) anzusprechen, kann ich andere Variablen verwenden. Das mag auf den ersten Blick nicht so verlockend klingen, doch schon in den nächsten drei Zeilen wird der Vorteil klar:

For x = 1 to 10 Step 1

lässt die Variable x von dem Wert 1 bis zu dem Wert 10 durchlaufen und erhöht sie bei jedem Durchlauf um den Wert der hinter Step steht (hier 1, es wären auch andere Werte wie –1; 0.564 oder 4 möglich).

Wichtig: Step 1 muss man eigentlich nicht dazuschreiben, sondern kann und sollte es einfach weglassen, da For wenn man Step nicht angibt automatisch von 1 ausgeht. Ich hab es hier nur hin geschrieben um Step auch gleich mit zu erklären.

Beim ersten Durchlauf ist x also 1, beim zweiten 2 usw. bis es am Ende 10 ist. Nach dem Durchlauf mit 10 wird die Schleife beendet und das Programm fährt unter dem Next fort (Anmerkung für Quick-Basic Programmierer: Next x funktioniert in Blitz Basic nicht, die Variable muss weggelassen werden!). Eine solche For-Schleife ist immer dann sinnvoll, wenn man für mehrere Dinge eine Überprüfung vornehmen möchte, die in einem Array gespeichert sind.

Die zweite Schleife gibt die Spieler in umgekehrter Reihenfolge auf dem Bildschirm aus und setzt mit vor den Namen der Spieler noch das Wort Spieler, die Nummer des Spielers und einen Doppelpunkt.

Kommen wir zu einer weiteren Schleife die recht nützlich ist: Der while / wend Schleife. Sie wiederholt einen Befehlsblock so lange, bis eine Bedingung erfüllt ist.

Hier ein typisches Beispielprogramm:

while Ende = 0
if KeyHit(1) then Ende = 1
wend

Dieses Programm wartet darauf, dass Esc gedrückt wird. In der Schleife könnten sich jetzt noch viel mehr Befehle befinden. Sogar ein ganzes Spiel. Doch gucken wir uns die Schleife erst einmal genau an. Zuerst wird die while Bedingung gesetzt. Solange Ende = 0 ist, soll das Programm alle Befehle ausführen die in der Schleife stehen. Ist die Schleife bei wend angekommen springt sie zurück zu der while Zeile und überprüft die Bedienung erneut. Und zwar solange, bis die Bedingung nicht mehr erfüllt ist. Ist die Bedingung nicht mehr erfüllt springt das Programm hinter die wend Zeile und arbeitet dort weiter.

Außerdem haben wir gleich noch den if Befehl kennen gelernt. If prüft ob eine Bedingung erfüllt ist oder nicht. Ist die Bedingung erfüllt, so wird alles was hinter dem if steht abgearbeitet. Ist die Bedingung nicht erfüllt, läuft das Programm einfach weiter. If ist einer der wichtigsten Befehle überhaupt, da er Verzweigungen im Programm und damit Interaktivität überhaupt erst richtig ermöglicht!

Die Funktion KeyHit überprüft ob eine bestimmte Taste gedrückt wurde oder nicht. Also, wenn die Taste 1 (entspricht ESC, alle Tastaturcodes stehen im Anhang unter 3.B) gedrückt wurde, wird Ende auf 1 gesetzt. Ende ist nun nicht mehr 0, also wird die Programmschleife verlassen. Ganz einfach, oder?

Noch ein paar Worte zur if-Prüfung. Es gibt verschiedene Möglichkeiten den if Befehl einzusetzen. Zum einen kann man ihn wie oben gesehen verwenden, und hinter ihm einfach einen Befehl angeben der nur ausgeführt werden soll wenn die vorangegangene Bedingung wahr ist. Man kann aber auch mehrere Befehle in einer if-Bedingung ausführen lassen. Dazu gibt es wieder zwei Wege: Entweder man trennt die Kommandos durch einen Doppelpunkt ( : ) voneinander ab und schreibt sie einfach hintereinander:

if KeyHit(1) then Ende = 1: print "Jetzt aber Schluss": print "Doppelpunkte sind toll"

oder aber man schreibt sie unter die if-Bedingung und beendet den Befehlsblock mit end if:

if KeyHit(1) then
Ende = 1
print "Jetzt aber Schluss"
print "end if ist noch toller !"
end if

Wichtig ist bei der zweiten Methode, dass man direkt hinter das then in diesem Fall nichts schreiben darf! Die erste Methode empfehle ich bei nur wenigen Befehlen, sollte man jedoch große Programmteile in einer if Schleife ausführen, so sollte man mit end if arbeiten.

Bei allen Befehlen und Schleifen die wir bis jetzt gelernt haben ist es wichtig zu wissen, dass man sie auch ineinander schachteln kann. Eine For / next Schleife in einer while / wend Schleife die durch eine if / then Bedingung aufgerufen wird, die ihrerseits wieder in zwei For / next Schleifen...

All das ist kein Problem und wird häufig verwendet um dem Programm komplexere Zusammenhänge zu beschreiben. Selbstverständlich gibt es noch viele andere Dinge die man hier erwähnen kann, doch da dieses Tutorium nicht die Praxis ersetzen kann, sollte sich jeder der mehr wissen will die weiteren Tutorien durchlesen und dann selber mit der Sprache rumexperimentieren. Das im ersten Tutorium erlernte wird übrigens in den folgenden Tutorien vorausgesetzt.

Weiter mit Teil 2...



Quelle: www.BlitzBasic.de