The Real Adok's Way to Creative Basic @ tutorials.de: Tutorials, Forum & Hilfe

INHALTSVERZEICHNIS

Vorwort
Kapitel 1 Erste Schritte
Kapitel 2 Grundlegende Befehle zur Verarbeitung von Zahlen
Kapitel 3 Einfache grafische Effekte
Kapitel 4 Blöcke
Kapitel 5 Programmierung von Abenteuerspielen
Kapitel 6 Grafikprogrammierung
Kapitel 7 Datentypen in Creative Basic
Kapitel 8 Dateiverwaltung
Kapitel 9 Befehle und Funktionen
Kapitel 10 Funktionen zur Verarbeitung von Strings
Kapitel 11 Die Creative-Basic-Toolbox
Nachwort

Vorwort

Mein älterer Kurs behandelte QBasic. Diesen neuen Kurs habe ich geschrieben, weil QBasic aktuellen Betriebssystemen nicht mehr beiliegt. Deshalb habe ich nach einer Alternative gesucht und Creative Basic gefunden, das man im Internet kostenlos und legal herunterladen kann. Creative Basic ist zu QBasic nicht kompatibel, es gibt viele Unterschiede. Deshalb habe ich einen neuen Kurs geschrieben.

KAPITEL 1
Erste Schritte

Es gibt anscheinend ziemlich viele Leute, die das Programmieren in Basic erlernen wollen und sehnsüchtig auf einen Kurs warten. Deshalb entschloss ich mich, mit einem Kurs anzufangen.

In meinem Kurs behandeln wir den Interpreter Creative Basic, der unter der Internet-Adresse http://www.ionicwind.com/index.php?o...k=section&id=6 kostenlos heruntergeladen werden kann.

Nun, lasst uns mit dem Kurs beginnen.

Nachdem Creative Basic installiert worden ist, kann es aus dem Programm-Menü heraus gestartet werden. Nach dem Starten erscheint der Editor. Wenn ihr auf „File“ und danach auf „New“ sowie auf „Source File“ klickt, könnt ihr ein Programm eingeben.

Tippt nun genauso, wie ihr mit dem Editor einen Brief schreiben würdet, folgendes Programm ab. Der Name des Programms lautet KURS0001.

Code :

DIM name AS STRING
PRINT "Hallo, Gebieter! Wie soll ich dich ansprechen?"
PRINT "Gib deinen Namen ein!"
INPUT name
PRINT "Hallo, " + name + ", ich will all deine Wünsche erfüllen."
PRINT "Ich will dir jetzt zeigen, mit welchen Befehlen du mich"
PRINT "beherrschen kannst."

Wenn ihr dieses Programm fertig abgetippt habt, könnt ihr es durch das Drücken der Taste F4 starten.

Zuerst erscheint folgender Text: Hallo, Gebieter! Wie soll ich dich ansprechen? Gib deinen Namen ein!

Jetzt seid ihr an der Reihe. Gebt entweder euren Namen, ein Pseudonym oder was auch immer ein. Mit Enter schließt ihr die Eingabe wieder ab.

Nun erscheint ein weiterer Text: Ich will dir jetzt zeigen, mit welchen Befehlen du mich beherrschen kannst. Danach erscheint die Meldung "<<< Program ended. Press any key to close >>>". Nach einem weiteren Tastendruck wird das Programm beendet.

Das war also unser erstes Programm, das wir erstellt haben! So einfach geht das. Super, nicht wahr? Aber wie funktioniert das Programm eigentlich?

Die erste Zeile des Programms lautet DIM name AS STRING. Im Unterschied zu anderen, älteren Basic-Dialekten müssen in Creative Basic Variablen definiert werden, bevor man sie benutzen kann. Lasst euch davon nicht irritieren, es ist eine einfache Sache. Variablen sind Behälter, in denen Werte gespeichert werden. Wir definieren hier eine Variable namens name. Ihr Typ ist STRING. Bei STRING handelt sich um den Datentyp „Zeichenkette“ – name ist also eine Variable, in der Texte gespeichert werden können.

Die zweite Zeile beginnt mit PRINT. Dies ist ein Befehl. Der Befehl PRINT hat mehrere Funktionen, weil er mit Parametern aufgerufen werden kann. "Hallo, Gebieter! Wie soll ich dich ansprechen?" ist zum Beispiel ein solcher Parameter.

PRINT dient dazu, Zeichenketten oder Zahlen auf dem Bildschirm auszugeben. In unserem Beispiel gibt PRINT folgendes aus: Hallo, Gebieter! Wie soll ich dich ansprechen? Dies ist eine Zeichenkette. Zeichenketten müssen in Basic immer in Anführungszeichen eingeschlossen sein. Ansonsten würde der Interpreter diesen Text als Variablen interpretieren.

Die dritte Zeile verstehen wir jetzt schon. Kommen wir also zur vierten Zeile. Hier finden wir den Befehl INPUT. Was ist das schon wieder? Mit INPUT lassen sich Zeichenketten von der Tastatur eingeben. In diesem Fall fragte der Computer in der dritten Zeile nach eurem Namen. Der Satz bleibt auf dem Bildschirm stehen, und mit INPUT erwartet der Computer die Eingabe eures Namens. Als Parameter von INPUT steht im Beispielprogramm name – die Variable, die wir am Anfang definiert haben.

Die fünfte Zeile ist wieder ein PRINT-Befehl. Diesmal sind als Parameter mehrere Zeichenketten angegeben, die durch Pluszeichen („+“) miteinander verkettet wurden. Eine dieser Zeichenketten ist die Variable name.

Die restlichen Zeilen enthalten weitere PRINT-Kommandos.

Fertig! Das war das ganze Programm. Jetzt können wir uns wieder entspannt zurücklehnen.

Ich möchte noch einige Tipps zum weiteren Verlauf dieses Kurses geben. Man sollte die Beispielprogramme immer ausdrucken und das Listing vor den Augen haben. Alle Anweisungen in diesem Text beziehen sich auf die Listings. Die Beispielprogramme kann man mit dem Menüpunkt File-Print ausdrucken.

Das eingetippte Programm kann man mit dem Menüpunkt File-Save abspeichern. Wenn ihr das Programm zum ersten Mal abspeichert, werdet ihr nach dem Dateinamen gefragt, unter dem es gespeichert werden soll. Für dieses Programm schreibt KURS0001. Creative Basic ergänzt automatisch die Dateierweiterung CBA. Der komplette Name wird nach dem Abspeichern KURS0001.CBA heißen.

Nach dem Ende einer Lektion solltet ihr mit den erlernten Befehlen experimentieren. Zu diesem Zweck gebe ich ‚Hau-sauf-gaben’, die ihr lösen sollt. Die richtigen Ergebnisse findet ihr im Anhang.

Aufgabe 1: Entwerft ein Programm, das zuerst den Benutzer nach seinem Namen und danach nach seinem Pseudonym fragt. Anschließend soll der Computer folgenden Text auf dem Bildschirm ausgeben: "Guten Tag, <name>! Dein Pseudo lautet <pseudo>. Willkommen im Club der Creative-Basic-Programmierer!" <name> steht dabei für die Variable, in der der Name, und <pseudo> für die Variable, in der das Pseudo abgespeichert ist. In meinem konkreten Fall würde der Satz lauten: "Guten Tag, Claus-Dieter Volko! Dein Pseudo lautet The Real Adok. Willkommen im Club der Creative-Basic-Programmierer!" Beachtet, daß ihr abweichend vom Programmbeispiel KURS0001 diesmal zwei Stringvariablen verwenden müßt.

Aufgabe 2: Nun sollt ihr ein Programm schreiben, das den Namen des Benutzers und den seiner Freundin einliest. Anschließend soll es einen lustigen Satz über die beiden auf dem Bildschirm ausgeben, etwa so: "<freundin>: 'Wann wirst du mich endlich heiraten, <benutzer>?'"

Lösungen zu Kapitel 1

Aufgabe 1: Hier musstet ihr ein Programm schreiben, das zuerst den Benutzer nach seinem Namen und seinem Pseudo fragt und anschließend einen Text ausgibt. Eine mögliche Lösung wäre das folgende Listing:

Code :

DIM name AS STRING
DIM pseudo AS STRING
PRINT "Wie lautet dein Name?"
INPUT name
PRINT "Und wie lautet dein Pseudo?"
INPUT pseudo
PRINT "Guten Tag, " + name + "! Dein Pseudo lautet " + pseudo + "."
PRINT "Willkommen im Club der Creative-Basic-Programmierer!"

Aufgabe 2: Ihr musstet ein Programm schreiben, das den Namen des Benutzers und den seiner Freundin einliest. Anschließend soll ein lustiger Text ausgegeben werden.

Hier eine mögliche Lösung:

Code :

DIM benutzer AS STRING
DIM freundin AS STRING
PRINT "Wie heißt du?"
INPUT benutzer
PRINT "Und wie heißt deine Freundin bzw. dein Freund?"
INPUT freundin
PRINT freundin + ": 'Wann wirst du mich endlich heiraten, " + benutzer + "?'"

KAPITEL 2

Grundlegende Befehle zur Verarbeitung von Zahlen

Das letzte Mal lernten wir die Befehle PRINT und INPUT kennen. PRINT und INPUT sind die grundlegenden Befehle zur Verarbeitung von Zeichenketten (Strings). Nun wollen wir zur Abwechslung die Zahlenvariablen, wie wir sie aus der Mathematik kennen, unter die Lupe nehmen.

Dazu gleich ein Beispielprogramm. Gebt es in Creative Basic ein und speichert es unter KURS0002.CBA.

Code :

DIM zahl1 AS INT
DIM zahl2 AS INT
PRINT "Gib Zahl 1 ein!"
INPUT zahl1
PRINT "Gib Zahl 2 ein!"
INPUT zahl2
PRINT "Addition:"
PRINT STR$(zahl1) + " +" + STR$(zahl2) + " =" + STR$(zahl1 + zahl2)
PRINT "Subtraktion:"
PRINT STR$(zahl1) + " -" + STR$(zahl2) + " =" + STR$(zahl1 - zahl2)
PRINT "Multiplikation:"
PRINT STR$(zahl1) + " *" + STR$(zahl2) + " =" + STR$(zahl1 * zahl2)
PRINT "Division:"
PRINT STR$(zahl1) + " /" + STR$(zahl2) + " =" + STR$(zahl1 / zahl2)

Schon haben wir ein einfaches Rechenprogramm! Startet es, und Creative Basic führt euch alle Grundrechnungsarten vor.

zahl1 und zahl2 sind, wie sich manche von euch wahrscheinlich schon denken werden, Zahlenvariablen. Wir haben sie als INT definiert, als ganze Zahlen. Also als Zahlen größer oder gleich Null ohne Nachkommastellen.

Um die Zahlen mit PRINT auszugeben, müssen wir sie, da wir den Verkettungsoperator verwenden, in Strings umwandeln (konvertieren). Dazu dient die Funktion STR$.

Die Zeichen ‘+’, ‘-’, ‘*’ und ‘/’ sind, wie ihr sicherlich schon bemerkt habt, Rechenzeichen, wobei '/' für Division steht. Dieses Rechenzeichen sollte man sich besonders gut merken, weil es von der schriftlichen Norm abweicht.

Anfänger könnten auch leicht '*' (Multikplikationszeichen) mit '.' (Komma) verwechseln. Die englische Schreibweise des Kommas und der Rechenzeichen wird übrigens in den meisten Anwendungsprogrammen und Programmiersprachen verlangt. Basic ist daher kein Einzelfall, und falls ihr doch nicht mehr weiterprogrammieren wollt (zu schwierig!?), solltet ihr euch diese Schreibweise trotzdem merken.

Natürlich kann man nicht nur die Ergebnisse der Rechnungen anzeigen, sondern sie auch anderen Variablen zuweisen. Hier ein weiteres Beispielprogramm. Speichert es unter KURS0003.CBA und startet es mit F4.

Code :

DIM zahl1 AS INT
zahl1 = 100
DO
zahl1 = zahl1 + 1
PRINT zahl1
UNTIL zahl1 = 200

Nun möchte ich das Programm Zeile für Zeile beschreiben. Zeile 1 definiert die Variable zahl1, Zeile 2 setzt diese Variable auf 100.

Das habe ich vorhin vergessen zu erwähnen: Das Gleichheitszeichen kann in Basic verschiede Bedeutungen haben. Hier bedeutet es Zuweisung. Das heißt, dass der Variablen, die links von dem Gleichheitszeichen steht, der Wert rechts von dem Gleichheitszeichen zugewiesen wird.

Eine Anweisung wie

Code :

1	100 = zahl1

führt zu einer Fehlermeldung.

Man kann übrigens auch LET vor die Variable schreiben. Unser Beispiel würde dann folgendermaßen aussehen:

Code :

1	LET zahl1 = 100

Die Verwendung von LET ist aber heutzutage weder notwendig noch empfehlenswert.

Die nächste Zeile enthält ein neues Schlüsselwort. Es handelt sich um DO, einen sehr vielfältig einsetzbaren Befehl, den wir im Kapitel über Schleifen und Verzweigungen genau besprechen werden. Jetzt sei nur gesagt, daß der Programmteil zwischen DO und UNTIL solange ausgeführt wird, bis die nachstehende Bedingung (zahl1 = 200) erfüllt ist.

In der 4. Zeile wird der Variablen zahl1 das Ergebnis der Addition zahl1 + 1 zugewiesen. Das ist einfacher, als es klingt, denn es bedeutet nichts anderes, als dass zahl1 um 1 erhöht wird. Danach wird die Zahl auf dem Bildschirm ausgegeben, und mit UNTIL wird das Ganze ab der vierten Zeile wiederholt. Alles klar?

KAPITEL 3

Einfache grafische Effekte

Wie kann man einfache Grafikeffekte realisieren, um die eigenen Programme aufzuwerten? Dazu gibt es mehrere Befehle, die ich jetzt aufzählen und näher erklären möchte.

Es ist vielleicht nicht so schön, wenn bei einem Programm die Textausgaben nacheinander folgen. Deshalb gibt es den Befehl LOCATE. Mit ihm kann man den Cursor an einer beliebigen Stelle des Bildschirms plazieren. Die "Syntax" des Befehls, das heißt, seine Schreibweise, lautet:

Code :

1	LOCATE zeile, spalte

Diese Syntax verwenden übrigens alle Basic-Dialekte auf dem PC. Auf den meisten anderen Computern wird zuerst die Spalte angegeben.

Der Textmodus, auf den wir uns (vorläufig) beschränken, hat eine Auflösung von 80 Spalten mal 25 Zeilen. Mit dem LOCATE-Befehl positionieren wir quasi den Cursor auf die durch die Variablen zeile und spalte angegebene Position. Die nächste Bildschirmausgabe findet an dieser Position statt, was sehr praktisch ist.

Um die Fähigkeiten des LOCATE-Befehls zu demonstrieren, hier eine erweiterte Version unseres Rechenprogramms:

Code :

DIM zahl1 AS INT
DIM zahl2 AS INT
LOCATE 2, 2
PRINT "Wie lautet die erste Zahl?"
LOCATE 3,2
INPUT zahl1
LOCATE 5, 2
PRINT "Wie lautet die zweite Zahl?"
LOCATE 6,2
INPUT zahl2
CLS
LOCATE 2, 2
PRINT "Zahl 1:" + STR$(zahl1)
LOCATE 2, 60
PRINT "Zahl 2:" + STR$(zahl2)
LOCATE 3, 1
PRINT " --------------------------------------------------------------------"
LOCATE 5, 2
PRINT "Addition:"
LOCATE 5, 18
PRINT zahl1 + zahl2
LOCATE 6, 2
PRINT "Subtraktion:"
LOCATE 6, 18
PRINT zahl1 - zahl2
LOCATE 7, 2
PRINT "Multiplikation:"
LOCATE 7, 18
PRINT zahl1 * zahl2
LOCATE 8, 2
PRINT "Division:"
LOCATE 8, 18
PRINT zahl1 / zahl2

Ein neuer Befehl, der in diesem Programm vorkommt, ist CLS. CLS „löscht“ den Bildschirm.

Dieses Programm werden wir noch öfters verändern. Speichert es also unter KURS0004.CBA ab.

Bisher hatten alle Programme eine einheitliche Farbkombination: weißer Text auf schwarzem Hintergrund. Da dies mit der Zeit sehr eintönig werden kann, gibt es in Creative Basic einen Befehl, um eine andere Farbkombination einzustellen: COLOR. Seine Syntax lautet:

Code :

1	COLOR vordergrundfarbe, hintergrundfarbe

Die Vordergrundfarbe ist hierbei die Farbe, in der der Text geschrieben werden soll, während die Hintergrundfarbe, wie der Name schon sagt, die Farbe des Hintergrunds ist.

Wie gibt man nun die Vordergrundfarbe und die Hintergrundfarbe an? Das ist leider nicht ganz so einfach.

Zu jeder Farbe gehört ein sogenannter Farbcode. Dieser Farbcode ist eine Zahl von 0 bis einschließlich 31.

Jede Zahl von 0 bis einschließlich 7 steht für eine "dunkle" Farbe. Zählt man zu einer dieser Zahlen 8 dazu, so erhält man die dazugehörige "helle" Farbe. Beispielsweise ist der Farbcode der Farbe Dunkelblau 1. Daher ist der Farbcode der Farbe Hellblau 9. Nur die Farbe mit der Nummer 8 ist hier eine Ausnahme, denn diese ist Grau.

Zählt man zu einer der Farben von 0 bis einschließlich 15 nun 16 hinzu, erhält man eine "blinkende" Farbe.

Man kommt nicht darum, die Farbcodes auswendig zu lernen. Da ich euch aber jetzt die "Philosophie" hinter der Reihenfolge der Farbcodes erklärt habe, wird es euch sicherlich leicht fallen. Hier nun die vollständige Liste der Farbcodes:

0 Schwarz
1 Dunkelblau
2 Dunkelgrün
3 Dunkelzyan
4 Dunkelrot
5 Dunkelviolett
6 Braun
7 Weiß

8 Grau
9 Hellblau
10 Hellgrün
11 Hellzyan
12 Hellrot
13 Hellviolett
14 Gelb
15 Leucht-Weiß

16 Blink-Schwarz
17 Blink-Dunkel-Blau
18 Blink-Dunkel-Grün
19 Blink-Dunkel-Zyan
20 Blink-Dunkel-Rot
21 Blink-Dunkel-Violett
22 Blink-Braun
23 Blink-Weiß

24 Blink-Grau
25 Blink-Hell-Blau
26 Blink-Hell-Grün
27 Blink-Hell-Zyan
28 Blink-Hell-Rot
29 Blink-Hell-Violett
30 Blink-Gelb
31 Blink-Leucht-Weiß

Wenn man eine Farbe öfters verwendet, könnte man sie auch in einer Variablen speichern. Wird z.B. die Farbe Dunkelgrün öfters benötigt, so könnte man ihren Farbcode der Variablen gruen zuweisen. Statt COLOR 2 braucht man dann nur mehr COLOR gruen zu schreiben. Creative Basic ersetzt während der Ausführung automatisch den Platzhalter gruen durch den Wert 2.

Man könnte auch einer Variablen hell den Wert 8 und einer Variable blink den Wert 16 zuweisen. Will man dann die Vordergrundfarbe auf Blink-Hellgrün umschalten, schreibt man einfach COLOR blink + hell + gruen. Ihr seht, das ist unserer Umgangssprache schon sehr ähnlich!

Doch nun zu unserem Beispielprogramm. Es ist eine Weiterentwicklung von KURS0004.CBA, und deshalb speichern wir es unter KURS0005.CBA.

Code :

DIM zahl1 AS INT
DIM zahl2 AS INT
DIM blau AS INT
DIM gelb AS INT
DIM weiss AS INT
DIM hell AS INT
blau = 1
gelb = 14
weiss = 7
hell = 8
COLOR hell + weiss, blau
CLS
LOCATE 2, 2
PRINT "Wie lautet die erste Zahl?"
COLOR gelb, blau
LOCATE 3,2
INPUT zahl1
COLOR hell + weiss, blau
LOCATE 5, 2
PRINT "Wie lautet die zweite Zahl?"
COLOR gelb, blau
LOCATE 6,2
INPUT zahl2
CLS
COLOR hell + weiss, blau
LOCATE 2, 2
PRINT "Zahl 1:"
COLOR gelb, blau
LOCATE 2, 9
PRINT STR$(zahl1)
COLOR hell + weiss, blau
LOCATE 2, 60
PRINT "Zahl 2:"
COLOR gelb, blau
LOCATE 2, 67
PRINT STR$(zahl2)
COLOR hell + weiss, blau
LOCATE 3, 1
PRINT " --------------------------------------------------------------------"
LOCATE 5, 2
PRINT "Addition:"
COLOR gelb, blau
LOCATE 5, 18
PRINT zahl1 + zahl2
COLOR hell + weiss, blau
LOCATE 6, 2
PRINT "Subtraktion:"
COLOR gelb, blau
LOCATE 6, 18
PRINT zahl1 - zahl2
COLOR hell + weiss, blau
LOCATE 7, 2
PRINT "Multiplikation:"
COLOR gelb, blau
LOCATE 7, 18
PRINT zahl1 * zahl2
COLOR hell + weiss, blau
LOCATE 8, 2
PRINT "Division:"
COLOR gelb, blau
LOCATE 8, 18
PRINT zahl1 / zahl2

Wie man sieht, macht CLS den Bildschirm nicht immer schwarz, sondern füllt ihn in der aktuellen Hintergrundfarbe aus.

Das Programm ist schon recht unübersichtlich, was? Um ein Programm verständlicher zu machen, könnt ihr Kommentare einfügen. Das geht mit dem Befehl REM. Alles, was nach diesem Wort in derselben Zeile steht, wird ignoriert. Das dient vor allem zur Erläuterung einzelner Programmabschnitte oder zum Ausprobieren von verschiedenen Varianten (am Anfang der Programmzeile einfach REM schreiben - Folge: Befehle, die sich in der Zeile befinden, werden ignoriert).

Der Befehl REM kann durch ein Hochkomma abgekürzt werden. Um einen Kommentar am Ende einer Programmzeile zu schreiben, in der bereits ein Befehl vorkommt, muss man in Creative Basic, im Gegensatz zu anderen Basic-Dialekten, davor einen Doppelpunkt schreiben. Der Doppelpunkt dient übrigens generell dazu, mehrere Befehle in einer Programmzeile zu schreiben.

Ein kleines Beispiel (KURS0006.CBA):

Code :

'Variablendefinitionen
DIM blau AS INT
DIM gelb AS INT
'Variablenzuweisungen
blau = 1 : 'Farbe Blau
gelb = 14 : 'Farbe Gelb
'Hauptprogramm
COLOR gelb, blau : 'Farben wählen
CLS : 'Bildschirm löschen
PRINT "Hallo, Leute!" : 'Text ausgeben
REM PRINT "Mieses Wetter heute!" : 'Ausgeklammerter Befehl
PRINT "Schönes Wetter heute!" : 'Text ausgeben
PRINT "Bis morgen!" : 'Text ausgeben

Alles klar?

KAPITEL 4

Blöcke

Nun möchte ich einen Befehl besprechen, der etwas aus der Reihe fällt. Außerdem ist er unser erster Block-Befehl, was heißen soll, daß er eigentlich aus zwei Befehlen besteht.

Bei dem Befehl handelt es sich konkret - tatatata - um DO/UNTIL. Wir haben ihn schon früher einmal in einem Beispielprogramm kennengelernt.

Alles, was zwischen DO und UNTIL steht, wird zunächst einmal ausgeführt. Danach wird überprüft, ob die Bedingung, die nach UNTIL steht, erfüllt ist. Ist dies nicht der Fall, so wird der Code zwischen DO und UNTIL noch einmal ausgeführt – und so weiter.

Ein Beispiel:

Code :

DIM i AS INT
i = 0
DO
 PRINT "Ich bin so schön"
 i = i + 1
UNTIL i = 10

Dieses Programm gibt genau zehnmal Ich bin so schön aus.

Ich habe die Zeilen zwischen DO und UNTIL zugunsten der Übersicht eingerückt. Man sollte sich angewöhnen, bei Blöcken immer den eigentlichen Code zwischen Blockanfang und Blockende einzurücken, weil es sonst sehr schnell unübersichtlich wird.

Blöcke lassen sich ineinander verschachteln. Ein Beispiel:

Code :

DIM i AS INT
DIM zeit AS INT
i = 0
DO
 PRINT "Ich bin so schön"
 i = i + 1
 zeit = TIMER
 DO
 UNTIL TIMER > zeit + 0.5
UNTIL i = 10

TIMER gibt die Anzahl der Sekunden zurück, die seit Mitternacht vergangen sind. Durch unseren Code wird zwischen dem Anzeigen zweier nacheinander folgender Texte Ich bin so schön eine Pause von einer halben Sekunde Länge gemacht.

Das innerste UNTIL gehört zum innersten DO, das zweitinnerste UNTIL zum zweitinnersten DO usw. bis zum äußersten UNTIL, das zum äußersten DO gehört.

Theoretisch kann man Blöcke unendlich oft verschachteln! Hier haben wir allerdings nur zwei "Ebenen" verwendet.

Creative Basic kennt einen zweiten, ähnlichen Block: den WHILE-Block. Unser Programm sieht mit WHILE so aus:

Code :

DIM i AS INT
DIM zeit AS INT
i = 0
WHILE i < 10
 PRINT "Ich bin so schön"
 i = i + 1
 zeit = TIMER
 DO
 UNTIL TIMER > zeit + 0.5
ENDWHILE

Im Gegensatz zu DO steht hier die Bedingung am Kopf des Blocks. WHILE heißt „solange“. Solange i kleiner als 10 ist, wird der Code zwischen WHILE und ENDWHILE wiederholt ausgeführt. Man beachte: Würde man i vor dem Block nicht auf 0, sondern auf 10 oder auf einen noch größeren Wert setzen, so würde der Code im Block gar nicht erst ausgeführt werden, weil die Bedingung gleich zu Beginn verletzt wäre. (Ausprobieren!) Das ist anders als beim DO-Block: Beim DO-Block wird der Code im Block immer zumindest einmal ausgeführt, weil erst am Ende des Blocks die Bedingung überprüft wird.

Die DO- und WHILE-Blöcke werden übrigens auch Schleifen genannt.

Es gibt in Basic weiters eine Schleife, die extra für Zählaufgaben gedacht ist: die FOR/NEXT-Schleife. Hier gleich ein Beispielprogramm:

Code :

DIM i AS INT
DIM zeit AS INT
i = 0
FOR i = 1 TO 9 STEP 1
 PRINT "Ich bin so schön"
 zeit = TIMER
 DO
 UNTIL TIMER > zeit + 0.5
NEXT i
PRINT "i hat jetzt den Wert:" + STR$(i)

Na, das ist doch gleich kompakter!

In der vierten Zeile steht der Schleifenanfang (wie DO) und in der neunten das Schleifenende (wie UNTIL).

In der vierten Zeile wird angegeben, daß die Variable i als Schleifenzähler verwendet werden soll. Der Startwert soll 1 und der Endwert 9 sein. STEP gibt die Schrittweite an. Wenn STEP weggelassen wird, ist die Schrittweite automatisch 1.

Was bewirkt nun der Schleifenanfang? Beim ersten Durchlauf wird der Schleifenzähler auf den Startwert gesetzt. Danach werden alle Befehle zwischen FOR und NEXT ausgeführt. NEXT erhöht nun den Schleifenzähler um die Schrittweite. Wenn der Schleifenzähler gleich oder größer dem Endwert ist, dann wird die Schleife abgebrochen und der nächste Befehl ausgeführt. Ansonsten wird zu FOR zurückgesprungen und die Befehle zwischen FOR und NEXT erneut ausgeführt.

Ihr seht, das Ganze verhält sich so ähnlich wie DO/UNTIL. Auch Verschachtelung ist möglich. Sogar verschiedenartige Schleifenarten lassen sich verschachteln!

Das gilt auch für den IF/THEN/ELSE/ENDIF-Block, obwohl dieser keine Schleife, sondern eine Verzweigung ist. Wir werden diesen etwas umfangreicheren, aber sehr wichtigen Befehl jetzt besprechen.

Der IF/THEN/ELSE/ENDIF-Block dient dazu, Verzweigungen zu realisieren. Wenn eine bestimmte Bedingung erfüllt ist, wird der Programmteil bis zu ENDIF ausgeführt. Ansonsten wird zu dem Befehl hinter ENDIF gesprungen.

Die Bedingung ist meist ein Vergleich zweier Variablen oder einer Variablen und eines Werts. Ein Beispielprogramm demonstriert die möglichen Varianten.

Code :

'Vergleiche
DIM Zahl AS INT
COLOR 14, 1
CLS
PRINT "Gib eine Zahl ein!"
INPUT Zahl
PRINT "Diese Zahl erfüllt folgende Bedingungen:"
IF Zahl < 100
 PRINT "Sie ist kleiner als 100."
ENDIF
IF Zahl <= 100
 PRINT "Sie ist kleiner oder gleich 100."
ENDIF
IF Zahl = 100
 PRINT "Sie ist gleich 100."
ENDIF
IF Zahl >= 100
 PRINT "Sie ist größer oder gleich 100."
ENDIF
IF Zahl > 100
 PRINT "Sie ist größer als 100."
ENDIF

Jetzt müssten die meisten Vergleichoperatoren klar sein. Größer-oder-Gleich und Kleiner-oder-Gleich werden zwar nur bei Fließkommaoperationen benötigt (und auch da nicht so oft), doch der Vollständigkeit halber listete ich sie auch auf.

Das Programm ließe sich auch so schreiben:

Code :

'Vergleiche
DIM Zahl AS INT
COLOR 14, 1
CLS
PRINT "Gib eine Zahl ein!"
INPUT Zahl
PRINT "Diese Zahl erfüllt folgende Bedingungen:"
IF Zahl < 100 THEN PRINT "Sie ist kleiner als 100."
IF Zahl <= 100 THEN PRINT "Sie ist kleiner oder gleich 100."
IF Zahl = 100 THEN PRINT "Sie ist gleich 100."
IF Zahl >= 100 THEN PRINT "Sie ist größer oder gleich 100."
IF Zahl > 100 THEN PRINT "Sie ist größer als 100."

Diese Variante von IF ist ein bisschen kompakter, weil sie ohne ENDIF auskommt. Dafür muss man aber alles in eine Zeile schreiben.

Dann gibt es da noch die netten, kleinen Operatoren & und |. Mit ihrer Hilfe lassen sich mehrere Bedingungen miteinander verketten.

Wenn zwei Bedingungen mit & verknüpft werden, wird der Code zwischen der Bedingung und ENDIF nur dann abgearbeitet, wenn beide Bedingungen erfüllt sind. Richtig, das lässt sich auch durch zwei verschachtelte IF/THEN/ELSE/ENDIF-Blöcke realisieren!

Bei | wird der Code schon dann abgearbeitet, wenn mindestens eine Bedingung erfüllt ist.

(| gibt man ein, indem man AltGr und gleichzeitig < drückt.)

Um das Ganze zu demonstrieren, wieder ein Beispielprogramm:

Code :

'Vergleiche mit & und |
DIM Zahl1 AS INT
DIM Zahl2 AS INT
COLOR 14, 1
CLS
PRINT "Gib die erste Zahl ein!"
INPUT Zahl1
PRINT "Gib die zweite Zahl ein!"
INPUT Zahl2
PRINT "Es werden folgende Bedingungen erfüllt:"
IF Zahl1 = 100 | Zahl2 = 100
 PRINT "Mindestens eine der beiden Zahlen ist 100."
ENDIF
IF Zahl1 = 100 & Zahl2 = 100
 PRINT "Beide Zahlen sind 100."
ENDIF
IF Zahl1 <> 100 & Zahl2 <> 100
 PRINT "Keine der beiden Zahlen ist 100."
ENDIF

Ach ja, 'Ungleich' wird in Creative Basic wie '<>' geschrieben. Das hatte ich vergessen, euch zu sagen.

Wozu ist nun der ELSE-Zweig gut? Normalerweise wird, wenn die Bedingung nicht erfüllt ist, die Programmausführung direkt beim nächsten Befehl hinter ENDIF fortgesetzt. Kommt nun ein ELSE-Zweig vor, wird bei einer nicht erfüllten Bedingung zuerst der Code zwischen ELSE und ENDIF ausgeführt! (Bei einer erfüllten Bedingung wird dann nur der Code zwischen der Bedingung und ELSE ausgeführt.)

Das ganze läßt sich mit Worten ziemlich schwer erklären, doch in Wirklichkeit ist es überhaupt nicht kompliziert. Am besten, wir nehmen wieder ein Beispielprogramm zur Hand (schon KURS0014.CBA!).

Code :

'Vergleiche mit ELSE
DIM Zahl1 AS INT
DIM Zahl2 AS INT
COLOR 14, 1
CLS
PRINT "Gib eine Zahl ein!"
INPUT Zahl1
PRINT "Gib eine zweite Zahl ein!"
INPUT Zahl2
PRINT
IF Zahl1 = Zahl2
 PRINT "Die beiden Zahlen sind identisch."
ELSE
 PRINT "Die beiden Zahlen sind NICHT identisch."
ENDIF

Zum Spaß habe ich dieses Programm optimiert. Die optimierte Version ist zwar zum Verständnis dieses Kurses nicht notwendig, könnte aber sehr interessant sein.

Code :

'Vergleiche mit ELSE
DIM Zahl1 AS INT
DIM Zahl2 AS INT
Dim Ausgabe AS STRING
COLOR 14, 1
CLS
PRINT "Gib eine Zahl ein!"
INPUT Zahl1
PRINT "Gib eine zweite Zahl ein!"
INPUT Zahl2
PRINT
Ausgabe = "Die beiden Zahlen sind "
IF Zahl1 <> Zahl2 THEN Ausgabe = Ausgabe + "NICHT "
PRINT Ausgabe + "identisch."

Das wäre jetzt der IF/THEN/ELSE/ENDIF-Block.

Wie gesagt, läßt er sich wie alle Blöcke verschachteln. Diese Verschachtelung ist auch extrem wichtig für die strukturierte Programmierung von Adventures. Am Ende dieser Folge folgt ein Beispiel, jetzt aber noch schnell der SELECT/CASE-Block.

Wenn man schnell eine Variable auf mehrere Werte prüfen will, ist dieser Block wesentlich besser geeignet als ein IF/THEN/ELSE/ENDIF-Block. Wo sonst 'IF ... ' steht, muß man 'SELECT Variable' schreiben. 'Variable' steht hier für den Namen der Variablen, auf die sich die nachfolgenden Vergleiche beziehen.

Ein Vergleich wird immer mit CASE eingeleitet. Daneben steht der Wert, mit dem die am Blockanfang angegebene Variable verglichen werden soll.

Ist nun die Variable gleich einem der neben CASE angegebenen Werte, so wird der Code hinter CASE ausgeführt, bis zum nächsten CASE. Ansonsten wird gleich zum nächsten CASE gesprungen. Abgeschlossen wird der SELECT/CASE-Block mit ENDSELECT.

Am besten gleich ein Beispiel, wie das Ganze funktioniert. Es demonstriert gut, wie man die Eingabe bei Adventures mit dem SELECT/CASE-Block leicht realisieren kann.

Code :

'Einfaches Adventure-Spiel mit SELECT/CASE
DIM Eingabe AS STRING
COLOR 14, 1
CLS
PRINT "Willkommen zum Mysterious Creative Basic Adventure. Du mußt immer die Zahl"
PRINT "eingeben, die neben der gewählten Option steht. 'aT' steht für eine"
PRINT "beliebige andere Taste."
PRINT
PRINT "Du stehst vor einem Schloß. Wagst Du Dich, es zu betreten?"
PRINT
PRINT " ( 1) Ja"
PRINT " (aT) Nö"
PRINT
INPUT Eingabe
CLS
SELECT Eingabe
CASE "1"
 PRINT "Jetzt bist Du im Schloß. Du hast die Wahl, ob Du nach Westen oder"
 PRINT "nach Osten gehst. Natürlich kannst Du auch das Schloß verlassen"
 PRINT "(Feigling!) Wofür entscheidest Du Dich, oh edler Ritter?"
 PRINT
 PRINT " ( 1) Westen"
 PRINT " ( 2) Osten"
 PRINT " (aT) Schloß verlassen"
 PRINT
 INPUT Eingabe
 CLS
 SELECT Eingabe
 CASE "1"
  PRINT "Da ist ein böser Drache, den Du, edler Ritter, mit Deinem Schwert"
  PRINT "zu Hackfleisch verarbeitest! Du hast die holde Prinzessin"
  PRINT "gerettet und darfst sie jetzt zur Belohnung zur Frau nehmen (und"
  PRINT "mit ihr 'ne Menge Spaß haben)! Ende."
  END
 CASE "2"
  PRINT "Oh, Du armer Held. Kaum gehst Du nach Osten, fällst Du in einen"
  PRINT "bodenlosen Abgrund! Und wenn er nicht gestorben ist, dann fällt"
  PRINT "er noch heute. Ende."
  END
 DEFAULT
  PRINT "Kaum hast Du das Schloß verlassen, fällt das Tor hinter Dir zu."
  PRINT "Du hast Deine Chance vertan, denn 'rein kannst Du nimmer! Ende."
  END
 ENDSELECT
DEFAULT
 PRINT "Na gut, dann nicht. Starte lieber Excel und erledige langweilige"
 PRINT "Tabellenkalkulationen! Ende."
ENDSELECT

Hier wird auch die Verschachtelung demonstriert. DEFAULT entspricht übrigens dem ELSE des IF/THEN/ELSE/ENDIF-Blocks, und END beendet das Programm an einer beliebigen Stelle. Hier nun das Ganze mit dem IF/THEN/ELSE/ENDIF-Block.

Code :

'Einfaches Adventure-Spiel mit IF/THEN/ELSE/ENDIF
DIM Eingabe AS STRING
COLOR 14, 1
CLS
PRINT "Willkommen zum Mysterious Creative Basic Adventure. Du mußt immer die Zahl"
PRINT "eingeben, die neben der gewählten Option steht. 'aT' steht für eine"
PRINT "beliebige andere Taste."
PRINT
PRINT "Du stehst vor einem Schloß. Wagst Du Dich, es zu betreten?"
PRINT
PRINT " ( 1) Ja"
PRINT " (aT) Nö"
PRINT
INPUT Eingabe
CLS
IF Eingabe = "1"
 PRINT "Jetzt bist Du im Schloß. Du hast die Wahl, ob Du nach Westen oder"
 PRINT "nach Osten gehst. Natürlich kannst Du auch das Schloß verlassen"
 PRINT "(Feigling!) Wofür entscheidest Du Dich, oh edler Ritter?"
 PRINT
 PRINT " ( 1) Westen"
 PRINT " ( 2) Osten"
 PRINT " (aT) Schloß verlassen"
 PRINT
 INPUT Eingabe
 CLS
 IF Eingabe = "1"
  PRINT "Da ist ein böser Drache, den Du, edler Ritter, mit Deinem Schwert"
  PRINT "zu Hackfleisch verarbeitest! Du hast die holde Prinzessin"
  PRINT "gerettet und darfst sie jetzt zur Belohnung zur Frau nehmen (und"
  PRINT "mit ihr 'ne Menge Spaß haben)! Ende."
  END
 ENDIF
 IF Eingabe = "2"
  PRINT "Oh, Du armer Held. Kaum gehst Du nach Osten, fällst Du in einen"
  PRINT "bodenlosen Abgrund! Und wenn er nicht gestorben ist, dann fällt er"
  PRINT "noch heute. Ende."
  END
 ELSE
  PRINT "Kaum hast Du das Schloß verlassen, fällt das Tor hinter Dir zu. Du"
  PRINT "hast Deine Chance vertan, denn 'rein kannst Du nimmer! Ende."
  END
 ENDIF
ELSE
 PRINT "Na gut, dann nicht. Starte lieber Excel und erledige langweilige"
 PRINT "Tabellenkalkulationen! Ende."
ENDIF

Wie man sieht, ist das Listing zwar etwas (eine Zeile) kürzer, aber komplizierter! Letztendlich bleibt aber dem Programmierer überlassen, ob er SELECT/CASE oder IF/THEN/ELSE/ENDIF verwendet. Ich persönlich bevorzuge SELECT/CASE.

KAPITEL 5

Programmierung von Abenteuerspielen

Wenn ihr alle brav mitgelernt habt, erfüllt ihr jetzt schon alle Voraussetzungen, um kreativ zu sein! Wir werden zusätzlich einige neue Techniken kennenlernen, die auch in anderen Programmieraufgaben nützlich sein können.

Wenn man ein Adventure erstellen will, sollte man sich zunächst vor der Codierung einen groben Überblick über die Story verschaffen. Normalerweise ist ein Adventure eine fortlaufende Geschichte, bei der man an einigen Stellen in die Handlung eingreifen kann. Bei professionellen Adventures sind aber die Eingriffsmöglichkeiten so groß, dass das Ganze zu einem Spiel wird.

Programme mit weniger Eingriffsmöglichkeiten nennen sich interaktive Filme. Die meisten von ihnen sind so primitiv, dass man nur ab und zu eine Richtungstaste drücken und hoffen darf, dass sie die richtige war!

Unser erstes Spiel soll etwas mehr Eingriffsmöglichkeiten als interaktive Filme, aber weniger als professionelle Adventures bieten.

Oft werden in Adventures Gegenstände benutzt. Diese können wir in Variablen speichern. Wenn die jeweilige Variable 1 ist, dann besitzt die Person den Gegenstand, wenn sie 0 ist, dann nicht. Man könnte auch noch andere Werte einsetzen, z.B. 2: Der Gegenstand ist bereits benutzt worden, befindet sich aber immer noch im Besitz des Spielers. Der Phantasie des Programmieres sind keine Grenzen gesetzt (höchstens die des Arbeitsspeichers)!

Wie bereits im Beispiel aus der vorigen Folge gezeigt wurde, werden die Auswahlsmöglichkeiten mit PRINT angezeigt. Danach wird die Wahl eingegeben und mit SELECT/CASE ausgewertet.

Um die Eingabe wenigstens etwas komfortabler zu gestaltet, ordnen wir jeder bis auf die letzte Auswahlsmöglichkeit eine Zahl zu. Der Benutzer muß dann nur die Zahl, die der gewünschten Auswahlsmöglichkeit zugeordnet ist, eingeben. Für die letzte Auswahlsmöglichkeit kann dann jede beliebige andere Zahl oder Zeichenkette eingegeben werden.

Weiters müssen wir bei Adventures oft im Programm "springen". Wenn wir z.B. ein Haus betreten und es später wieder verlassen, muss zu der Stelle, wo wir vor dem Haus stehen, gesprungen werden.

Am einfachsten sind solche Sprünge mit dem berühmt-berüchtigten Befehl GOTO realisierbar. Dazu muss zuerst ein sogenanntes Label definiert werden, zu dem GOTO dann springen kann. Ein Label besteht aus einer Zeichenkette, diesmal aber ausnahmsweise nicht in Anführungszeichen eingeschlossen, und einem Doppelpunkt. Es muss in einer eigenen Zeile stehen.

Nach GOTO muß als Parameter der Name des Labels angegeben werden, denn es lassen sich natürlich auch mehrere Labels benutzen. Allerdings müssen die dann auch verschiedene Namen haben! (Ich weiß aus eigener Erfahrung, daß vieles, was für mich heute selbstverständlich ist, für den Anfänger unnötig kompliziert sein kann. Deshalb erkläre ich lieber alles genauer als notwendig, bevor ich einen Stapel von Fragen mit der Post geliefert bekomme.)

So, jetzt kennt ihr die Theorie. Nun wollen wir ein kleines Beispiel liefern.

Code :

'Die Reise zum Mond
'Stark gekürzte Version für The Real Adok's Way to Creative Basic
DIM a AS STRING
DIM eingab AS STRING
DIM e1 AS STRING
DIM MitNeleGeredet AS INT
DIM Joystick AS INT
COLOR 14, 1
CLS
'Vorspann
PRINT "Die Reise zum Mond - Das Gerhard-betriebene Raumschiff"
PRINT "Copyright (C) 1995-1996 by Adok Soft"
PRINT
PRINT "Stark gekürzte Version für The Real Adok's Way to Creative Basic"
INPUT a
CLS
PRINT "Clausi, Stefan, Philipp, Franzi, Gerhard, Marius, Zahra und Nele wollen"
PRINT "gemeinsam auf den Mond fliegen! Clausi, das Genie, baute kurzerhand ein"
PRINT "Raumschiff namens Astrein Shuttle und ernannte sich zum Kommandanten."
PRINT "Das Besondere am Astrein Shuttle ist sicherlich nicht seine Geschwin-"
PRINT "digkeit, die mit einigen Megametern pro Sekunde nicht sehr schnell ist,"
PRINT "sondern der Antrieb. Er funktioniert so: Gerhard hängt sich an das Raumschiff"
PRINT "an und lässt sich von Zahra füttern. Je mehr er (fr)isst, desto mehr - pardon -"
PRINT "Abgase lässt er. Und diese Abgase treiben das Raumschiff an!"
INPUT a
CLS
PRINT "Nochmals für alle: Die Besatzung besteht aus"
PRINT
PRINT "Clausi.......... Kommandant"
PRINT "Franzi.......... 1. Offizier"
PRINT "Philipp......... 2. Offizier"
PRINT "Stefan.......... 3. Offizier"
PRINT "Marius.......... Oberbiologe und Klowart"
PRINT "Nele............ Navigatorin"
PRINT "Gerhard......... Treibstofferzeuger"
PRINT "Zahra........... Krankenschwester"
INPUT a
CLS
PRINT "Du übernimmst die Rolle von Clausi, dem Kommandanten. Du und deine Besatzung"
PRINT "sind schon sehr lange (seit einer Minute!) im Weltraum mit dem Schiff unterwegs. "
PRINT "Deine Aufgabe ist es, dich und deine Besatzung sicher zum Mond zu bringen. "
PRINT "Einfach? Ja, so klingt es. Ist es aber nicht..."
INPUT a
'Das Spiel beginnt!
HaupthalleStart:
CLS
PRINT "Du bist nun in der Haupthalle des Astrein-Shuttles. Von hier aus kannst du"
PRINT "alle Räume des Raumschiffs erreichen und das Raumschiff sogar verlassen."
PRINT "Bevor du letzteres tust, rate ich dir, die notwendige"
PRINT "Ausrüstung zu holen..."
GOSUB Eingabe
CLS
SELECT eingab
CASE "1"
PRINT "Es ist niemand da, mit dem du sprechen könntest!"
CASE "2"
HheRetry1:
PRINT "Was willst du betrachten?"
PRINT " (1) Die Türen"
PRINT " (2) Den Raum"
PRINT " (3) Die Luft"
PRINT " (4) Das Schild"
INPUT e1
CLS
SELECT e1
CASE "1"
PRINT "Es sind fünf große Türen, die durch ein Laserfeld geschlossen sind. Berührt"
PRINT "man das Laserfeld, so wird es automatisch deaktiviert."
CASE "2"
PRINT "Ein großer, leerer Raum, der Haupthalle genannt wird. An den Wänden kleben"
PRINT "alte Butterbrote, und die fünf Türen werden durch ein Laserfeld geschlossen."
PRINT "Wenn man diesen Raum mit einem bestimmten Klassenraum des Goethe-Gymnasiums"
PRINT "vergleicht, so ist eine gewisse Ähnlichkeit erkennbar."
CASE "3"
PRINT "Das Sehorgan behauptet, sie wäre ein transparentes Nichts. Das Geruchs- und"
PRINT "das Atmungsorgan wissen es allerdings besser."
CASE "4"
PRINT "Auf ihm steht 'EXIT'. Offensichtlich führt es zum Ausgang dieses Raumschiffs."
PRINT "Das solltest du, der Erbauer dieses Raumschiffs, eigentlich am besten wissen!"
DEFAULT
GOTO HheRetry1
ENDSELECT
CASE "3"
HheRetry2:
PRINT "Was willst du nehmen?"
PRINT " (1) Laserfeld"
PRINT " (2) Butterbrot"
INPUT e1
CLS
SELECT e1
CASE "1"
PRINT "Bist du lebensmüde oder was!? Wenn du so weitermachst, wirst du das Spiel nie"
PRINT "schaffen!"
CASE "2"
PRINT "Igitt! Dieses grausame, an der Wand klebende, mit Butter verzierte Brot ist"
PRINT "ekelerregend! Laß es lieber kleben!"
DEFAULT
GOTO HheRetry2
ENDSELECT
CASE "4"
HheRetry3:
PRINT "Wohin willst du gehen?"
PRINT " (1) Tür 1"
PRINT " (2) Tür 2"
PRINT " (3) Tür 3"
PRINT " (4) Tür 4"
PRINT " (5) Tür 5"
INPUT e1
CLS
SELECT e1
CASE "1"
PRINT "Diesen Raum kannst du nur in der ungekürzten Fassung betreten!"
CASE "2"
PRINT "Diesen Raum kannst du nur in der ungekürzten Fassung betreten!"
CASE "3"
GOTO KommandoraumStart
CASE "4"
PRINT "Diesen Raum kannst du nur in der ungekürzten Fassung betreten!"
CASE "5"
GOTO OffizierszimmerStart
DEFAULT
GOTO HheRetry3
ENDSELECT
DEFAULT
GOTO HaupthalleStart
ENDSELECT
INPUT a
GOTO HaupthalleStart
KommandoraumStart:
CLS
PRINT "Dies ist der Kommandoraum des Astrein Shuttles. Vor dir ist ein riesiges "
PRINT "Steuerpult, neben dem Nele sitzt, die vergeblich versucht, es zu bedienen. "
PRINT "Dahinter befindet sich in diesem Raum ein riesiges Fenster."
GOSUB Eingabe
CLS
SELECT eingab
CASE "1"
KreRetry1:
PRINT "Mit wem willst du sprechen?"
PRINT " (1) Nele"
PRINT " (2) Autopilot"
INPUT e1
CLS
SELECT e1
CASE "1"
SELECT MitNeleGeredet
CASE 1
PRINT "Nele: 'Konntest du den Autopiloten aktivieren?'"
PRINT "Clausi: 'Ich bin gerade dabei!'"
CASE 0
PRINT "Clausi: 'Gibt es Probleme?"
PRINT "Nele: 'Ja, gewaltige! Wir sind vom Kurs abgekommen, und ich kann den"
PRINT " Autopiloten nicht mehr aktivieren!'"
PRINT "Clausi: 'Dann siehe doch in der Bedienungsanleitung nach!'"
PRINT "Nele: 'Ich habe sie verloren.'"
PRINT "Clausi: 'Wunderbar! Letzten Endes muß ich doch immer alles machen. Lass es"
PRINT " mich probieren!'"
MitNeleGeredet = 1
ENDSELECT
CASE "2"
PRINT "Clausi: 'Bitte, Herr Autopilot, fliegen Sie uns zum Mond!'"
PRINT
PRINT "............................"
PRINT
PRINT "Keine Antwort. Tja, so leicht geht es nicht!"
DEFAULT
GOTO KreRetry1
ENDSELECT
CASE "2"
KreRetry2:
PRINT "Was willst du betrachten?"
PRINT " (1) Nele"
PRINT " (2) Steuerpult"
PRINT " (3) Fenster"
PRINT " (4) Teppich"
INPUT e1
CLS
SELECT e1
CASE "1"
PRINT "Nele, die Navigatorin des Astrein-Shuttles, sitzt gemütlich auf ihrem Sessel, "
PRINT "hört sich mit ihrem Discman eine neue CD an und versucht herauszufinden, wie"
PRINT "man den Autopiloten des Astrein-Shuttles aktiviert."
CASE "2"
IF MitNeleGeredet = 1 & Joystick = 5
PRINT "Du gibst den Code, den dir Franzi gesagt hat, ein."
PRINT "Plötzlich ruft Nele: 'Hurra! Du hast es geschafft! Du hast den Autopiloten "
PRINT "aktiviert!'"
INPUT a
CLS
PRINT "Das war die gekürzte Version von 'Die Reise zum Mond' für"
PRINT "The Real Adok's Way to Creative Basic. See you in the Full Version!"
END
ELSE
PRINT "Das Steuerpult des Astrein-Shuttles besteht aus unzähligen Knöpfen, Hebeln,"
PRINT "Schaltern, Joysticks und Joypads. Sogar ein Computer mit vielen Spielen"
PRINT "ist eingebaut! Wozu, glaubt ihr, sollte man die Joysticks und Joypads sonst"
PRINT "brauchen, außer zur Unterhaltung der Besatzungsmitglieder?"
ENDIF
CASE "3"
PRINT "Ein riesiges Fenster, das den Blick zu dem, was sich außerhalb des Shuttles"
PRINT "befindet, gewährt! He, Moment mal! Da draußen sind auch Zahra und Gerhard!"
CASE "4"
PRINT "DEN TEPPICH ANSCHAUEN? Wie geht das, wenn hier gar kein Teppich ist?"
DEFAULT
GOTO KreRetry2
ENDSELECT
CASE "3"
KreRetry3:
PRINT "Was willst du nehmen?"
PRINT " (1) Teppich"
PRINT " (2) Steuerpult"
PRINT " (3) Joystick"
INPUT e1
CLS
SELECT e1
CASE "1"
PRINT "DEN TEPPICH NEHMEN? Wie geht das, wenn hier gar kein Teppich ist?"
CASE "2"
PRINT "Ein bisschen zu schwer, was? Ja, ein bisschen viel zu schwer!"
CASE "3"
IF Joystick < 2
PRINT "Du reißt einen der vielen Joysticks aus dem Steuerpult heraus und steckst ihn"
PRINT "in die Tasche. Vielleicht kannst du ihn einmal brauchen?"
Joystick = 2
ELSE
PRINT "Du hast schon einen!"
ENDIF
DEFAULT
GOTO KreRetry3
ENDSELECT
CASE "4"
KreRetry4:
PRINT "Wohin willst du gehen?"
PRINT " (1) Tür"
INPUT e1
CLS
IF e1 <> "1"
GOTO KreRetry4
ENDIF
GOTO HaupthalleStart
DEFAULT
GOTO KommandoraumStart
ENDSELECT
INPUT a
GOTO KommandoraumStart
OffizierszimmerStart:
CLS
PRINT "Du befindest dich im Offizierskasino. Hier befinden sich die drei Offiziere"
PRINT "Franzi, Philipp und Stefan. Sie spielen gerade ein Schachspiel auf ihrem"
PRINT "Computer. (Können sie überhaupt Schach spielen!?)"
GOSUB Eingabe
CLS
SELECT eingab
CASE "1"
OzeRetry1:
PRINT "Mit wem willst du sprechen?"
PRINT " (1) Stefan"
PRINT " (2) Franzi"
PRINT " (3) Philipp"
INPUT e1
CLS
SELECT e1
CASE "1"
PRINT "Stefan: 'Hmmm, soll ich meinen König opfern, um die Dame zu retten?'"
CASE "2"
IF Joystick = 0
PRINT "Franzi: 'Stefan, Philipp, seid nicht so gemein! Laßt mich auch mitspielen!'"
PRINT "Philipp: 'Dann bräuchten wir aber noch einen dritten Joystick, und den haben"
PRINT " wir nicht!'"
ENDIF
IF Joystick = 5
PRINT "Franzi: 'Bitte, gib mir die Tüte!'"
PRINT "Clausi: 'Die Tüte gebe ich dir nicht!'"
PRINT "Franzi: 'Wie ich schon sagte: Der Code heißt oben, rechts, unten, links, oben"
PRINT " oder umgekehrt!'"
ENDIF
IF Joystick > 2 & Joystick < 5 & MitNeleGeredet <> 1
PRINT "Franzi: 'Vielen Dank für den Joystick, Clausi!'"
PRINT "Clausi: 'Gern geschehen!'"
ENDIF
IF Joystick = 4 & MitNeleGeredet = 1
PRINT "Clausi: 'Hey, Fratzi, wie wäre es mit dieser original philippinischen "
PRINT " Plastiktüte? Sie ist von Philipps Bett hinuntergefallen!'"
PRINT "Franzi: 'Wirklich? Ein Gegenstand ist immer für ein Gerücht gut! Gib her!'"
PRINT "Clausi: 'Zuerst sagst du mir den Code!'"
PRINT "Franzi: 'Na gut. Oben, rechts, unten, links, oben ... oder umgekehrt?'"
PRINT "Clausi: 'Du bist ja eine schöne Hilfe! Dafür bekommst du die Tüte nicht!'"
Joystick = 5
ENDIF
IF Joystick > 2 & Joystick < 5 & MitNeleGeredet = 1
PRINT "Clausi: 'Hey, Fratzi, weißt du, wie man den Autopiloten aktiviert?'"
PRINT "Franzi: 'Nein! Aber ich habe die Bedienungsanleitung!'"
PRINT "Clausi: 'Gib sie her!'"
PRINT "Franzi: 'Hm... eigentlich sollte ich sie dir geben, denn du bist erstens mein"
PRINT " Kommandant und zweitens hattest du mir den Joystick vorhin gegeben."
PRINT " Trotzdem: Ich gebe dir die Anleitung nur, wenn du mir noch ein"
PRINT " Geschenk machst! Mache mich zum Kommandanten!'"
PRINT "Clausi: 'Das mache ich nicht!'"
PRINT "Franzi: 'Dann mache etwas anderes!'"
Joystick = 4
ENDIF
IF Joystick = 2
PRINT "Franzi: 'Komm, Philipp, lass mich endlich mitspielen!'"
PRINT "Philipp: 'Wie oft soll ich es dir noch sagen: Dazu brauchen wir einen dritten"
PRINT " Joystick!'"
PRINT "Clausi: 'Wie diesen hier, den ich in meiner Hand halte?'"
PRINT "Philipp: 'Ja, genau einen wie den! Gib ihn her!'"
PRINT "Clausi: 'Hier.'"
PRINT "Franzi: 'Danke, Clausi! Du bist mein bester Freund!'"
Joystick = 3
ENDIF
CASE "3"
PRINT "Philipp: 'Schach ist ein wahrhaft lustiges Spiel! Wenn ich es bloß spielen"
PRINT " könnte...'"
DEFAULT
GOTO OzeRetry1
ENDSELECT
CASE "2"
OzeRetry2:
PRINT "Was willst du betrachten?"
PRINT " (1) Schachcomputer"
PRINT " (2) Franzi"
PRINT " (3) Philipp"
PRINT " (4) Stefan"
INPUT e1
CLS
SELECT e1
CASE "1"
PRINT "Ein riesengroßer Computer, mit dem man nur Schach spielen kann, dafür aber"
PRINT "zu dritt!"
CASE "2"
PRINT "Dieser Junge nennt sich Franzi und ist erster Offizier. Seine Spitznamen sind"
PRINT "Fratzi, Intrigator und FBI. Letzteres bedeutet 'Flotter blonder Insulaner'."
PRINT "Naja, Marius, der diesen Spitznamen erfunden hatte, meinte mit dem 'I' etwas"
PRINT "anderes, aber wir wollen ja nicht frech sein."
CASE "3"
PRINT "Dieser Junge nennt sich Philipp und ist zweiter Offizier. Er haut auf die"
PRINT "Drums wie die anderen auf ihre lieben Mitschüler."
CASE "4"
PRINT "Dieser Junge nennt sich Stefan und ist dritter Offizier. Wie man es auch an"
PRINT "einer zweiten Stelle in diesem Spiel erfahren kann, nennt sich dieses Genie"
PRINT "auch Stex Mel. Eine seiner berühmtesten, vielzitierten Aussagen: 'Philosophie"
PRINT "ist nichts anderes als eine Mischung aus Poesie und Dichtung.'"
DEFAULT
GOTO OzeRetry2
ENDSELECT
CASE "3"
OzeRetry3:
PRINT "Was willst du nehmen?"
PRINT " (1) Schachcomputer"
PRINT " (2) Philipp's Joystick"
PRINT " (3) Franzi"
INPUT e1
CLS
SELECT e1
CASE "1"
PRINT "Du hast doch zu Hause selber einen 'rumstehen!"
CASE "2"
PRINT "Den gibt er nicht her!"
CASE "3"
PRINT "Clausi: 'Fratzi, lass mich dich in meine Arme nehmen!'"
PRINT "Franzi: 'Du willst mich wohl AUF den Arm nehmen!?'"
DEFAULT
GOTO OzeRetry3
ENDSELECT
CASE "4"
PRINT "Wohin willst du gehen?"
PRINT " (1) Tür"
OzeRetry4:
INPUT e1
IF e1 <> "1"
GOTO OzeRetry4
ENDIF
GOTO HaupthalleStart
DEFAULT
GOTO OffizierszimmerStart
ENDSELECT
INPUT a
GOTO OffizierszimmerStart
Eingabe:
PRINT " (1) Sprich"
PRINT " (2) Betrachte"
PRINT " (3) Nimm"
PRINT " (4) Gehe zu"
PRINT " (5) Ende"
INPUT eingab
IF eingab = "5"
END
ENDIF
RETURN

"Das soll ein kleines Beispiel sein?" wird sich so mancher jetzt fragen. Ja, mit seinen 405 Zeilen, die gut 13 KB Speicherplatz belegen, ist dieses Beispielprogramm schon sehr groß. Aber für ein voll funktionsfähiges Adventure mit allem Drum und Dran bis auf Grafik, Maussteuerung und Sound ist es geradezu winzig!

Zu dem Beispielprogramm noch einige Erläuterungen:

•Joystick und MitNeleGeredet sind Variablen, in denen gespeichert wird, wie weit man im Spiel fortgeschritten ist, was man schon alles gemacht hat usw.

•Der Befehl GOSUB entspricht von der Verwendung her im großen und ganzen GOTO, nur wird, wenn Basic auf RETURN stößt, zu der Zeile, in der GOSUB steht, zurückgesprungen.

KAPITEL 6

Grafikprogrammierung

Uff, das wird umfangreich sein! Fangen wir also am besten gleich an.

Wenn wir die Grafikfunktionen nützen wollen, müssen wir zunächst ein Fenster erzeugen. Das geschieht mit dem Befehl WINDOW, der ein bisschen umfangreicher ist und an Hand eines Beispielprogramms erklärt wird:

Code :

DIM Fenster1 AS WINDOW
WINDOW Fenster1, 0, 0, 640, 480, @MINBOX + @MAXBOX + @SIZE, 0, "Mein Fenster", Fenster1Prozedur
WAITUNTIL Fenster1 = 0
END
 
SUB Fenster1Prozedur
 IF @CLASS = @IDCLOSEWINDOW
  CLOSEWINDOW Fenster1
 ENDIF
RETURN

Wir brauchen eine Fenstervariable, eine Variable vom Typ WINDOW (ja, der Typ heißt genauso wie der Befehl). Diese definieren wir in der ersten Zeile.

Dann erzeugen wir das Fenster mit dem Befehl WINDOW. Dieser Befehl frisst viele Parameter. Womit müssen wir ihn füttern? Zunächst mit der Fenstervariablen, dann mit den Koordinaten des Bildpunktes ganz links oben, wo das Fenster angezeigt werden soll. Es wird immer von 0 ausgehend gezählt, der Bildpunkt (0, 0) ist also der ganz links oben im Bildschirm gelegene Punkt. Experimentiert ruhig, indem ihr andere Werte einsetzt und die Auswirkungen beobachtet. Als nächstes kommen die Breite und die Höhe des Fensters, hier habe ich 640 und 480 Bildpunkte gewählt. Der nächste Parameter ist eine Sammlung von Eigenschaften, die dieses Fenster besitzt. In diesem Fall habe ich @MINBOX + @MAXBOX + @SIZE geschrieben. Damit bekommt das Fenster oben rechts ein Feld, das man anklicken kann, um es zu minimieren (ganz klein zu machen) sowie eines, um es zu maximieren (ganz groß zu machen). Außerdem kann man es durch Anklicken des Randes und Ziehen vergrößern oder verkleinern. Diese drei Eigenschaften werden durch + miteinander verknüpft. Man könnte statt dessen auch | verwenden. Wenn man keine dieser Eigenschaften haben will, schreibt man statt allem 0. Nächster Parameter ist ein Verweis auf ein Fenster, das ein „Elternfenster“ unseres Fensters darstellt. Ein „Kindfenster“ kann sich nur innerhalb seines Elternfensters bewegen. Wir haben kein Elternfenster, also schreiben wir 0. Dann kommt der Titel des Fensters, der links oben angezeigt wird – wir nehmen schlicht Mein Fenster. Der letzte Parameter ist die Prozedur, die die Steuerung des Fensters übernimmt.

Was sind Prozeduren? Prozeduren sind Unterprogramme, Programmteile, die zwischen den Befehlen SUB und RETURN eingeschlossen sind.

Normalerweise ruft man Prozeduren aus dem Programm auf. Hier wird die Prozedur jedoch nicht direkt vom Programm aufgerufen, sondern sie wird automatisch durch den WINDOW-Befehl aufgerufen. Der Sinn dieser Prozedur ist festzustellen, ob bestimmte Ereignisse eingetreten sind, und, wenn ja, darauf zu reagieren. In unserem Programm wird nur darauf reagiert, ob der Benutzer etwas getan hat, das ein Schließen des Fensters verursacht. Wenn @CLASS = @IDCLOSEWINDOW, dann soll das Fenster geschlossen werden – CLOSEWINDOW Fenster1.

Im Hauptprogramm steht nach dem WINDOW-Befehl die Zeile WAITUNTIL Fenster1 = 0. Das Programm wartet, bis die Fenstervariable den Wert 0 annimmt. Diesen Wert nimmt sie an, wenn das Fenster geschlossen wurde. Das Programm unterbricht also quasi seine Ausführung und wartet darauf, dass die Prozedur Fenster1Prozedur die Variable Fenster1 indirekt auf 0 setzt.

Der Befehl END beendet das Programm. Er muss vor SUB geschrieben werden, weil es sonst zu einem Fehler käme.

Fangen wir etwas mit unserem Fenster an. Zeichnen wir Linien!

Code :

'LINE-Demo
DIM Fenster1 AS WINDOW
WINDOW Fenster1, 0, 0, 640, 480, @MINBOX + @MAXBOX + @SIZE, 0, "Mein Fenster", Fenster1Prozedur
LINE Fenster1, 100, 100, 320, 200, RGB(255,0,0)
LINE Fenster1, 80, 400, 420, 400, RGB(0,0,255)
WAITUNTIL Fenster1 = 0
END
 
SUB Fenster1Prozedur
 IF @CLASS = @IDCLOSEWINDOW
  CLOSEWINDOW Fenster1
 ENDIF
RETURN

Der Befehl LINE dient dazu, Linien zu zeichnen. Der erste Parameter ist die Fenstervariable, denn LINE muss ja wissen, wohin es seine Linie zeichnen soll. Danach kommen die Koordinaten des Punktes, wo die Linie beginnen soll. Zuerst kommt die x-Koordinate, dann die y-Koordinate. Als nächstes dann die Koordinaten des Endpunktes, wieder zuerst x, dann y. Schließlich die Farbe des Bildpunktes. Wir arbeiten mit dem RGB-Farbmodell. RGB steht für „rot, grün, blau“. Jeder dieser Farbanteile hat einen Wert zwischen 0 und 255. RGB(255,0,0) ist ein sattes Rot, RGB(0,0,255) ein sattes Blau. Probiert, Farben zu mischen.

Man kann auch die Farbe weglassen. Dann wird die Linie schwarz gezeichnet.

Wer nicht ganze Linien zeichnen, sondern nur einzelne Punkte setzen will, dem sei der Befehl PSET ans Herz gelegt. Syntax: PSET Fenstervariable, x, y, Farbe.

Wenn ihr hingegen nicht nur Linien, sondern ganze Rechtecke zeichnen wollt, dann ist der Befehl RECT der Befehl eurer Wahl. Ein Beispielprogramm demonstriert ihn:

Code :

'RECT-Demo
DIM Fenster1 AS WINDOW
WINDOW Fenster1, 0, 0, 640, 480, @MINBOX + @MAXBOX + @SIZE, 0, "Mein Fenster", Fenster1Prozedur
RECT Fenster1, 10, 200, 300, 200, RGB(0,0,255), RGB(255,255,0)
WAITUNTIL Fenster1 = 0
END
 
SUB Fenster1Prozedur
 IF @CLASS = @IDCLOSEWINDOW
  CLOSEWINDOW Fenster1
 ENDIF
RETURN

Die Parameter sind die Fenstervariable, die x- und die y-Koordinate des linken oberen Bildpunkts, die Breite und die Höhe sowie die Farbe des Randes und die Füllfarbe. Man kann die letzten beiden Parameter auch weglassen. Lässt man nur den letzten Parameter weg, so wird das Rechteck nicht ausgefüllt. Lässt man auch den vorletzten Parameter weg, so ist seine Randfarbe schwarz.

Der nächste Befehl ist CIRCLE. Mit ihm lassen sich Kreise zeichnen. Als Parameter müssen der Mittelpunkt, der Radius und die Farbe angegeben werden. Wie immer, hier ein Beispiel.

Code :

'CIRCLE-Demo
DIM MPunktX AS INT
DIM MPunktY AS INT
DIM Radius AS INT
DIM Fenster1 AS WINDOW
MPunktX = 320
MPunktY = 200
Radius = 100
WINDOW Fenster1, 0, 0, 640, 480, @MINBOX + @MAXBOX + @SIZE, 0, "Mein Fenster", Fenster1Prozedur
CIRCLE Fenster1, MPunktX, MPunktY, Radius, RGB(0,0,255), RGB(255,255,0)
LINE Fenster1, MPunktX - Radius, MPunktY, MPunktX + Radius, MPunktY
LINE Fenster1, MPunktX, MPunktY - Radius, MPunktX, MPunktY + Radius
WAITUNTIL Fenster1 = 0
END
 
SUB Fenster1Prozedur
 IF @CLASS = @IDCLOSEWINDOW
  CLOSEWINDOW Fenster1
 ENDIF
RETURN

Wie bei RECT können Rand- und Füllfarbe auch weggelassen werden.

KAPITEL 7

Datentypen in Creative Basic

Wenn man die Datentypen mit der Mathematik vergleicht, so entsprechen sie am ehesten den Zahlenmengen. Das heißt, dass die Datentypen sozusagen die Grundmengen für die Variablen festlegen.

Bis jetzt sind uns zwei Datentypen bekannt: Ganze Zahlen (INT) und Zeichenketten (STRING).

Daneben gibt es auch noch Fließkommazahlen. Einer heißt FLOAT. Er hat nur eine begrenzte Anzahl an Vor- und Nachkommastellen. Eine höhere Anzahl von Stellen hat der Datentyp DOUBLE.

Mit dem DIM-Befehl lassen sich auch sogenannte Felder (englisch: Arrays) definieren. Die Anweisung

Code :

1	DIM FeldName[x] AS INT

erzeugt ein Feld, das aus x INT-Variablen besteht. Jede dieser Variablen läßt sich dann einzeln ansprechen, als ob sie nicht in einem Feld stünde. Die erste Variable ist FeldName[0], die zweite FeldName[1] usw. Will man beispielweise der fünften Variablen des Feldes GanzZahl den Wert 10 zuweisen, so schreibt man einfach:

Code :

1	GanzZahl[4] = 10

Damit das Ganze verständlich wird, hier ein Beispielprogramm:

Code :

'Array-Demo
DIM Summand[3] AS FLOAT
DIM Summe AS FLOAT
DIM Zaehler AS INT
COLOR 14, 1
CLS
FOR Zaehler = 0 TO 2
 PRINT "Summand" + STR$(Zaehler + 1)
 INPUT Summand[Zaehler]
 Summe = Summe + Summand[Zaehler]
NEXT Zaehler
PRINT
PRINT STR$(Summand[0]) + " +" + STR$(Summand[1]) + " +" + STR$(Summand[2]) + " =" + STR$(Summe)

Da dieses Beispielprogramm etwas komplizierter ist als die anderen, wollen wir es Zeile für Zeile besprechen.

In der zweiten Zeile wird ein FLOAT-Feld mit drei Elementen namens Summand definiert.

In der dritten und der vierten Zeile werden zwei weitere Variablen definiert.

Anschließend werden die Farben gewählt und der Bildschirm gelöscht.

In der siebten Zeile steht nun der Anfang einer FOR/NEXT-Schleife. Zuerst wird ausgegeben, der wievielte Summand eingegeben werden soll. Danach muß der Benutzer diesen Summand eingeben.

Ihr merkt, dass man auch Variablen als "Arrayindex" verwenden kann. Bisher verwendeten wir dazu nur Zahlen.

Anschließend wird der eingegebene Summand gleich zu der Summe addiert. Man könnte zwar auch nachträglich alle drei Summanden zusammenzählen und der Variablen Summe zuweisen, doch das würde bei vielen Summanden sehr lange dauern.

Bei nur drei Summanden, wie wir in diesem Beispiel verwenden, ist der Geschwindigkeitsverlust zwar nicht bemerkbar, aber trotzdem sollten wir es nicht vernachlässigen, unsere Programme zu optimieren. Später wollen wir ja nicht nur Programme zum Addieren dreier Summanden schreiben, sondern auch solche Programme, mit denen man Space-Shuttles starten, steuern und landen lassen kann.

Nach der Schleife wird die Rechnung auf dem Bildschirm ausgegeben, aber das ist sowieso klar.

KAPITEL 8

Dateiverwaltung

Manchmal muss man externe Programme aus einem eigenen Programm heraus ausführen. Der Befehl hierzu ist SYSTEM. Der erste Parameter ist das Programm (inklusive Pfad), der zweite enthält eventuelle Parameter. Ein Beispielprogramm wäre hier sinnlos, weil es ja nichts machen würde, außer wieder ein anderes Programm zu starten.

Kommen wir lieber zur eigentlichen Dateiverwaltung. Der wichtigste Befehl heißt hier wohl OPENFILE. Mit ihm läßt sich eine Datei erzeugen oder einlesen. Seine Syntax lautet:

Code :

1	OPENFILE(DateiVariable, Dateiname, Modus)

DateiVariable ist eine Variable vom Typ FILE. Über diese Variable wird in der Folge auf die Datei zugegriffen. Dateiname ist der Name der Datei, einschließlich Pfad – z.B. „C:\TEMP\hallo.txt“. Der Modus ist entweder „R“ („read“, lies), „W“ („write“, schreibe) oder „A“ („append“, füge hinzu). Während „W“ eine neue Datei erzeugt oder eine existierende Datei überschreibt, öffnet „A“ eine bestehende Datei und fügt das Neue an ihrem Ende hinzu.

Vor dem Ende eines jeden Programms müssen alle geöffneten Dateien geschlossen werden. Dazu gibt es den Befehl CLOSEFILE. Seine Syntax lautet:

Code :

1	CLOSEFILE DateiVariable

Kommen wir nun zum Einlesen einer Datei. Dies geschieht mit dem Befehl READ. Syntax:

Code :

1	READ(DateiVariable, Variable)

Eigentlich ist READ nicht nur ein Befehl, sondern auch eine Funktion. Das heißt, READ gibt einen Wert zurück. Wir können schreiben:

Code :

1	a = READ(DateiVariable, Variable)

a ist gleich 0, wenn alles in Ordnung war. Wenn a jedoch einen anderen Wert hat, dann ist ein Fehler aufgetreten. Zum Beispiel könnte es sein, dass das Dateiende erreicht worden ist. Wir überprüfen also den Rückgabewert von READ, um festzustellen, ob das Dateieende erreicht worden ist, und brechen ab, wenn das der Fall ist.

Hier gleich ein praktisches Anwendungsbeispiel, nämlich ein Datei-Betrachter.

Code :

'Datei-Betrachter, unbrauchbare Version
DIM Datei AS FILE
DIM DateiName AS STRING
DIM Zeile AS STRING
DIM a AS INT
COLOR 15, 1
CLS
PRINT "Dateiname"
COLOR 14, 1
LOCATE 1, 10
PRINT "?"
INPUT DateiName
OPENFILE(Datei, DateiName, "R")
CLS
COLOR 15, 1
'Zeilen einlesen und anzeigen
DO
 a = READ(Datei, Zeile)
 PRINT Zeile
UNTIL a <> 0
CLOSEFILE Datei

Warum ich 'unbrauchbare Version' geschrieben habe? Ganz einfach: Probiert doch einmal aus, eine große Datei zu öffnen!

Die Datei wird 'in einem durch' angezeigt. Effektiv läßt sich dann nur die letzte Seite betrachten.

Am besten, wir bauen gleich eine seitenweise Anzeige ein. Wenn der Benutzer dann die nächste Seite sehen will, betätigt er einfach eine beliebige Taste.

Das können wir erreichen, indem wir einen Zähler einbauen, in dem gespeichert wird, wieviele Zeilen schon ausgegeben wurden. Mit IF/THEN/ELSE/ENDIF wird dann abgefragt, ob er einen bestimmten Wert (sagen wir, 20) erreicht hat. Wenn ja, muß der Benutzer eine beliebige Taste drücken.

Danach wird der Bildchirm gelöscht, der Zähler auf 0 gesetzt, und weiter geht's!

Hier das Listing. .......... Wieso denn? Es wäre doch eine gute Idee, euch die Umsetzung in Basic als Hausaufgabe aufzugeben! Den Programmablauf haben wir ja jetzt schon besprochen.

Kommen wir zum Schreiben in eine Datei. Der Schreibbefehl ist WRITE. Syntax:

Code :

1	WRITE(DateiVariable, Variable)

Als Beispiel ein einfacher ASCII-Texteditor.

Code :

'Texteditor
DIM Datei AS FILE
DIM DateiName AS STRING
DIM Zeile AS STRING
COLOR 15, 1
CLS
'Eingabe des Dateinamens
PRINT "Gib den Namen der Datei ein!"
PRINT "Vorsicht: Falls eine Datei mit demselben Namen bereits vorhanden ist,"
PRINT "wird sie überschrieben!"
COLOR 14, 1
INPUT DateiName
CLS
COLOR 15, 1
PRINT "Jetzt Text eingeben! Um das Programm zu beenden, Leerzeile eingeben."
COLOR 14, 1
'Eingabe des Texts
OPENFILE(Datei, DateiName, "W")
DO
 INPUT Zeile
 WRITE(Datei, Zeile)
UNTIL Zeile = ""
CLOSEFILE Datei

Das war für heute alles!

Eine Hausaufgabe habt ihr ja schon bekommen, aber wie immer sollt ihr euch auch mit den neuen Befehlen herumspielen. Nur Vorsicht bei „W“! Wenn schon eine Datei mit dem gewählten Namen existiert, wird sie gnadenlos überschrieben!

Lösungen zu Kapitel 8

Aufgabe 1: Ihr mußtet bei unserem Datei-Betrachter seitenweises Anzeigen der Datei ergänzen. Eine mögliche Lösung wäre folgendes Programm:

Code :

'Datei-Betrachter, brauchbare Version
DIM Datei AS FILE
DIM DateiName AS STRING
DIM Zeile AS STRING
DIM a AS INT
DIM b AS STRING
DIM Zaehler AS INT
COLOR 15, 1
CLS
PRINT "Dateiname"
COLOR 14, 1
LOCATE 1, 10
PRINT "?"
INPUT DateiName
OPENFILE(Datei, DateiName, "R")
CLS
COLOR 15, 1
'Zeilen einlesen und anzeigen
Zaehler = 0
DO
 a = READ(Datei, Zeile)
 PRINT Zeile
 Zaehler = Zaehler + 1
 IF Zaehler = 20
  INPUT b
  CLS
  Zaehler = 0
 ENDIF
UNTIL a <> 0
CLOSEFILE Datei

KAPITEL 9

Befehle und Funktionen

Heute geht es um SUBs, eines der wichtigsten Merkmale der strukturierten Programmierung. Bevor wir damit anfangen können, müssen wir zunächst den Unterschied zwischen Befehlen und Funktionen klären.

Befehle wie PRINT veranlassen den Computer, etwas Bestimmtes zu tun, z.B. einen Text auszugeben. Es lassen sich Parameter übergeben, die mehrere Optionen möglich werden lassen.

An Funktionen wie READ lassen sich ebenfalls Parameter übergeben. Doch Funktionen sind vielseitig. Eine Funktion gibt nämlich im Gegensatz zu einem Befehl einen Wert zurück. Mit diesem Wert kann man nun machen, was man will: ihn einer Variablen zuweisen, auf dem Bildschirm ausgeben, testen usw. Folgende Anwendungen sind gültig:

Code :

1
2
3

a = READ(Datei, Zeile)
PRINT READ(Datei, Zeile)
IF READ(Datei, Zeile) = "J" THEN …

Mit dem Befehl SUB kann man nun seine eigenen Befehle bzw. Funktionen erstellen. Natürlich sind es wohlgemerkt nicht ganz neue Befehle, sondern nur eine Zusammenfassung von Befehlen. Man spricht von einem Programm im Programm bzw. Unterprogramm. Dieser Ausdruck stammt zwar aus der Zeit, in der GW-Basic und Basic 2.0 supertolle Hits waren, aber er wird trotzdem heute immer noch verwendet.

Erstellen wir doch einfach 'mal eine einfache SUB, um zu sehen, wie diese funktionieren!

Code :

'SUB-Demo
DECLARE Hallo ()
DIM i AS INT
 
'Beispielprogramm
FOR i = 1 TO 10
 Hallo
NEXT i
END
 
'Eigentliche SUB
SUB Hallo
 PRINT "Hallo, Welt!" : 'Ein bisschen spät, nicht wahr?
RETURN

Jetzt werde ich viel erklären müssen. Gehen wir das Programm Zeile für Zeile durch.

Zeile 2 (DECLARE Hallo ()) ist notwendig, damit die SUB Hallo wie ein Befehl aufgerufen werden kann.

Mit den Zeilen 6 bis 8 wird erreicht, daß die SUB Hallo zehnmal aufgerufen wird.

Ab Zeile 12 beginnt nun die eigentliche SUB. Hinter dem Schlüsselwort SUB muß der Name der SUB stehen. In unserem Beispiel lautet dieser Hallo. Die Befehle, die nun beim Aufruf dieser SUB ausgeführt werden, stehen zwischen der Zeile mit dem Befehl SUB und der Zeile RETURN.

Im Grunde genommen sind SUBs nichts anderes als Blöcke, die man an einer beliebigen Stelle des Hauptprogramms oder einer anderen SUB aufrufen kann. Im Extremfall kann eine SUB sogar ein eigenes Programm beinhalten!

SUBs wären nicht SUBs, wenn man sie nicht mit Parametern aufrufen könnte. Damit eine SUB mit Parametern aufgerufen werden kann, müssen diese in der Zeile mit DECLARE definiert werden. Beispiel:

Code :

1	DECLARE DruckeText (Text:STRING, Anzahl:INT)

Bevor hier jemand in Panik ausbricht, die Erklärung: Wenn die SUB DruckeText aufgerufen wird, müssen jetzt zwei Parameter übergeben werden. Wir haben mit obiger Zeile definiert, dass der erste vom Typ STRING und der zweite vom Typ INT sein muss.

Text und Anzahl sind Variablennamen, unter denen die SUB die beiden Parameter ansprechen kann. Rufen wir jetzt die SUB DruckeText beispielsweise mit

Code :

1	DruckeText ("Hallo!", 1000)

auf, so erhält die Variable Text den Wert "Hallo!" und Anzahl den Wert 1000. Diese Variablen lassen sich jedoch nur in der SUB ansprechen, wie wir später erfahren werden.

Damit es jeder kapiert, ein Beispielprogramm:

Code :

'Parameter-Demo
DECLARE DruckeText (Text:STRING, Anzahl:INT)
 
'Beispielprogramm
COLOR 15, 1
CLS
DruckeText("Creative Basic ist super!", 20)
END
 
'Eigentliche SUB
SUB DruckeText (Text, Anzahl)
 DIM i AS INT
 FOR i = 1 TO Anzahl
  PRINT Text
 NEXT i
RETURN

Falls jemand noch immer Probleme mit den Parametern haben sollte: einfach fragen!

Kommen wir nun zu einem weiteren wichtigen Merkmal von SUBs, den lokalen Variablen. In den SUBs lassen sich Variablen definieren. Diese können nur innerhalb dieser SUB angesprochen werden. Es ist sogar möglich, Variablen zu definieren, die dieselben Namen wie Variablen aus dem Hauptprogramm haben.

Am besten, wir lassen das von einem Beispielprogramm demonstrieren.

Code :

'Lokale Variablen
DECLARE ZeigeText ()
DIM Text AS STRING
COLOR 15, 1
CLS
Text = "Tschüss!"
ZeigeText
COLOR 15, 1
PRINT "Wir befinden uns im Hauptprogramm. Der Inhalt von Text ist:"
COLOR 14, 1
PRINT Text
END
 
SUB ZeigeText
 DIM Text AS STRING
 Text = "Hallo!"
 COLOR 15, 1
 PRINT "Wir befinden uns in der SUB ZeigeText. Der Inhalt von Text ist:"
 COLOR 14, 1
 PRINT Text
RETURN

Wozu sind solche lokalen Variablen gut? Nun, sie haben folgende Vorteile:

•Jede SUB hat ihre eigenen lokalen Variablen. Auch wenn diese dieselben Namen wie die Variablen aus einer anderen SUB oder dem Hauptprogramm haben, sind sie 'eigenständige' Variablen.
•Nach dem Beenden der SUB werden alle lokalen Variablen automatisch gelöscht. Gäbe es keine lokalen Variablen, so müsste dies der Programmierer tun.

SUBs können auch Werte zurückgeben. Dadurch werden sie zu echten Funktionen. Ein Wert wird zurückgegeben, indem man ihn neben RETURN schreibt.

Als Beispiel habe ich ein Programm geschrieben, mit dem man die n-te Wurzel einer Zahl
ausrechnen kann. Ich verwendete dazu den Operator '^' (hoch).

Code :

'Funktionen-Demo
DECLARE nteWurzel (Zahl:DOUBLE, n:DOUBLE)
DIM Zahl AS DOUBLE
DIM n AS DOUBLE
COLOR 15, 1
CLS
PRINT "Von welcher Zahl soll die n-te Wurzel ausgerechnet werden?"
COLOR 14, 1
INPUT Zahl
PRINT
COLOR 15, 1
PRINT "Wieviel ist n?"
COLOR 14, 1
INPUT n
PRINT
COLOR 15, 1
IF n = 0
 PRINT "Die 0-te Wurzel kann nicht ausgerechnet werden!"
ELSE
 PRINT "Die n-te Wurzel der Zahl ist:"
 COLOR 14, 1
 PRINT nteWurzel(Zahl, n)
ENDIF
END
 
SUB nteWurzel (Zahl, n)
 DIM Wurzel AS DOUBLE
 Wurzel = Zahl ^ (1 / n)
RETURN Wurzel

Die mathematische Formel möchte ich euch nicht erklären (müsste in jedem Mathe-Lexikon stehen).

KAPITEL 10

Funktionen zur Verarbeitung von Strings

Ich möchte euch jetzt eine Reihe von Funktionen zur Stringverarbeitung vorstellen.

Funktion ASC. Syntax: Variable = ASC(Zeichen). Das Ergebnis ist der ASCII-Code des angegebenen Zeichens. Beispiel:

Code :

'ASC-Demo
DIM Zeichen AS STRING
COLOR 15, 1
CLS
PRINT "Gib ein beliebiges Zeichen ein!"
INPUT Zeichen
IF LEN(Zeichen) > 1
 PRINT "Fehler! Du hast kein Zeichen eingegeben, sondern einen Text!"
 END
ENDIF
PRINT
PRINT "Du hast das Zeichen "
LOCATE 4, 21
COLOR 14, 1
PRINT Zeichen
LOCATE 4, 22
COLOR 15, 1
PRINT " eingegeben. Sein ASCII-Code lautet "
LOCATE 4, 58
COLOR 14, 1
PRINT ASC(Zeichen)
LOCATE 4, 60
COLOR 15, 1
PRINT "."

In diesem Programm kommt auch die Funktion LEN vor. Sie gibt die Länge eines Strings, also die Anzahl seiner Zeichen, zurück.

Funktion CHR$. Syntax: Stringvariable = CHR$(ASCIICode). Das Ergebnis ist das Zeichen mit dem angegebenen ASCII-Code. Beispiel:

Code :

'CHR$-Demo
DIM ASCIICode AS INT
COLOR 15, 1
DO
 CLS
 COLOR 15, 1
 PRINT "Gib eine Zahl von 0 bis 255 ein!"
 COLOR 14, 1
 INPUT ASCIICode
UNTIL ASCIICode >= 0 & ASCIICode <= 255
COLOR 15, 1
PRINT "Das Zeichen mit diesem ASCII-Code ist "
LOCATE 3, 39
COLOR 14, 1
PRINT CHR$(ASCIICode)
LOCATE 3, 40
COLOR 15, 1
PRINT "."

CHR$(7) ist insofern eine Ausnahme, als dass es kein Zeichen, sondern einen Piepton erzeugt (einfach ausprobieren!).

Funktion STRING$. Syntax: Stringvariable = STRING$(Anzahl, Zeichen). Das Ergebnis ist eine Zeichenkette, die aus der angegebenen Anzahl des Zeichens besteht. Beispiel:

Code :

'Für Verliebte
COLOR 13, 0
CLS
FOR i = 1 TO 20
 PRINT STRING$(79, CHR$(3))
NEXT i

Funktion MID$. Syntax: Stringvariable = MID$(Zeichenkette, x, y). Das Ergebnis ist ein Teilstring der angegebenen Zeichenkette. Er beginnt mit dem x-ten Zeichen der ursprünglichen Zeichenkette und ist y Zeichen lang. Da sich dies komplizierter anhört, als es in Wirklichkeit ist, hier ein Beispiel:

Code :

'MID$-Demo
DIM Zeichenkette AS STRING
COLOR 15, 1
CLS
PRINT "Gib eine Zeichenkette ein!"
COLOR 14, 1
INPUT Zeichenkette
PRINT
COLOR 15, 1
PRINT "Die ersten sechs Zeichen der eingegebenen Zeichenkette lauten:"
COLOR 14, 1
PRINT MID$(Zeichenkette, 1, 6)
COLOR 15, 1
PRINT
PRINT "Die Zeichen 2 bis 4 lauten:"
COLOR 14, 1
PRINT MID$(Zeichenkette, 2, 3)

Siehe dazu auch: LEFT$, RIGHT$.

Funktion LTRIM$. Syntax: Stringvariable = LTRIM$(Zeichenkette). Das Ergebnis ist ein String, der der ursprünglichen Zeichenkette gleicht, nur ohne überflüssige Leerzeichen vor dem eigentlichen Text. Siehe dazu auch: RTRIM$.

Funktion UCASE$. Syntax: Stringvariable = UCASE$(Zeichenkette). Das Ergebnis gleicht der ursprünglichen Zeichenkette, nur die Kleinbuchstaben sind in Großbuchstaben umgewandelt worden. Siehe auch: LCASE$.

KAPITEL 11

Die Creative-Basic-Toolbox

Ich habe eine kleine Toolbox für euch zusammengestellt, die viele SUBs enthält, die euch das Leben leichter machen werden. Einige der Befehle, die ich hier verwende, haben wir noch nicht gelernt. Wer es unbedingt will, kann ja in der Hilfe nachsehen.

Code :

'The Real Adok's Way to Creative Basic Library
DECLARE cPrint (Text:STRING)
DECLARE Formatted (Zahl:INT)
DECLARE nteWurzel (Zahl:DOUBLE, n:DOUBLE)
DECLARE ZufallsZahl (Min:INT, Max:INT)
 
SUB cPrint (Text)
 PRINT STRING$(INT((80 - LEN(Text)) / 2 - 1), " ") + Text
RETURN
 
SUB Formatted (Zahl)
RETURN LTRIM$(RTRIM$(STR$(Zahl)))
 
SUB nteWurzel (Zahl, n)
RETURN Zahl ^ (1 / n)
 
SUB ZufallsZahl (Min, Max)
RETURN INT(RND(1) * (1 + Max - Min) + Min)

Eine kleine Dokumentation der SUBs:

•SUB cPrint: Als Parameter muss eine Zeichenkette angegeben werden. Diese wird dann zentriert auf dem Bildschirm ausgegeben.

•SUB Formatted: Als Parameter muss eine INT-Variable angegeben werden. Diese wird dann in einen String umgewandelt. Überflüssige Leerzeichen werden abgeschnitten. Diese SUB ist besonders gut für die Ausgabe von Zahlen geeignet. Sie lässt sich auch leicht an Fließkommazahlen anpassen.

•SUB nteWurzel: Als Parameter müssen zwei Variablen vom Typ DOUBLE angegeben werden. Diese SUB haben wir ja schon in der letzten Folge besprochen.

•SUB ZufallsZahl: Als Parameter müssen zwei Integervariablen übergeben werden. Diese bestimmen die Unter- und die Obergrenze für die zu erzeugende Zufallszahl. Die Zufallszahl ist vom Typ INT. Der Typ läßt sich aber leicht ändern. Falls Fließkommazahlen erzeugt werden sollen, muß noch zusätzlich der INT-Befehl verändert werden.

Nachwort

Das war auch schon The Real Adok's Way to Creative BASIC. Ich hoffe, dass es euch Spaß gemacht hat und ihr auch etwas dabei gelernt habt.

Beim Erstellen dieses Kurses richtete ich mich nach keinem Buch. Alle Ideen enstanden in meinem Kopf, und alle Beispielprogramme wurden auch nur von mir programmiert. Dieser Kurs ist das Ergebnis meiner langen Programmiererfahrung. Ich hoffe, die Mühe und die Zeit, die ich in den Kurs investiert habe, haben sich gelohnt und euch geholfen, sich mit der Programmiersprache Creative Basic vertraut zu machen.

Ich bin gerne bereit, euch bei Problemen zu helfen. Mit den Befehlen und Funktionen, die ihr in diesem Kurs erlernt habt, könnt ihr schon eine ganze Menge anfangen. Alles andere hängt von eurer Vorstellungskraft, Phantasie und den Ideen ab.

Mit dem Erlernen einer Programmiersprache eröffnet sich euch eine neue Welt. Nun kann man mit dem Computer kommunizieren, ihm seine eigenen Ideen verständlichmachen und seine ungeahnte Möglichkeiten für eigene Zwecke nützen.

Jeder, ob in der Schule oder im Beruf, ist laufend mit verschiedenen Problem konfrontiert, die er mit Hilfe des Computers wesentlich vereinfachen und lösen kann. Man soll aber nicht dabei bleiben, nur die Routinearbeiten zu erledigen. Wichtig wäre es, neue Ideen umzusetzen, etwas Neues zu schaffen.

Wenn man eine Programmiersprache erlernt hat, heißt es aber noch lange nicht, dass man nichts mehr Neues dazulernen kann. Es gibt hier keine Grenzen. Alles hängt von euch ab. Versucht, neue Nischen zu finden, riskiert etwas, setzt euch ein, gebt euch mit dem Erreichten nicht zufrieden!

Vielleicht sehen wir einander wieder in einem anderen Kurs. Ich habe noch so viele Ideen...

tut orials.de	tut verbinden	tut dir helfen	tut kooperieren
©2000-2012 tutorials.de Alle Rechte vorbehalten	tut informieren » Impressum » Nutzungsregeln » Netiquette » Team » Redaktion	» Tutorials » Videotutorials » Showroom » Events & Contests » Chat » RSS-Feed » Blogs	» der-webdesigner.net » DesignerInAction » Design Nation » Directorforum » Flashhilfe » PHP-Resource » PHPwelt » PSD-Tutorials

The Real Adok's Way to Creative Basic

Artikel bewerten

Login

Bereiche

Kategorien

Forum - Programming

Kriege Graphics.drawImage nicht ans laufen

AW: Undefined reference

AW: Undefined reference

AW: Undefined reference

AW: Array in iframe mitschleppen

Shop @ tutorials.de

Newsletter @ tutorials.de

Nützliches