The Real Adok's Way to QBASIC - Der QBasic-Kurs fr Einsteiger 
Copyright (C) 1996 by The Real Adok 
Erschienen im PC-Heimwerker und im Hugendubelexpress! 
 
                              ****************
                              ***  TEIL 1  ***
                              ****************
Es gibt anscheinend ziemlich viele Leute hier im PC-Heimwerker, die das
Programmieren in Basic erlernen wollen und sehnschtig auf einen Kurs warten.
Deshalb entschliee ich mich, endlich mit einem Kurs anzufangen. In meinem
Kurs behandeln wir den Interpreter QBasic, der bei MS-DOS ab Version 5.0
beiliegt. Falls du ein anderes Betriebssystem benutzt, in dem QBasic nicht
enthalten ist, kannst du auch den noch leistungsfhigeren und 99,9%ig
kompatiblen Compiler Quick Basic ab Version 4.0 verwenden. (Die
weitverbreitete Meinung, Quick Basic sei 100%ig kompatibel, ist nicht ganz
richtig. Wenn man CALL ABSOLUTE anwendet, mu man Quick Basic mit dem
Parameter /L starten, whrend bei QBasic der Parameter entfallen kann. Dazu 
abernoch spter.) 
Von Power Basic wrde ich eher abraten, weil ziemlich viele
Befehle eine andere Syntax haben und die Online-Hilfe nicht so genial ist.
Nun, la uns mit dem Kurs beginnen. QBasic lt sich durch Eingabe von
QBASIC am DOS-Prompt starten. Binnen weniger Sekunden ist der Editor geladen.
Es erscheint eine graue Dialogbox. Du kannst jetzt whlen, ob du zuerst eine
Einfhrung in die Bedienung des Editors erhalten, oder dich gleich ins
Programmiervergngen strzen willst. Falls du dich noch nicht mit der
Bedienung der DOS-Programme EDIT und HELP auskennst, die im Prinzip nichts
anderes als abgespeckte Versionen des QBasic-Editors und der
QBasic-Online-Hilfe sind, solltest du dich fr die Einfhrung in die Bedienung
des Editors entscheiden. Du whlst diesen Menpunkt, indem du dich auf die
Enter-Taste strzt. Pltzlich wird der Bildschirm schwarz, und es erscheinen
komische weie Buchstaben. Dies ist die Online-Hilfe von QBasic. Du kannst mit
den Cursortasten und Page-Up bzw. Page-Down in ihr herumreisen. La dir Zeit
und lies alles genau von oben bis nach unten durch. Bald wirst du auf das Ende
der Online-Hilfe stoen. "DAS WAR SCHON ALLES? Die berhmte Online-Hilfe habe
ich mir lnger vorgstellt!" wirst du jetzt rufen. Halt, das war noch nicht
alles! Reise mit den Cursortasten wieder zurck zum Anfang der Hilfe. Was
erkennst du dort? Grne Pfeile, zwischen denen sich ein kurzer Text befindet!
Wozu sollen die gut sein? Probiere es einfach aus! Lehne dich zuerst zurck 
und entspanne dich. Gehe dann mit dem Cursor auf den Text, der zwischen den 
grnen Pfeilen steht, und hacke einmal auf die Enter-Taste. "Was? Das geht 
ja noch weiter!" rufst du entsetzt. Richtig, denn die Texte zwischen den 
grnen Pfeilen sind Menpunkte, mit denen du in weitere Gebiete der riesigen
Online-Hilfe vordringen kannst. Jetzt wirst du dich sicherlich fragen, wozu
das ganze gut sein soll. Ganz einfach: Nehmen wir an, du wrest gerade dabei,
ein QBasic-Programm zu erstellen, und dir fllt auf einmal nicht mehr ein, wie
ein bestimmter Befehl funktioniert. Dann fhrst du einfach mit dem Cursor auf
diesen Befehl und drckst F1. Damit wird die Online-Hilfe fr diesen Befehl
aufgerufen. Du kannst dir jetzt in Ruhe die Anweisungen durchlesen und mit
einem Tastendruck auf Escape wieder zum Editor zurckkehren. Jetzt fragst du
dich sicherlich, wozu ein QBasic-Kurs denn gut sein sollte, denn man knnte
theoretisch das Programmieren auch nur mit der Online-Hilfe erlernen. Das
stimmt! Einer meiner Freunde erlernte QBasic auch nur mit der Online-Hilfe
und kann schon relativ viel programmieren. Vielleicht liegt es daran, da er
Hesse ist und diese besonders gut fr das Programmieren geeignet sind (?).
Aber ich glaube, auch andere "Stmme" knnen es mindestens ebensogut. Dennoch
wrde ich von dieser Methode vorerst abraten, weil die Befehle ziemlich
kompliziert beschrieben sind, weshalb man schon Grundlagen in der
QBasic-Programmierung haben sollte.
Wenn du nun mit dem Schmkern in der Online-Hilfe fertig bist und voller
schpferischer Energie dich auf das Programmieren freust, drcke die
Escape-Taste. Schwuppdiwupp ist der schwarze Bildschirm verschwunden.
Stattdessen lchelt dich eine freundliche, blaue Oberflche an. Sie wird dich
beim Programmieren immer begleiten. Du lufst schon jetzt langsam die Gefahr,
dich zu verlieben. Sie wartet ergeben mit einer Eingabeaufforderung auf dich.
Du bist am Zug. Fangen wir an, ein erstes Programm zu schreiben. Du kannst
ein Programm genauso wie einen Text eingeben. QBasic ist nmlich nichts
anderes als ein erweiteter MS-DOS-Texteditor. Tippe nun genauso, wie du mit
dem Editor einen Brief schreibst, folgendes Programm ab. Der Name des
Programms lautet KURS0001.
#PROGEIN
CLS
PRINT "Hallo, Gebieter! Wie soll ich dich ansprechen?"
PRINT "Gib deinen Namen ein!"
LINE INPUT name$
PRINT "Hallo, ";
PRINT name$; 
PRINT ", ich will all deine Wnsche erfllen."
PRINT "Ich will dir jetzt zeigen, mit welchen Befehlen du mich"
PRINT "beherrschen kannst."
#PROGAUS
Wenn du dieses Programm fertig abgetippt hast, kannst du es durch das Drcken
der Taste F5 starten. Zuerst wird der Bildschirm gelscht. Danach erscheint
folgender Text: Hallo, Gebieter! Wie soll ich dich ansprechen? Gib deinen
Namen ein! Jetzt bist du an der Reihe. Gib entweder deinen Namen, das Pseudo
oder was auch immer ein. Mit Enter schliet du die Eingabe wieder ab. Jetzt
erscheint ein weiterer Text: Ich will dir jetzt zeigen, mit welchen Befehlen
du mich beherrschen kannst. Danach erscheint die Meldung "Beliebige Taste
drcken, um fortzusetzen", und nach einem Tastendruck wird das Programm
beendet. Das war unser erstes Programm, das wir erstellt haben! So einfach
geht das. Super, nicht? Aber wie funktioniert das Programm eigentlich?
Lehne dich zurck und entspanne dich. (Das mu man vorsichtshalber immer
schreiben, wenn etwas Neues kommt!) Die erste Zeile des Programms lautet CLS.
CLS ist ein Befehl, welcher QBasic befiehlt, den Bildschirm schwarz zu machen,
also den vorherigen Inhalt zu lschen. Wenn ein Programm gestartet wird und
QBasic auf einen Befehl trifft, bersetzt es ihn in eine bestimmte Reihe von 
Impulsen, die der Computer versteht. 
Die zweite Zeile beginnt mit PRINT.
Dies ist ebenfalls ein Befehl. Im Gegensatz zu CLS hat PRINT 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 mssen in
QBasic immer in Anfhrungszeichen eingeschlossen sein. Ansonsten wrde 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 LINE INPUT. Was ist das schon wieder? Mit
LINE INPUT lassen sich Zeichenketten eingeben. In diesem Fall fragte der
Computer in der dritten Zeile nach deinem Namen. Der Satz bleibt auf dem
Bilschirm stehen, und mit LINE INPUT erwartet der Computer die Eingabe deines
Namens. Als Parameter von LINE INPUT steht im Beispielprogramm name$. Das
Dolarzeichen bezeichnet man als "String". Man erhlt es, indem man 
gleichzeitig Umschalt und 4 bettigt. Das Stringzeichen gibt an, da name$
ein Platzhalter fr Zeichenkettenvariablen ist. Nachdem man den gewnschten
Namen eingegeben und Enter gedrckt hat, wird dieser Name im Platzhalter
name$ abgespeichert. Jetzt knnen alle anderen Befehle auf diesen 
ausgefllten Platzhalter zurckgreifen. Man nennt einen solchen Platzhalter
eine Stringvariable. Wir werden spter noch andere Variablen kennenlernen. Es
klingt am Anfang ein bichen kompliziert, ist aber sehr einfach.
Die fnfte Zeile ist wieder ein PRINT-Befehl. Nach dem Parameter "Hallo, "
steht allerdings ein Punktstrich (Semikolon). Wie kluge Leser sicherlich
gemerkt haben, dient er dazu, da der nchste Text oder die nchste Zahl
direkt neben diesem erscheint. In unserem Programm wird zuerst die
Programmzeile fnf ausgefhrt und der Text 'Hallo, ' auf dem Bildschirm
ausgegeben. Zeile sechs ist wieder eine Bildschirmausgabe, und weil am Ende
der Zeile fnf ein Punktstrich stand, wird sie direkt neben dem Text der
Zeile fnf auf dem Bildschirm geschrieben.
Die Zeile sechs beinhaltet noch eine Besonderheit: Als Parameter wird diesmal
kein in Anfhrungszeichen eingeschlossener Text, sondern die Stringvariable
name$ angegeben. Das bedeutet, da kein vorgegebener Text, sondern der Inhalt
der Variablen ausgegeben wird. Neben name$ steht wieder ein Punktstrich,
wodurch, wie wir bereits oben erwhnt haben, der Zeilenvorschub unterdrckt
und der Text, der in der siebten Programmzeile angegeben ist, in der selben
Zeile ausgegeben wird.
Am Ende der siebten Programmzeile steht diesmal kein Punktstrich, wodurch der
Text der achten Programmzeile wieder in einer eigenen Zeile ausgegeben wird.
Fertig! Das war das ganze Programm. Jetzt knnen wir uns wieder entspannt
zurcklehnen. Ich mchte noch einige Tips 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 Menpunkt Datei-Drucken 
ausdrucken. Ein abgetipptes Programm kann man mit dem Menpunkt 
Datei-Speichern abspeichern. Wenn du das Programm zum ersten Mal abspeicherst, 
wirst du nach dem Dateinamen gefragt, unter dem es gespeichert werden soll. 
Fr dieses Programm schreibst du KURS0001. QBasic ergnzt automatisch die
Dateierweiterung BAS. Der komplette Name wird nach dem Abspeichern
KURS0001.BAS heien.
Nach dem Ende einer Lektion des Kurses solltest du mit den
erlernten Befehlen experimentieren. Dazu gebe ich "Hausaufgaben", die du
lsen sollst. Die richtigen Ergebnisse erscheinen im nchsten Teil des Kurses.
Aufgabe 1: Entwirf ein Programm, das zuerst den Benutzer nach seinem Namen
und danach nach seinem Pseudo fragt. Anschlieend soll der Computer 
folgenden Text auf dem Bildschirm ausgeben: "Guten Tag, <name>! Dein Pseudo 
lautet <pseudo>. Willkommen im Club der QBasic-Programmierer!" 
<name> steht dabei fr die Variable, in der der
Name, und <pseudo> fr die Variable, in der das Pseudo
abgespeichert ist. In meinem konkreten Fall wrde der Satz lauten: "Guten Tag,
Claus-Dieter Volko! Dein Pseudo lautet The Real Adok. Willkommen im Club der
QBasic-Programmierer!" Beachte, da du abweichend vom Programmbeispiel 
KURS0001 diesmal zwei Stringvariablen verwenden mut.
Aufgabe 2: Nun sollst du ein Programm schreiben, das den Namen des Benutzers
und den seiner Freundin einliest. Anschlieend soll es einen lustigen Satz
ber die beiden auf dem Bildschirm ausgeben, etwa so: "<freundin>: 'Wann
wirst du mich endlich heiraten, <benutzer>?'"
Aufgabe 3: Jetzt etwas fr die Fortgeschrittenen. Es gibt einen Befehl namens
LPRINT, mit dem man Texte auf den Drucker ausgeben kann. Er funktioniert
ansonsten so wie PRINT. Entwirf ein Programm, das zunchst eine oder mehrere
Zeichenketten vom Benutzer eingeben lt und sie anschlieend zusammen mit
einem anderen Text auf dem Drucker ausgibt. Falls du Probleme mit LPRINT
haben solltest, schau' in der Online-Hilfe nach!
Ich hoffe, ihr habt viel Spa an dieser Lektion gehabt. Berichtet von euren
Erfahrungen oder Problemen in dieser Rubrik.


                              ****************
                              ***  TEIL 2  ***
                              ****************
Willkommen zum zweiten Teil des QBasic-Kurses! Als erstes mchte ich euch die 
Lsungen zu den "Hausaufgaben" des ersten Teils zeigen. 
In Aufgabe 1 mutet ihr ein Programm schreiben, das zuerst den Benutzer nach 
seinem Namen und seinem Pseudo fragt und anschlieend einen Text ausgibt. Eine 
mgliche Lsung wre das folgende Listing: 
#PROGEIN
CLS
PRINT "Wie lautet dein Name?"
LINE INPUT name$
PRINT "Und wie lautet dein Pseudo?"
LINE INPUT pseudo$
PRINT "Guten Tag, ";
PRINT name$;
PRINT "! Dein Pseudo lautet ";
PRINT pseudo$;
PRINT "."
PRINT "Willkommen im Club der QBasic-Programmierer!"
#PROGAUS
Zur Wiederholung: Mit der ersten Zeile wird der Bildschirm gelscht. Man 
sollte am Anfang eines jeden Programms den Bildschirm lschen, weil es 
einfach schner und bersichtlicher aussieht. Mit der zweiten Zeile wird der 
Text 'Wie lautet dein Name?' auf dem Bildschirm ausgegeben. In der dritten 
Zeile steht die Anweisung, mit der der Name eingegeben und in der Variablen 
'name$' gespeichert wird. Vierte und fnfte Zeile funktionieren genauso, nur 
wird diesmal das Pseudo eingegeben. Mit den restlichen sechs Zeilen wird der 
Text auf dem Bildschirm ausgegeben. Zur Erinnerung: Der Punktstrich bzw. das 
Semikolon verhindert einen Zeilenvorschub. Das heit, da der nchste Text 
gleich anschlieend und nicht erst in der nchsten Zeile ausgegeben wird. 
Die zweite Aufgabe war es, ein Programm zu schreiben, das den Namen des 
Benutzers und den seiner Freundin einliest. Anschlieend soll ein lustiger 
Text ausgegeben werden. Hier eine mgliche Lsung: 
#PROGEIN
CLS
PRINT "Wie heit du?"
LINE INPUT benutzer$
PRINT "Und wie heit deine Freundin bzw. dein Freund?"
LINE INPUT freundin$
PRINT freundin$; ": 'Wann wirst du mich endlich heiraten, "; benutzer$; "?'"
#PROGAUS
Ihr seht, im Prinzip funktioniert es genauso wie in der ersten Aufgabe. Nur 
die letzte Zeile sieht etwas komisch aus. Keine Panik, es ist nur eine 
verkrzte Form mehrerer PRINT-Anweisungen. Statt der letzten Zeile knnte man 
auch 
#PROGEIN
PRINT freundin$;
PRINT ": 'Wann wirst du mich endlich heiraten, ";
PRINT benutzer$; 
PRINT "?'"
#PROGAUS
schreiben. Solange es nicht auf Kosten der bersicht geht, wrde ich aber 
lieber zur verkrzten Methode raten. 
Die dritte und letzte Hau-Sauf-Gabe :-) war ein Programm, das mehrere Zeilen 
vom Benutzer einliest und sie mit Hilfe des Befehls LPRINT auf dem Drucker 
ausgibt. Hier eine mgliche Lsung: 
#PROGEIN
CLS
PRINT "Bitte gib drei kurze Stze ein!"
LINE INPUT satz1$
LINE INPUT satz2$
LINE INPUT satz3$
LPRINT "Der 1. Satz lautet:"
LPRINT satz1$
LPRINT "Der 2. Satz lautet:"
LPRINT satz2$
LPRINT "Der 3. Satz lautet:"
LPRINT satz3$
#PROGAUS
Dieses Listing knnte man noch optimieren, aber dazu spter, wenn wir ber die 
Arrayverwaltung und die FOR-/NEXT-Schleife hren werden. 
Das letzte Mal lernten wir die Befehle CLS, PRINT und LINE INPUT kennen. 
PRINT und LINE INPUT sind die grundlegendsten 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 QBasic ein und speichert es unter KURS0002.BAS. 
#PROGEIN
CLS
zahl1 = 12
zahl2 = 3
PRINT "Zahl 1:";
PRINT zahl1
PRINT "Zahl 2:";
PRINT zahl2
PRINT "Addition:";
PRINT zahl1 + zahl2
PRINT "Subtraktion:";
PRINT zahl1 - zahl2
PRINT "Multiplikation:";
PRINT zahl1 * zahl2
PRINT "Division:";
PRINT zahl1 / zahl2
#PROGAUS
Schon haben wir ein einfaches Rechenprogramm! Startet es, und QBasic fhrt 
euch alle Grundrechnungsarten vor. Wenn ihr andere Zahlen als 
12 und 3 einsetzen wollt, so mt ihr einfach die entsprechenden Werte in die 
Zeilen 2 und 3 schreiben. 'zahl1' und 'zahl2' sind, wie sich manche von euch 
wahrscheinlich schon denken werden, Zahlenvariablen. Sie sind Platzhalter fr 
beliebige Fliekommawerte, die eine bestimmte Gre und Anzahl von 
Nachkommastellen haben knnen. (Wie gro sie sein knnen und wie viele 
Nachkommastellen sie haben knnen, wei ich nicht auswendig. Es mte aber 
irgendwo in der Online-Hilfe, Verzeichnis 'Inhalt', zu finden sein!) Es gibt 
noch andere sogenannte 'Datentypen', in denen man Zahlen speichern kann. 
Darauf mchte ich erst spter eingehen. Im Moment reicht es, zu wissen, da 
man in Variablen, die kein Stringzeichen ($) enthalten, Fliekommawerte 
speichern kann. 
Wie das Programm zeigt, lassen sich mit 'PRINT' auch Zahlenwerte auf dem 
Bildschirm ausgeben. Vor und nach der Zahl wird jeweils ein Leerzeichen 
ausgegeben. Bei negativen Zahlen entfllt das erste Leerzeichen. Stattdessen 
wird das Vorzeichen ausgegeben. Ihr knnt dies leicht berprfen, indem ihr 
in der Zeile 2 oder 3 fr eine der beiden Variablen einen negativen Wert 
einsetzt. 
Die Zeichen '+', '-', '*', '/', '^' sind, wie ihr sicherlich schon bemerkt 
habt, Rechenzeichen, wobei '/' fr Division und '^' fr Potenz steht. Diese 
beiden sollte man sich besonders gut merken, weil sie von der schriftlichen 
Norm abweichen. Anfnger knnten auch leicht '*' (Multikplikationszeichen) 
mit '.' (Komma) verwechseln. Auerdem kann das '*' leicht vergessen werden 
(z.B. 2y statt 2 * y). 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. 
Natrlich kann man nicht nur die Ergebnisse der Rechnungen anzeigen, sondern 
sie auch anderen Variablen zuweisen. Hier ein weiteres Beispielprogramm. 
Speichert es unter KURS0003.BAS und startet es mit F5. 
#PROGEIN
CLS
zahl1 = 100
DO
 zahl1 = zahl1 + 1.6
 PRINT zahl1
LOOP
#PROGAUS
Das Programm luft unendlich lange. Keine Panik, der Computer ist nicht 
abgestrzt! Durch gleichzeitiges Bettigen von STRG und PAUSE lt sich das 
Programm unterbrechen. Ihr gelangt in QBasic zurck. Die Programmzeile, bei 
deren Ausfhrung ihr STRG und PAUSE gedrckt habt, ist hervorgehoben. Kmmert 
euch jedoch nicht darum. 
Nun mchte ich das Programm Zeile fr Zeile beschreiben. Zeile 1 lscht den 
Bildschirm, Zeile 2 setzt die Variable 'zahl1' auf 100. Das habe ich vorhin 
vergessen zu erwhnen: Das Gleichheitszeichen kann in Basic verschiede 
Bedeutungen haben. Hier bedeutet es 'Zuweisung'. Das heit, da der Variablen, 
die links von dem Gleichheitszeichen steht, der Wert rechts von dem 
Gleichheitszeichen zugewiesen wird. Eine Anweisung wie 
#PROGEIN
100 = zahl1
#PROGAUS
fhrt zu einer Fehlermeldung. Man kann brigens auch 'LET' vor die Variable 
schreiben. Unser Beispiel wrde dann folgendermaen lauten: 
#PROGEIN
LET zahl1 = 100
#PROGAUS
Die Verwendung von 'LET' ist aber heutzutage weder notwendig noch 
empfehlenswert. 
Die nchsten Zeile enthlt ein neues Schlsselwort. Es handelt sich um 'DO', 
einen sehr flexiblen und vielfltig einsetzbaren Befehl, den wir in der Folge 
ber Schleifen und Verzweigungen genau besprechen werden. Jetzt sei nur 
gesagt, da der Programmteil zwischen 'DO' und 'LOOP' unendlich oft 
ausgefhrt wird. 
In der 4. Zeile wird der Variablen 'zahl1' das Ergebnis der Addition 
'zahl1 + 1.6' zugewiesen. Das ist einfacher, als es klingt, denn es bedeutet 
nichts anderes, als da 'zahl1' um 1,6 erhht wird. Danach wird die Zahl auf 
dem Bildschirm ausgegeben, und mit 'LOOP' wird das ganze ab Zeile 4 
wiederholt. Alles klar? 
Nun, zurck zum ersten Beispielprogramm. Wie wre es, wenn der Benutzer die 
Zahlen selbst eingeben knnte? Dazu gibt es den Befehl 'INPUT'. Er funktioniert 
genauso wie 'LINE INPUT', nur wird zustzlich ein Fragezeichen auf dem 
Bildschirm ausgegeben. Man kann zwar mit 'INPUT' auch Zeichenketten eingeben, 
doch dazu eignet sich 'LINE INPUT' meiner Meinung nach besser, weil sich 
damit auch Beistriche eingeben lassen. Erstellt ein solches Rechenprogramm 
gleich als "Hausaufgabe"! 
Ich habe mir schon berlegt, was ich in den nchsten Folgen des Kurses 
schreiben werde. Hier nun die Vorschau fr die nchsten acht Folgen: 
- Folge 3: Einfachste Grafik- und Soundeffekte. Hier zeige ich euch, wie man 
seine Programme mit einfachen Befehlen "verschnern" kann. Ich beschrnke mich 
jedoch vorerst nur auf den Textmodus. 
- Folge 4: Debugging. QBasic bietet eine Reihe von Methoden, mit denen man 
sich auf Fehlersuche begeben kann. Ich erklre sie in dieser Folge und 
beschreibe auch die erweiterten Debugging-Methoden von Quick Basic. 
- Folge 5: Schleifen und Verzweigungen. Es ist langweilig, wenn jedes 
Programm immer von Anfang bis Ende luft. Mit Hilfe von Verzweigungen kann man 
je nach Ereignis verschiedene Routinen aufrufen. Schleifen sind auch sehr 
praktisch, wenn man Programmteile nicht mehrere Male hintereinander schreiben 
will oder nicht wei, wie oft ein bestimmter Programmteil ausgefhrt werden 
mu. 
- Folge 6: Programmierung von Abenteuerspielen. Nach Abschlu von Lektion 5 
kann man bereits Adventures hnlich "Die Reise zum Mond" selbst erstellen. 
Diese Folge hat mit dem eigentlichen Programmieren nur wenig zu tun, weil 
vielmehr das Planen und Umsetzen von Spielen im Vordergrund steht. Ein kurzes 
Beispiel-Adventure wird gemeinsam erarbeitet. Wer fr Spiele nichts brig hat, 
kann diese Folge berspringen. 
- Folge 7: Fortgeschrittene Grafikprogrammierung. Hier werden die 
Bildschirmmodi besprochen und einige Zeichenbefehle vorgstellt, unter anderem 
das mchtige 'DRAW'-Kommando. 
- Folge 8: Datentypen in Basic. Wie oben erwhnt, stelle ich hier die anderen 
Datentypen zur Speicherung von Zahlenwerten vor. 
- Folge 9: Dateiverwaltung. Ich stelle die Befehle vor, mit denen man in 
Dateien schreiben und Dateien einlesen kann. Auerdem erklre ich, wie man 
DOS-Kommandos in Basic benutzt. 
- Folge 10: SUBs und FUNCTIONs. In dieser Folge erklre ich den Unterschied 
zwischen Befehlen und Funktionen und bringe euch bei, selbst neue zu 
erstellen. 
So, das wre im Moment alles, was ich mir vorgenommen habe. Falls jemand 
Wnsche, Fragen oder Kritik zu diesem Kurs hat, kann er es entweder an den 
PC-Heimwerker oder direkt an mich schreiben. Meine Addy findet ihr in der 
Pseudo-Liste. 


                              ****************
                              ***  TEIL 3  ***
                              ****************
Willkommen zum dritten Teil meines QBasic-Kurses! Heute mchte ich euch 
zeigen, wie man mit einfachen grafischen und musikalischen Effekten seine 
Programme aufwerten kann. Doch zunchst zu unserer Hausaufgabe. Ihr mutet 
unter Verwendung des 'INPUT'-Befehls das Programm 'KURS0002.BAS' so 
verndern, da der Benutzer die Zahlen selbst eingeben kann. Hier eine 
mgliche Lsung: 
#PROGEIN
CLS
PRINT "Wie lautet die erste Zahl";
INPUT zahl1
PRINT "Wie lautet die zweite Zahl";
INPUT zahl2
CLS
PRINT "Zahl 1:";
PRINT zahl1
PRINT "Zahl 2:";
PRINT zahl2
PRINT "Addition:";
PRINT zahl1 + zahl2
PRINT "Subtraktion:";
PRINT zahl1 - zahl2
PRINT "Multiplikation:";
PRINT zahl1 * zahl2
PRINT "Division:";
PRINT zahl1 / zahl2
#PROGAUS
Ihr seht, da der Befehl 'INPUT' fast genauso wie 'LINE INPUT' funktioniert. 
Wenn 'INPUT' ausgefhrt wird, erscheint auf dem Bildschirm ein Fragezeichen. 
Das Programm verlangt nun, da der Benutzer einen Text oder eine Zahl eingibt. 
Die Eingabe wird mit der ENTER-Taste besttigt, und der eingegebene Text bzw. 
die eingegebene Zahl wird in der Variablen gespeichert, die im Listing neben 
'INPUT' steht. Die Unterschiede zwischen 'INPUT' und 'LINE INPUT' bestehen 
also darin, da 'INPUT' ein Fragezeichen ausgibt und der Benutzer nicht nur 
Zeichenketten, sondern auch Zahlen eingeben kann. Dann mu 'INPUT' aber auch 
eine Stringvariable als Parameter bergeben bekommen. (Um Miverstndnissen 
vorzubeugen: Zeichenketten knnen auch Ziffern enthalten!) 
Wenn ihr das obenstehende Programm gestartet habt, werdet ihr bemerkt haben, 
da das Fragezeichen, das 'INPUT' auf dem Bildschirm ausgibt, direkt neben 
den Ausgaben der 'PRINT'-Anweisungen erscheint. Das heit im Klartext, da 
sich das Semikolon nicht nur auf die nchste 'PRINT'-, sondern berhaupt auf 
die nchste Anweisung, die eine Bildschirmausgabe bewirkt, bezieht. Auch 
'LINE INPUT' bewirkt eine Bildschirmausgabe (der Cursor und die 
eingegebenen Zeichen werden auf dem Bildschirm ausgegeben)! 
Nun zu dem Thema dieser Folge: Wie kann man einfache Grafik- und Soundeffekte 
realisieren, um die eigenen Programme aufzuwerten? Dazu gibt es mehrere 
Befehle, die ich jetzt aufzhlen und nher erklren mchte. 
- Es ist vielleicht nicht so schn, 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 heit, seine Schreibweise, lautet: 
#PROGEIN
LOCATE zeile, spalte 
#PROGAUS
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 (vorlufig) beschrnken, hat eine Auflsung 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 nchste Bildschirmausgabe findet an dieser Position statt, was sehr 
praktisch ist. 
Man kann auch wahlweise 'zeile' oder 'spalte' weglassen. Der nicht angegebene 
Wert wird dann automatisch eingefgt. Beispiel: Wenn wir uns in Zeile 12, 
Spalte 10 befinden und den Befehl 
#PROGEIN
LOCATE , 40
#PROGAUS
verwenden, wird der Cursor an die Position Zeile 12, Spalte 40 gesetzt. Hier 
wurde also die Zeile nicht angegeben, dafr aber die aktuelle Zeile 
automatisch eingesetzt. 
Um die Fhigkeiten des 'LOCATE'-Befehls zu demonstrieren, hier eine erweiterte  
Version unserer Hausaufgabe: 
#PROGEIN
CLS
LOCATE 2, 2
PRINT "Wie lautet die erste Zahl";
INPUT zahl1
LOCATE 5, 2
PRINT "Wie lautet die zweite Zahl";
INPUT zahl2
CLS
LOCATE 2, 2
PRINT "Zahl 1:";
PRINT zahl1;
LOCATE , 60
PRINT "Zahl 2:";
PRINT zahl2
LOCATE 3, 1
PRINT "---------------------------------------------------------------------";
PRINT "-----------"
LOCATE 5, 2
PRINT "Addition:";
LOCATE , 17
PRINT zahl1 + zahl2
LOCATE 6, 2
PRINT "Subtraktion:";
LOCATE , 17
PRINT zahl1 - zahl2
LOCATE 7, 2
PRINT "Multiplikation:";
LOCATE , 17
PRINT zahl1 * zahl2
LOCATE 8, 2
PRINT "Division:";
LOCATE , 17
PRINT zahl1 / zahl2
#PROGAUS
Damit ihr keine Tippfehler macht: In der Zeile 16 befinden sich 69 Minusse, in 
der Zeile 17 9 Minusse. Man knnte zwar auch die insgesamt 78 Minuszeichen in 
einer 'PRINT'-Anweisung zusammenfassen, jedoch ist die Zeile dann so lang, da 
sie ber den Bildschirmrand hinaus geht. Auerdem drfen im PCH die Listings 
nur eine Zeilenbreite von maximal 70 Zeichen haben, wenn kein Umbruch 
entstehen soll. 
Dieses Programm werden wir noch fters verndern. Speichert es also unter 
'KURS0004.BAS'. 
- Bisher hatten alle Programme eine einheitliche Farbkombination: weier Text 
auf schwarzem Hintergrund. Da dies mit der Zeit sehr eintnig werden kann, 
gibt es in QBasic einen Befehl, um eine andere Farbkombination einzustellen: 
'COLOR'. Seine Syntax lautet: 
#PROGEIN
COLOR vordergrundfarbe, hintergrundfarbe 
#PROGAUS
Die Vordergrundfarbe ist hierbei die Farbe, in der der Text geschrieben werden 
soll, whrend die Hintergrundfarbe, wie der Name schon sagt, die Farbe des 
Hintergrunds ist. Wie bei 'LOCATE' kann auch ein Parameter weggelassen werden. 
Wie gibt man nun die Vordergrundfarbe und die Hintergrundfarbe an? Das ist 
leider nicht ganz so einfach. Zu jeder Farbe gehrt ein sogenannter 
Farbcode. Dieser Farbcode ist eine Zahl von 0 bis einschlielich 31. Jede Zahl 
von 0 bis einschlielich 7 steht fr eine "dunkle" Farbe. Zhlt man zu einer 
dieser Zahlen 8 dazu, so erhlt man die dazugehrige "helle" Farbe. Beispiel: 
Der Farbcode der Farbe Dunkelblau ist 1. Daher ist der Farbcode der Farbe 
Hellblau 9. Nur die Farbe mit der Nummer 8 ist hier eine Ausnahme, denn diese 
ist Grau. Zhlt man zu einer der Farben von 0 bis einschlielich 15 nun 16 
hinzu, erhlt 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 erklrt habe, 
wird es euch sicherlich leicht fallen. Hier nun die vollstndige Tabelle der 
Farbcodes: 
#PROGEIN
   0 Schwarz         8 Grau         16 Blink-Schwarz     24 Blink-Grau 
   1 Dunkelblau      9 Hellblau     17 Blink-D.-Blau     25 Blink-H.-Blau 
   2 Dunkelgrn     10 Hellgrn     18 Blink-D.-Grn     26 Blink-H.-Grn 
   3 Dunkelzyan     11 Hellzyan     19 Blink-D.-Zyan     27 Blink-H.-Zyan 
   4 Dunkelrot      12 Hellrot      20 Blink-D.-Rot      28 Blink-H.-Rot 
   5 Dunkelviolett  13 Hellviolett  21 Blink-D.-Violett  29 Blink-H.-Violett 
   6 Braun          14 Gelb         22 Blink-Braun       30 Blink-Gelb 
   7 Wei           15 Leucht-Wei  23 Blink-Wei        31 Blink-Leucht-Wei 
#PROGAUS
Wenn man eine Farbe fters verwendet, knnte man sie auch in einer Variablen 
speichern. Wird z.B. die Farbe Dunkelgrn fters bentigt, so knnte man ihren 
Farbcode der Variablen 'gruen' zuweisen. Statt 'COLOR 2' braucht man dann nur 
mehr 'COLOR gruen' zu schreiben. QBasic ersetzt dann whrend der Ausfhrung 
automatisch den Platzhalter 'gruen' durch den Wert 2. 
Man knnte auch einer Variablen 'hell' den 
Wert 8 und einer Variable 'blink' den Wert 16 zuweisen. Will man dann die 
Vordergrundfarbe auf Blink-Hellgrn 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.BAS', und deshalb speichern wir es unter 
'KURS0005.BAS'. 
#PROGEIN
blau = 1
gelb = 14
weiss = 7
hell = 8

COLOR , blau
CLS
 
COLOR hell + weiss
LOCATE 2, 2
PRINT "Wie lautet die erste Zahl";
COLOR gelb
INPUT zahl1

COLOR hell + weiss
LOCATE 5, 2
PRINT "Wie lautet die zweite Zahl";
COLOR gelb
INPUT zahl2

CLS
COLOR hell + weiss
LOCATE 2, 2
PRINT "Zahl 1:";
COLOR gelb
PRINT zahl1;

COLOR hell + weiss
LOCATE , 60
PRINT "Zahl 2:";
COLOR gelb
PRINT zahl2

COLOR hell + weiss
LOCATE 3, 1
PRINT "---------------------------------------------------------------------";
PRINT "-----------"

COLOR hell + weiss
LOCATE 5, 2
PRINT "Addition:";
COLOR gelb
LOCATE , 17
PRINT zahl1 + zahl2

COLOR hell + weiss
LOCATE 6, 2
PRINT "Subtraktion:";
COLOR gelb
LOCATE , 17
PRINT zahl1 - zahl2

COLOR hell + weiss
LOCATE 7, 2
PRINT "Multiplikation:";
COLOR gelb
LOCATE , 17
PRINT zahl1 * zahl2

COLOR hell + weiss
LOCATE 8, 2
PRINT "Division:";
COLOR gelb
LOCATE , 17
PRINT zahl1 / zahl2
#PROGAUS
In den Zeilen 6 und 7 wird gezeigt, da CLS den Bildschirm nicht immer schwarz 
macht, sondern ihn in der aktuellen Hintergrundfarbe ausfllt. Auerdem seht 
ihr, da ich in diesem Programm einige Leerzeilen eingefgt habe. Das dient 
schlicht und einfach dazu, da das Programm bersichtlicher wird. 
- Zur bersichtlichkeit ist es auch ntzlich, wenn man den Befehl REM 
einsetzt. Alles, was nach diesem Wort in derselben Zeile steht, wird 
ignoriert. Das dient vor allem zur Erluterung 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 einfaches Apostroph (') abgekrzt werden. Dann 
kann man ihn auch mitten in die Zeile hineinsetzen. In diesem Fall wird nur 
ab dieser Stelle die Ausfhrung unterbunden. 
Ein kleines Beispiel (KURS0006.BAS): 
#PROGEIN
'Variablenzuweisungen
blau = 1                         'Farbe Blau
gelb = 14                        'Farbe Gelb

'Hauptprogramm
COLOR gelb, blau                 'Farben whlen
CLS                              'Bildschirm lschen
PRINT "Hallo, Leute!"            'Text ausgeben
REM PRINT "Mieses Wetter heute!" 'Ausgeklammerter Befehl
PRINT "Schnes Wetter heute!"    'Text ausgeben
PRINT "Bis morgen!"              'Text ausgeben
#PROGAUS
Alles klar? 
PRINT lt sich brigens auch durch das Fragezeichen (?) abkrzen. Doch da 
dies nicht sehr gebruchlich ist, erwhnen wir es nur am Rande. 
- Nun zu der Musik. (ENDLICH!!!!) Fr diesen Teil ist es notwendig, da ihr 
wenigstens etwas im Musikunterricht aufgeschnappt habt. Die Notennamen mchte 
ich hier nicht noch einmal erklren! Alle Unmusikalischen knnen aber auch 
etwas Musik mit den Befehlen BEEP und SOUND erzeugen (in der Online-Hilfe 
nachlesen!). Kommen wir aber zum gebruchlisten Musikbefehl in QBasic: PLAY. 
Mit ihm kann der Programmierer "Klavier spielen". Die Noten mssen dazu aber 
in einer Zeichenkette vorliegen. Das Format ist zwar anfangs etwas 
ungewhnlich, aber da auch der mchtige Grafikbefehl DRAW ein hnliches Format 
verwendet, lohnt es sich, es zu lernen. Sehen wir uns dazu ein Beispiel an. 
#PROGEIN
'I want to be in America
'Coded by The Real Adok
'bersichtliche Version fr Basic-Kurs
PLAY "t120 l8 o4"
PLAY "g g g > c c c < l4 a f c"                   'Tempo 120, Achtel, Oktave 4
PLAY "l8 g g g > c c c l4 d < b g"                'Das Lied beginnt!
PLAY "l8 b- b- b- > e- e- e- l4 d < b- f"         'Weiter geht's!
PLAY "l8 e- e- e- a- a- a- l4 g > l8 e p8 < l4 c" 'Ende.
#PROGAUS
Klingt doch gut, oder? Dieses Listing habe ich schon frher 'mal im PCH 
verffentlicht. Allerdings war es dort etwas unbersichtlich und in der 
damaligen Version nicht so gut fr Erklrungen geeignet. 
Der erste PLAY-Befehl stellt das Tempo auf 120, die Notenlnge auf Achtel und 
die Oktave auf 4 ein. Man erkennt: Der Buchstabe 't' steht fr das Tempo, 
'l' fr die Notenlnge und 'o' fr die Oktave. Bei der Oktave mssen Zahlen 
angegeben werden, denn QBasic versteht sowas wie 'groe Oktave' oder 
'eingestrichene Oktave' nicht. 0 ist die tiefste und 7 die hchste Oktave. 
Standard ist 4. Das Tempo entspricht der Taktfrequenz des Metronoms und reicht 
theoretisch von 0 bis 255. Tatsache ist aber, da ein Tempo unter 32 nicht 
auszuhalten ist. Schlielich und endlich gibt die Zahl neben dem 'l', wie 
gesagt, die Notenlnge an. Wenn diese Zahl z.B. x ist, dann ist die 
Notenlnge 1/x (logisch, man will es dem Programmierer auch nicht zu 
kompliziert machen). 
Das waren die allgemeinen Vorbereitungen. Jetzt beginnt das eigentliche Lied! 
Natrlich lassen sich die Befehle, die wir im Vorbereitungsteil verwendet 
haben, auch noch jetzt verwenden. Allerdings kenne ich kaum Lieder, in denen 
das Tempo stndig gewechselt wird (auer in meinen eigenen :-) und denen von 
Bla Bartok)...! 
Noten werden durch Nennung ihres Namens gespielt. Hier haben wir 
beispielsweise gleich zu Anfang drei G's gespielt, die in der aktuellen 
Oktave im aktuellen Tempo und der aktuellen Notenlnge ertnen. Wichtig ist 
nur, da die englische Schreibweise benutzt wird, also berall dort, wo die 
Note H vorkommt, B geschrieben wird. Das ist die einzige nderung. 
Kreuz- und Be-Vorzeichen werden an die Note angehngt, und zwar steht 
'#' fr Kreuz und '-' fr Be. Das wre eigentlich alles, was ihr dazu braucht, 
um eure Lieder in QBasic umzusetzen. Hier noch eine Liste mit weiteren 
PLAY-Dingsbums (eigentlich sind es auch Befehle) wie '<' und '>'. 
#PROGEIN
 <........... eine Oktave tiefer 
 >........... eine Oktave hher 
  
 mf.......... spiele Musik im Vordergrund 
 mb.......... spiele Musik im Hintergrund (Einlesen der Noten ist zu langsam!) 
  
 ml.......... legato 
 ms.......... staccato 
 mn.......... normal 
  
 #........... Kreuz 
 -........... Be 
  
 lx.......... Notenlnge 1/x 
 tx.......... Tempo x 
 ox.......... Oktave x 
#PROGAUS
Falls euch unklar ist, was mit "Vordergrund" und "Hintergrund" gemeint ist: 
Wenn "Vordergrund" gewhlt wurde, wird whrend der Wiedergabe der Musik die 
Programmausfhrung angehalten und erst nachher wieder fortgesetzt. Dagegen 
arbeitet das Programm, wenn "Hintergrund" gewhlt wurde, weiter, whrend die 
Musik gespielt wird. Leider werden die Noten im "Hintergrund"-Modus zu 
langsam eingelesen, um eine echte Hintergrundmusik realisieren zu knnen. 
Nochmals zu den Notennamen: ALLE MSSEN NACH DER REGEL EINGEGEBEN WERDEN! 
Solche Spezialitten wie das Es versteht QBasic nicht. Habt ihr eigentlich 
schon 'mal versucht, 'c-' zu spielen? Da diese Note dem 'b' der vorigen 
Oktave entspricht, kapiert der Computer nicht! Fr ihn liegen Halbtne nur auf 
den schwarzen Tasten. 
Uff, das war 'ne Menge! Und weil's so schn ist, binden wir in unser Proggy 
noch Musik ein!!!! 
#PROGEIN
'DAS MEGARECHENPROGRAMM!!!!
'... aus The Real Adok's Way to QBASIC.


'+++ Variablenzuweisungen
blau = 1                                'Farbe Blau
gelb = 14                               'Farbe Gelb
weiss = 7                               'Farbe Wei
hell = 8                                'Zusatz fr Helligkeit


'+++ Hauptprogramm
COLOR , blau                            'Blauer Hintergrund
CLS                                     'Bildschirm lschen
 
COLOR hell + weiss                      'Eingabe der ersten Zahl
LOCATE 2, 2                             '
PRINT "Wie lautet die erste Zahl";      '
COLOR gelb                              '
INPUT zahl1                             '

COLOR hell + weiss                      'Eingabe der zweiten Zahl
LOCATE 5, 2                             '
PRINT "Wie lautet die zweite Zahl";     '
COLOR gelb                              '
INPUT zahl2                             '

CLS                                     'Bildschirm lschen
COLOR hell + weiss                      'Erste Zahl ausgeben
LOCATE 2, 2                             '
PRINT "Zahl 1:";                        '
COLOR gelb                              '
PRINT zahl1;                            '

COLOR hell + weiss                      'Zweite Zahl ausgeben
LOCATE , 60                             '
PRINT "Zahl 2:";                        '
COLOR gelb                              '
PRINT zahl2                             '

COLOR hell + weiss                      'Verzierungsstrichlein ausgeben
LOCATE 3, 1                             '
PRINT "-----------------------";        '
PRINT "-----------------------";        '
PRINT "-----------------------";        '
PRINT "-----------"                     '

COLOR hell + weiss                      'Ergebnis der Addition ausgeben
LOCATE 5, 2                             '
PRINT "Addition:";                      '
COLOR gelb                              '
LOCATE , 17                             '
PRINT zahl1 + zahl2                     '

COLOR hell + weiss                      'Ergebnis der Subtraktion ausgeben
LOCATE 6, 2                             '
PRINT "Subtraktion:";                   '
COLOR gelb                              '
LOCATE , 17                             '
PRINT zahl1 - zahl2                     '

COLOR hell + weiss                      'Ergebnis der Multiplikation ausgeben
LOCATE 7, 2                             '
PRINT "Multiplikation:";                '
COLOR gelb                              '
LOCATE , 17                             '
PRINT zahl1 * zahl2                     '

COLOR hell + weiss                      'Ergebnis der Division ausgeben
LOCATE 8, 2                             '
PRINT "Division:";                      '
COLOR gelb                              '
LOCATE , 17                             '
PRINT zahl1 / zahl2                     '
 
PLAY "t200 l8 o5 ddd p64 l2 g"          'Musik

'+++ Ende des Programms.
#PROGAUS
Das Programm ist mit seinen 3 KB eigentlich zum Abtippen schon gewaltig gro. 
Naja, solange dem PCH noch keine Disk/CD beiliegt (vielleicht gibt's einmal so 
viel Stuff, da eine zustandekommt, wre ja eine Idee), mt ihr wohl oder 
bel in den sauren Apfel beien. Man soll das aber von der praktischen Seite 
betrachten: Es ist eine gute Tippbung. Mir ist brigens auch aufgefallen, da 
man sich so die Befehle besser merkt, als wenn man sie nur liest und das 
Programm zum Beispiel von einer Diskette ladet. 
So, fr heute machen wir Schlu. Das Programm ist doch eigentlich toll 
aufgemacht! Nur noch Maussteuerung und eine menorientierte Benutzerfhrung 
wrden theoretisch durchaus gengen, da das Programm mit anderen 
SW-/FW-/PD-Proggys mithalten kann. Doch wer braucht schon so einfache 
Programme? Da wre doch etwas Komplexeres interessanter! Wir werden auch in 
einer der nchsten Lektionen gemeinsam ein kleines Adventure-Spiel in der Art 
von 'Die Reise zum Mond' erstellen. Die Optik ist zwar dort nicht das Wahre 
(OK, OK, ich gebe es endlich zu), aber fr den Anfang reicht es immerhin. 
Spter werde ich vielleicht noch einen Kurs zur Programmierung von 
professionellen Adventures in Power Basic machen. Darin werden dann die 
Techniken beschrieben, die ich im zweiten Teil der Reise zum Mond verwenden 
werde. Dies sind unter anderem: 
 - Maussteuerung unter Verwendung des Interrupts 33h, 
 - eigene Fonts im Grafikmodus, 
 - Soundblaster-Programmierung mit der Shareware-Library POW!, 
 - Einbinden von Grafiken aller mglichen Formate mit dem Graphics Workshop, 
 - Tips zum Optimieren der selbstgeschriebenen Programme. 
Selbstverstndlich gibt es zum Schlu ein kleines Beispiel-Adventure 
(Beispielspiel zu sagen wre doch bld) bei, wahrscheinlich ein kleiner 
Ausschnitt aus 'Die Reise zum Mond 1 Remix', das 'Die Reise zum Mond 2' 
beiliegen wird. Es ist im Grunde genommen nichts anderes als 'Die Reise zum 
Mond 1', aber mit viiiiiiiiel besserer Grafik und keinen ASCIIs. 
Aber bevor ich noch vom Thema abschweife, sollte ich lieber wirklich Schlu 
machen. Wenn 'Die Reise zum Mond 2' fertig ist, werdet ihr noch alles 
erfahren! 
Ach ja, Hausaufgaben: Die erlasse ich euch. Dafr sollt ihr viel mit den 
erlenten Befehlen, besonders mit PLAY, experimentieren. Nchstes Mal werde ich 
euch erzhlen, wie man sich in seinen eigenen Programmen auf Fehlersuche 
begeben kann, und wie QBasic und Quick Basic einen dabei untersttzen. Die 
Funktionen von Quick Basic sind glcklicherweise denen von Power Basic sehr 
hnlich. Ich habe mich entschlossen, in meinem Kurs doch Power Basic zu 
untersttzen, denn mittlerweile habe ich schon so viel Erfahrung damit, da 
ich mit Sicherheit sagen kann, da es die beste Basic-Programmiersprache fr 
den PC ist! Die Beispielprogramme in diesem Einsteigerkurs werden aber immer 
noch auf allen dreien luffhig sein. 
Noch ein kleines Nachwort: Mann, dieser Teil des Kurses ist umfangsreich. Aber 
ihr (und vor allem die Redax) werdet euch an so lange Teile gewhnen mssen. 
Eine zweimonatliche Erscheinungsweise ist jedenfalls verdammt viel fr die 
schnellebige PC-Szene! Ihr knnt die Wartepausen aber gut ntzen, um viel mit 
den neuen Befehlen zu experimentieren. Das wrde ich euch auch wrmstens 
empfehlen, denn in fast jedem Teil dieses Kurses kommt wieder eine Menge neuer 
Befehle vor! 
Jetzt endgltig Schlu mit diesem Teil von The Real Adok's Way to QBASIC 
(woher dieser Name wohl stammt?). 


                              ****************
                              ***  TEIL 4  ***
                              ****************
Willkommen zum vierten Teil von The Real Adok's Way to QBASIC! Diesmal wollen 
wir uns mit den Debugging-Mglichkeiten von Quick Basic und Power Basic 
beschftigen. Eigentlich htte dieser Teil schon viel frher kommen mssen, 
denn beim Lsen der Hausaufgaben knnen fters Fehler auftreten, die man 
beheben mu. Aber egal, here we go! 
Wer noch nie einen kleinen Programmfehler produziert hat, der werfe mit dem 
ersten Stein! Na, das wird aber lange dauern, bis der erste Stein geworfen 
wird! Beginnen wir also, indem wir selbst einen Fehler produzieren. Gebt 
folgende Programmzeile ein: 
#PROGEIN
LINE (100, 100) - (150, )
#PROGAUS
Den Befehl LINE werden wir brigens im Kapitel ber die Grafikprogrammierung 
noch nher kennenlernen. Es sei jetzt nur gesagt, da man mit ihm im 
Grafikmodus Linien zeichnen kann. 
Wenn wir jetzt zur Besttigung ENTER bettigen, meldet QBasic einen Fehler 
(Erwartet: Ausdruck). Wir haben nun zwei Mglichkeiten. Zum einen 
knnen wir uns eine wenig aufschlureiche Fehlererklrung ansehen, die jedoch 
zu kaum etwas nutze ist, weil es x Mglichkeiten gibt, dieselbe 
Fehlermeldung zu produzieren. Die andere Mglichkeit ist, in den Editor 
zurckzukehren, um dort den Fehler zu suchen und zu korrigieren. Wir whlen 
jetzt diese Mglichkeit. Da der Fehler whrend der Eingabe auftauchte, kann 
man daraus schlieen, da er sich in der gerade eingegebenen Programmzeile 
befinden mu. (Auerdem wird die Stelle, in der sich der Fehler befindet, 
ohnehin farblich hervorgehoben!) 
Die Kunst des Fehlerbehebens besteht nun darin, sich die 
Programmzeile noch einmal genau durchzulesen und bei den Befehlen und den 
Parametern zu prfen, ob man sich an alle Regeln hielt. Ihr kennt den Befehl 
LINE noch nicht und knnt daher auch nicht den Fehler feststellen. Deshalb 
verrate ich euch, was da falsch ist: Eine Zahl fehlt. Also schreibt 
zwischen den letzten Beistrich und die Klammer die Zahl '200'. 
So, das war die eine Mglichkeit, wo Fehler auftreten knnen: bei der 
Programmeingabe. Glcklicherweise berprfen QBasic und Quick Basic immer die 
aktuelle Zeile auf Eingabefehler, sobald man ENTER drckt, wodurch sich diese 
schneller feststellen lassen. Power Basic stellt diese Eingabefehler jedoch 
erst dann fest, nachdem man den Befehl zur Ausfhrung des Programms erteilte. 
Von den logischen Fehlern einmal abgesehen, die keine Programmiersprache 
feststellen kann und auf die wir spter zu sprechen kommen, sind Eingabefehler 
die hufigsten Fehler. Doch es knnen auch Laufzeitfehler, sprich Fehler 
whrend der Ausfhrung eines Programms, entstehen. QBasic-Benutzer sind hier 
besonders im Nachteil, weil QBasic nur ein Interpreter ist und im 
Gegensatz zu den Compilern einige Fehler erst whrend der Ausfhrung des 
jeweiligen Befehls entdeckt werden knnen. Eine hufige Art von 
Laufzeitfehlern entsteht, wenn man Grafikbefehle benutzt, ohne vorher in den 
Grafikmodus umgeschaltet zu haben (wozu der Grafikmodus dient, werden wir 
spter erfahren). Dies ist brigens auch bei unserem Einzeiler-Programm so. 
Also starten wir es, um diesen Laufzeitfehler zu produzieren. 
Wir erkennen, da Laufzeitfehler im Grunde genommen genauso wie Eingabefehler 
behandelt werden, nur mit dem Unterschied, da sich der Fehler nicht in der 
aktuellen Zeile befinden mu. Hier bentigen wir also etwas Logik, um 
herauszufinden, was nun falsch sei. Bei unserem Beispiel habe ich es ja schon 
verraten: Wir vergaen, vorher in den Grafikmodus umzuschalten. Dies knnen 
wir korrigieren, indem wir eine Zeile vor den LINE-Befehl einfgen und dort 
#PROGEIN
SCREEN 12
#PROGAUS
schreiben. Jetzt sieht das Programm folgendermaen aus: 
#PROGEIN
SCREEN 12
LINE (100, 100) - (150, 200)
#PROGAUS
Wenn wir es nun starten, erscheint eine nette, kleine Gerade auf dem 
Bildschirm. Hurra! Wir haben es geschafft! 
Die hufigste Fehlerart sind aber logische Fehler. Dies sind die aus vielen 
professionellen Anwendungen bekannten Bugs, wegen denen das Programm nicht 
immer tut, was der Benutzer will! Da bei diesen Fehlern die Befehle meist 
richtig geschrieben und den Regeln entsprechend angewendet werden, kann QBasic 
sie nicht finden. Abhilfe schaffen nur sorgfltiges Planen vor der 
eigentlichen Codierung und strukturiertes Programmieren. Wer mehr darber 
wissen will, soll sich meine Antwort auf eine Behauptung von Wstenfuchs 
durchlesen. Sie befindet sich im PCH 2/96. 
QBasic versucht aber, den Programmierer so weit wie mglich bei der Suche nach 
logischen Fehlern in seinen Programmen zu untersttzen. Dazu gibt's die 
Mglichkeit, mit F9 Haltepunkte einzufgen. Wenn das Programm nun mit F5 
gestartet wird, wird es nur bis zu der Zeile, in der der Haltepunkt gesetzt 
ist, ausgefhrt. Danach kehrt QBasic in den Editor zurck, wo man nun kleine 
nderungen und Fehlerkorrekturen durchfhren kann. Durch einen erneuten Druck 
auf F5 wird die Programmausfhrung von diesem Haltepunkt an bis zum nchsten 
fortgesetzt, whrend mit Shift und F5 gleichzeitig das Programm von Anfang an 
neu gestartet wird. 
Diese Haltepunkte sind besonders ntzlich in Kombination mit den erweiterten 
Debugging-Funktionen von Quick Basic und Power Basic. Dort kann man nmlich 
im Men Debug (QB) bzw. Debug - Watch (PB) die jeweils aktuellen Inhalte von 
Variablen stndig auf dem Bildschirm des Editors anzeigen. In Quick Basic 
heit die Menoption, die ihr whlen mt, 'Variable anzeigen', in Power 
Basic 'Add Watch'. Danach mt ihr den Namen der Variablen angeben, deren 
aktueller Wert stndig angezeigt werden soll. Schon erscheinen der Name der 
Variablen und der aktuelle Wert auf dem Bildschirm! Jetzt knnt ihr entweder 
das Programm starten oder mit dem Editieren fortfahren. Mit den anderen 
Befehlen im angegebenen Men lassen sich diese angezeigten Variablen wieder 
vom Bildschirm lschen. Die Variablen selbst werden dabei nicht aus dem 
Speicher gelscht!!! Ntzlich ist auch die Funktion 'Aktueller Wert anzeigen' 
von Quick Basic (in Power Basic mte es dazu auch ein quivalent geben; wie 
es heit, wei ich aber momentan nicht), die den aktuellen Wert der Variablen 
anzeigt, auf der sich der Cursor befindet. Mit einem Mausklick lt sich diese 
Variable dann in die Liste der zu anzeigenden Variablen aufnehmen. 
So, das wre alles, was ber die Debugging-Funktionen zu sagen wre. Da dieser 
Teil des Kurses sehr kurz geworden ist, und ich fr nchstes Mal sehr viel 
vorhabe, werde ich einen Befehl, den ich ursprnglich erst im nchsten Teil 
erklren wollte, schon hier besprechen. Es ist ein Befehl, der etwas aus der 
Reihe fllt. Auerdem ist er unser erster Block-Befehl, was heien soll, da 
er eigentlich aus zwei Befehlen besteht. Bei dem Befehl handelt es sich 
konkret - tatatata - um DO/LOOP. Wir haben ihn schon frher einmal in einem 
Beispielprogramm kennengelernt. Er ist brigens einer der vielseitigsten 
Befehle, die es gibt (diesmal auf ALLE Programmiersprachen bezogen). Als 
"nackter" Befehl ohne Parameter, bedeutet er, da der Programmteil zwischen 
den beiden Schlsselwrtern DO und LOOP unendlich oft wiederholt wird. Man 
nennt dies eine Endlosschleife. Solche Endlosschleifen sind nicht besonders 
ratsam, weil man sie nur durch gleichzeitiges Drcken von STRG und PAUSE 
abbrechen kann - wenn berhaupt. Aber keine Angst, bei QBasic funktioniert es 
(fast) immer! Bei Power Basic ist das wieder etwas anderes, weil dieses keine 
Programme in der Vorgangsweise eines Interpreters bersetzen kann, sondern nur 
wie ein Compiler. Compiler sind meistens sowieso besser, aber das ist ein 
anderes Thema. Unser kleines Experiment, das jetzt folgen wird, mte auch in 
Power Basic kein Problem sein: 
#PROGEIN
'Endlosschleife, kann nur mit STRG und PAUSE abgebrochen werden!

COLOR 14, 9
CLS
DO                                'Anfang der Schleife.
 PRINT "Hallo, Leute!"
 PRINT "Hi, PC-Heimwerker!"
 PRINT "Viele Gre von QBASIC!"
 Stopper = TIMER                   'Kleine Stoppschleife, weil das ganze
 DO                                'sonst zu schnell wird.
 LOOP UNTIL TIMER > Stopper + .5
LOOP                              'Ende der Schleife.
#PROGAUS
So, nehmen wir dieses zwlfzeilige Proggy genauer unter die Lupe. 'Schleife' 
ist brigens eine Bezeichnung fr eine spezielle Art von Blcken, zu denen 
auch DO/LOOP gehrt. In der dritten Zeile wird die Farbkombination gewhlt, in 
der vierten der Bildschirm gelscht. Die fnfte Zeile beinhaltet jetzt den 
neuen Befehl: DO. Er setzt den Beginn der Schleife. Die Zeilen 6 bis 11 
beinhalten den eigentlichen Code, der unendlich oft ausgefhrt wird. Ich habe 
diese Zeilen zugunsten der bersicht eingerckt. Man sollte sich angewhnen, 
bei Blcken immer den eigentlichen Code zwischen Blockanfang und Blockende 
einzurcken, weil es sonst sehr schnell unbersichtlich wird. In der 
Schleife befindet sich auerdem eine weitere Schleife, die eine markante 
Eigenschaft von Blcken aufweist: Sie lassen sich ineinander verschachteln. 
Das innerste LOOP gehrt zum innersten DO, das zweitinnerste LOOP zum 
zweitinnersten DO usw. bis zum uersten LOOP, das zum uersten DO gehrt. 
Theoretisch kann man Blcke unendlich oft verschachteln! Hier haben wir 
allerdings nur zwei "Ebenen" verwendet. Das innere LOOP gehrt zum inneren DO, 
das uere LOOP zum ueren DO. Was UNTIL und TIMER bedeuten, braucht ihr 
noch nicht zu wissen (UNTIL wird schon bald erklrt), jedenfalls sei gesagt, 
da die innere Schleife dazu dient, zwischen den einzelnen Textausgaben eine 
kleine Pause zu machen. Das LOOP in Zeile 12 schlielich veranlat QBasic, 
zurck in die Zeile 5 mit DO zu springen. Da dort keine Abbruchsbedingungen zu 
finden sind, wird der Code innerhalb der Schleife wiederholt ausgefhrt. Dann 
kommt QBasic wieder zu LOOP, springt nach DO, fhrt den Code innerhalb der 
Schleife aus usw. 
Was hat es nun mit diesem UNTIL auf sich? Die Schlsselwrter UNTIL und WHILE 
knnen nach DO oder LOOP stehen und geben eine Abbruchsbedingung an. Wenn bei 
UNTIL diese erfllt ist, wird die DO/LOOP-Schleife abgebrochen und der nchste 
Befehl nach LOOP ausgefhrt. Bei WHILE ist das ganze umgekehrt: Wenn 
die Bedingung NICHT erfllt ist, wird die Schleife abgebrochen, ansonsten wird 
die Ausfhrung fortgesetzt. Da ein Beispiel mehr sagt als tausend Worte, hier 
eine kleine Anwendung fr UNTIL. Sie zhlt von 0 bis auf 10 hinauf und gibt 
dabei die Zahl und einen Text aus. Mittlerweile sind wir brigens schon bei 
unserem zehnten Beispielprogramm angelangt. JUBILUM!!!! 
#PROGEIN
'Zhlschleife

COLOR 14, 1
CLS

Zaehler = 0
DO
 PRINT "Schleife wird zum"; Zaehler; ". Mal durchlaufen."
 Zaehler = Zaehler + 1
LOOP UNTIL Zaehler = 10
PRINT "Wert des Schleifenzhlers ist"; Zaehler; "=> PROGRAMMABBRUCH."
#PROGAUS
Das Interessante beginnt ab Zeile 6. Dort wird der Schleifenzhler auf 0 
gesetzt. Eigentlich unwichtig, weil alle Zahlenvariablen vor einer Zuweisung 
0 enthalten, doch zur bersichtlichkeit machen wir es hier. Danach wird mit 
DO der Schleifenkopf eingeleitet. Hier ist nichts Neues dazugekommen. In der 
achten Zeile wird nun ausgegeben, zum wievielten Mal die Schleife 
durchlaufen wird. Eigentlich ist das etwas unlogisch, weil beim ersten 
Schleifendurchlauf ausgegeben wird, da die Schleife zum nullten Mal 
durchlaufen wird! Aber das knnt ihr ja selbst SEHR einfach auf zwei Arten 
ndern. Wie, das mchte ich nicht verraten. Macht es doch als Hausbung! In 
der neunten Zeile wird der Schleifenzhler um 1 erhht. Und jetzt kommt's! In 
der zehnten Zeile wird noch zustzlich neben LOOP das Schlsselwort UNTIL 
verwendet. 'Zaehler = 10' ist nun so ein Vergleich, wie wir in der nchsten 
Folge beim IF/THEN/ELSE/ENDIF-Block viele kennenlernen werden. Dieser hier 
fragt ab, ob der Inhalt der Variablen Zaehler gleich 10 ist. Wenn ja, dann 
wird die Schleife abgebrochen und die PRINT-Anweisung, die sich in der elften 
Zeile befindet, ausgefhrt. Ansonsten wird das ganze nach DO verzweigt, und 
die Schleife wird erneut ausgefhrt. Diesmal ist jedoch die Variable Zaehler 
schon um 1 grer als beim letzten Durchlauf. Nun wird ausgegeben, da die 
Schleife das erste Mal durchlaufen werde (flschlicherweise, wie wir wissen) 
und das ganze geht weiter, bis der Zhler auf 10 erhht wird. Dann wird die 
Schleife abgebrochen, und wir kommen zur abschlieenden Textausgabe. Diese 
Art der Zhlschleife ist schon etwas aufwendig. Nchstes Mal werden wir die 
auf Zhlaufgaben spezialisierte FOR/NEXT-Schleife kennenlernen. Auerdem 
werden wir mit dem IF/THEN/ELSE/ENDIF-Block unsere Variablen auf bestimmte 
Inhalte berprfen. Mit diesen Kenntnissen knnten wir dann schon ein 
einfaches Adventure-Spiel erstellen, das wir in Teil 6 besprechen werden. 
Interessiert? Dann besorgt euch den nchsten PC-Heimwerker! Zum Abschlu noch 
einmal die Zhlschleife, diesmal mit WHILE (viel komplizierter): 
#PROGEIN
'Zhlschleife, Version mit WHILE

COLOR 14, 1
CLS

Zaehler = 0
DO
 PRINT "Schleife wird zum"; Zaehler; ". Mal durchlaufen."
 Zaehler = Zaehler + 1
LOOP WHILE Zaehler < 10
PRINT "Wert des Schleifenzhlers ist"; Zaehler; "=> PROGRAMMABBRUCH."
#PROGAUS
Und nicht vergessen: Schn brav mit den erlernten Befehlen experimentieren und 
immer die Hausaufgaben erledigen! Wir sehen einander im nchsten Teil von 
The Real Adok's Way to QBASIC. 


                              ****************
                              ***  TEIL 5  ***
                              ****************
Willkommen in der fnften Folge von The Real Adok's Way to QBASIC! Gleich als 
erstes zu den Hausaufgaben, die im Prinzip mit etwas logischem Denken leicht 
zu lsen waren. Es gibt zwei Mglichkeiten, um den Schleifenzhler am Anfang 
auf 1 und nicht auf 0 zu setzen. Die naheliegendere ist, bei der Zuweisung 
vor der Schleife ganz einfach 0 in 1 zu verndern. Das Listing sieht dann 
folgendermaen aus: 
#PROGEIN
'Zhlschleife

COLOR 14, 1
CLS

Zaehler = 1
DO
 PRINT "Schleife wird zum"; Zaehler; ". Mal durchlaufen."
 Zaehler = Zaehler + 1
LOOP UNTIL Zaehler = 10
PRINT "Wert des Schleifenzhlers ist"; Zaehler; "=> PROGRAMMABBRUCH."
#PROGAUS
Na, war doch ganz einfach! Es gibt aber noch eine zweite, nicht ganz so 
naheliegende Mglichkeit: Man kann den Befehl mit der Erhhung des 
Schleifenzhlers gleich hinter DO zu schreiben! Das sieht dann so aus: 
#PROGEIN
'Zhlschleife

COLOR 14, 1
CLS

Zaehler = 0
DO
 Zaehler = Zaehler + 1
 PRINT "Schleife wird zum"; Zaehler; ". Mal durchlaufen."
LOOP UNTIL Zaehler = 10
PRINT "Wert des Schleifenzhlers ist"; Zaehler; "=> PROGRAMMABBRUCH."
#PROGAUS
Diese Variante hat allerdings eine Besonderheit: Wenn wir das Programm 
starten, erkennen wir, da die Schleife nun auch ein zehntes Mal durchlaufen 
wird. Man sollte sich auch beim Coden in der Praxis klar sein, da es unter 
Umstnden zu anderen Ergebnissen fhrt, wenn man eine Wertzuweisung - und das 
ist eine Werterhhung im Grunde genommen auch - an den Anfang der Schleife 
schreibt, als wenn sie am Ende steht! Es ist oft wichtig, diesen Umstand zu 
kennen. 
So, jetzt mchte ich euch noch kurz die FOR/NEXT-Schleife zeigen. Hier gleich 
ein Beispielprogramm: 
#PROGEIN
'Zhlschleife mit FOR/NEXT

COLOR 14, 1
CLS

FOR Zaehler = 1 TO 10 STEP 1
 PRINT "Schleife wird zum"; Zaehler; ". Mal durchlaufen."
NEXT
PRINT "Wert des Schleifenzhlers ist"; Zaehler; "=> PROGRAMMABBRUCH."
#PROGAUS
Wie ihr seht, erspart das Verwenden der FOR/NEXT-Schleife eine Menge 
Schreibart. Die 6. Zeile ist der Schleifenanfang (wie DO) und die 8. das 
Schleifenende (wie LOOP). In der 6. Zeile wird angegeben, da die Variable 
Zaehler als Schleifenzhler verwendet werden soll. Der Startwert soll 1 und 
der Endwert 10 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 Schleifenzhler auf den 
Startwert gesetzt. Danach werden alle Befehle zwischen FOR und NEXT 
ausgefhrt. NEXT erhht nun den Schleifenzhler um die Schrittweite. Wenn der 
Schleifenzhler gleich oder grer dem Endwert ist, dann wird die Schleife 
abgebrochen und der nchste Befehl ausgefhrt. Ansonsten wird zu FOR 
zurckgesprungen und die Befehle zwischen FOR und NEXT erneut ausgefhrt. Ihr 
seht, das ganze verhlt sich so hnlich wie DO/LOOP. Auch Verschachtelung ist 
mglich. Sogar verschiedenartige Schleifenarten lassen sich verschachteln! 
Das gilt auch fr 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 erfllt ist, wird der Programmteil zwischen 
THEN und ENDIF ausgefhrt. 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 mglichen 
Varianten. 
#PROGEIN
'Vergleiche

COLOR 14, 1
CLS

PRINT "Gib eine Zahl ein!"
INPUT Zahl

PRINT "Diese Zahl erfllt folgende Bedingungen:"
IF Zahl < 100 THEN
 PRINT "Sie ist kleiner als 100."
END IF
IF Zahl <= 100 THEN
 PRINT "Sie ist kleiner oder gleich 100."
END IF
IF Zahl = 100 THEN
 PRINT "Sie ist gleich 100."
END IF
IF Zahl >= 100 THEN
 PRINT "Sie ist grer oder gleich 100."
END IF
IF Zahl > 100 THEN
 PRINT "Sie ist grer als 100."
END IF
#PROGAUS
Jetzt mten die meisten Vergleichoperatoren klar sein. Grer-oder-Gleich und 
Kleiner-oder-Gleich werden zwar nur bei Fliekommaoperationen bentigt (und 
auch da nicht so oft), doch der Vollstndigkeit zuliebe listete ich sie auch 
auf. 
Dann gibt es da noch so nette kleine Befehle wie AND, OR usw. Mit ihrer Hilfe 
lassen sich mehrere Bedingungen miteinander verketten. Wenn zwei Bedingungen 
mit AND verknpft werden, wird der zwischen THEN und ENDIF stehende Code nur 
dann abgearbeitet, wenn BEIDE Bedingungen erfllt sind. Richtig, das lt sich 
auch durch zwei verschachtelte IF/THEN/ELSE/ENDIF-Blcke realisieren! Auerdem 
werden verschachtelte Blcke etwas schneller abgearbeitet als 
AND-Verknpfungen, weshalb von letzteren eher abzuraten ist. OR macht schon 
mehr Sinn. Hier wird der Code hinter THEN schon dann abgearbeitet, wenn 
mindestens eine Bedingung erfllt ist. XOR bedeutet woviel wie 
'Entweder-Oder'. Nomen est Omen! Der hinter THEN stehende Code wird hier nur 
ausgefhrt, wenn NUR EINE Bedingung erfllt ist. Wenn beide oder gar keine 
erfllt sind, springt QBasic zu dem Befehl nach ENDIF. 
Um das ganze zu demonstrieren, wieder ein Beispielprogramm: 
#PROGEIN
'Vergleiche mit AND, OR und XOR

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 erfllt:"
IF Zahl1 = 100 OR Zahl2 = 100 THEN
 PRINT "Mindestens eine der beiden Zahlen ist 100."
END IF
IF Zahl1 = 100 AND Zahl2 = 100 THEN
 PRINT "Beide Zahlen sind 100."
END IF
IF Zahl1 = 100 XOR Zahl2 = 100 THEN
 PRINT "Genau eine der beiden Zahlen ist 100."
END IF
IF Zahl1 <> 100 AND Zahl2 <> 100 THEN
 PRINT "Keine der beiden Zahlen ist 100."
END IF
#PROGAUS
Ach ja, 'Ungleich' wird in QBasic wie '<>' geschrieben. Das hatte ich 
vergessen, euch zu sagen. 
Wozu ist nun der ELSE-Zweig gut? Normalerweise wird, wenn die Bedingung nicht 
erfllt ist, die Programmausfhrung direkt beim nchsten Befehl hinter ENDIF 
fortgesetzt. Kommt nun ein ELSE-Zweig vor, wird bei einer nicht erfllten 
Bedingung zuerst der Code zwischen ELSE und ENDIF ausgefhrt! (Bei einer 
erfllten Bedingung wird dann nur der Code zwischen THEN und ELSE ausgefhrt.) 
Das ganze lt sich mit Worten ziemlich schwer erklren, doch in Wirklichkeit 
ist es berhaupt nicht kompliziert. Am besten, wir nehmen wieder ein 
Beispielprogramm zur Hand (schon KURS0015.BAS!). 
#PROGEIN
'Vergleiche mit ELSE

COLOR 14, 1
CLS

PRINT "Gib eine Zahl ein!"
INPUT Zahl1

PRINT "Gib eine zweite Zahl ein!"
INPUT Zahl2

PRINT
IF Zahl1 = Zahl2 THEN
 PRINT "Die beiden Zahlen sind identisch."
ELSE
 PRINT "Die beiden Zahlen sind NICHT identisch."
END IF
#PROGAUS
Zum Spa habe ich dieses Programm optimiert. Die optimierte Version ist zwar 
zum Verstndnis dieses Kurses nicht notwendig, knnte aber sehr interessant 
sein. 
#PROGEIN
'Vergleiche mit ELSE

COLOR 14, 1
CLS

PRINT "Gib eine Zahl ein!"
INPUT Zahl1

PRINT "Gib eine zweite Zahl ein!"
INPUT Zahl2

PRINT
PRINT "Die beiden Zahlen sind ";
IF Zahl1 <> Zahl2 THEN
 PRINT "NICHT ";
END IF
PRINT "identisch."
#PROGAUS
Das wre jetzt der IF/THEN/ELSE/ENDIF-Block. Wie gesagt, lt er sich wie alle 
Blcke verschachteln. Diese Verschachtelung ist auch EXTREM wichtig fr 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 prfen will, ist dieser Block 
wesentlich besser geeignet als ein IF/THEN/ELSE/ENDIF-Block. Wo sonst 
'IF ... THEN' steht, mu man 'SELECT CASE Variable' schreiben. 'Variable' 
steht hier fr 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. Es lassen sich auch mehrere, durch Beistriche getrennte Werte, 
neben CASE angeben, was dann soviel wie eine OR-Verknpfung bedeutet. Ist nun 
die Variable gleich einem der neben CASE angegebenen Werte, so wird der Code 
hinter CASE ausgefhrt, bis zum nchsten CASE. Ansonsten wird gleich zum 
nchsten CASE gesprungen. Abgeschlossen wird der SELECT/CASE-Block mit 
END SELECT. 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. 
#PROGEIN
'Einfaches Adventure-Spiel mit SELECT/CASE

COLOR 14, 1
CLS

PRINT "Willkommen zum Mysterious QBASIC Adventure. Du mut immer die Zahl"
PRINT "eingeben, die neben der gewhlten Option steht. 'aT' steht fr"
PRINT "eine beliebige andere Taste."
PRINT
PRINT "Du stehst vor einem Schlo. Wagst Du Dich, es zu betreten?"
PRINT
PRINT "  ( 1)  Ja"
PRINT "  (aT)  N"
PRINT

LINE INPUT Eingabe$
CLS
SELECT CASE Eingabe$
 CASE "1"
  PRINT "Jetzt bist Du im Schlo. Du hast die Wahl, ob Du nach Westen oder"
  PRINT "nach Osten gehst. Natrlich kannst Du auch das Schlo verlassen"
  PRINT "(Feigling!) Wofr entscheidest Du Dich, oh edler Ritter?"
  PRINT
  PRINT "  ( 1)  Westen"
  PRINT "  ( 2)  Osten"
  PRINT "  (aT)  Schlo verlassen"
  PRINT
  LINE INPUT Eingabe$
  CLS
  SELECT CASE Eingabe$
   CASE "1"
    PRINT "Da ist ein bser 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, fllst Du in einen"
    PRINT "bodenlosen Abgrund! Und wenn er nicht gestorben ist, dann fllt er"
    PRINT "noch heute. Ende."
    END
   CASE ELSE
    PRINT "Kaum hast Du das Schlo verlassen, fllt das Tor hinter Dir zu. Du"
    PRINT "hast Deine Chance vertan, denn 'rein kannst Du nimmer! Ende."
    END
  END SELECT
 CASE ELSE
  PRINT "Na gut, dann nicht. Starte lieber Excel und erledige langweilige"
  PRINT "Tabellenkalkulationen! Ende."
END SELECT
#PROGAUS
Hier wird auch die Verschachtelung demonstriert. CASE ELSE 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. 
#PROGEIN
'Einfaches Adventure-Spiel mit IF/THEN/ELSE/ENDIF 

COLOR 14, 1
CLS

PRINT "Willkommen zum Mysterious QBASIC Adventure. Du mut immer die Zahl"
PRINT "eingeben, die neben der gewhlten Option steht. 'aT' steht fr"
PRINT "eine beliebige andere Taste."
PRINT
PRINT "Du stehst vor einem Schlo. Wagst Du Dich, es zu betreten?"
PRINT
PRINT "  ( 1)  Ja"
PRINT "  (aT)  N"
PRINT

LINE INPUT Eingabe$
CLS
IF Eingabe$ = "1" THEN
 PRINT "Jetzt bist Du im Schlo. Du hast die Wahl, ob Du nach Westen oder"
 PRINT "nach Osten gehst. Natrlich kannst Du auch das Schlo verlassen"
 PRINT "(Feigling!) Wofr entscheidest Du Dich, oh edler Ritter?"
 PRINT
 PRINT "  ( 1)  Westen"
 PRINT "  ( 2)  Osten"
 PRINT "  (aT)  Schlo verlassen"
 PRINT
 LINE INPUT Eingabe$
 CLS
 IF Eingabe$ = "1" THEN
  PRINT "Da ist ein bser 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
 END IF
 IF Eingabe$ = "2" THEN
  PRINT "Oh, Du armer Held. Kaum gehst Du nach Osten, fllst Du in einen"
  PRINT "bodenlosen Abgrund! Und wenn er nicht gestorben ist, dann fllt er"
  PRINT "noch heute. Ende."
  END
 ELSE
  PRINT "Kaum hast Du das Schlo verlassen, fllt das Tor hinter Dir zu. Du"
  PRINT "hast Deine Chance vertan, denn 'rein kannst Du nimmer! Ende."
  END
 END IF
ELSE
 PRINT "Na gut, dann nicht. Starte lieber Excel und erledige langweilige"
 PRINT "Tabellenkalkulationen! Ende."
END IF
#PROGAUS
Wie man sieht, ist das Listing zwar etwas krzer, aber komplizierter! 
Letztendlich bleibt aber dem Programmierer berlassen, ob er SELECT/CASE oder 
IF/THEN/ELSE/ENDIF verwendet. Ich persnlich bevorzuge SELECT/CASE. 
Nchstes Mal werden wir nher auf die Programmierung von Adventures eingehen. 
Es sollten sich aber auch Leute, die mit Spielen nichts am Hut haben, die 
nchste Folge besorgen, weil wir einige Techniken kennenlernen, die auch in 
anderen Programmieraufgaben ntzlich sein knnen. Bis zur nchsten Ausgabe! 


                              ****************
                              ***  TEIL 6  ***
                              ****************
Willkommen zum sechsten Teil von The Real Adok's Way to QBASIC! Diesmal geht 
es hauptschlich um das Erstellen einfacher Adventures. Wenn ihr alle 
brav mitgelernt habt, erfllt ihr jetzt schon alle Voraussetzungen, um 
kreativ zu sein! Wir werden zustzlich noch einige neue Techniken 
kennenlernen, die auch in anderen Programmieraufgaben ntzlich sein knnen. 
Wenn man ein Adventure erstellen will, sollte man sich zunchst 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 
Eingriffsmglichkeiten so gro, da das ganze zu einem Spiel wird. Programme 
mit weniger Eingriffsmglichkeiten nennen sich interaktive Filme. Die meisten 
von ihnen sind so primitiv, da man nur ab und zu eine Richtungstaste drcken 
und hoffen darf, da sie die richtige war! 
Unser erstes Spiel soll etwas mehr Eingriffsmglichkeiten als interaktive 
Filme, aber weniger als professionelle Adventures, bieten. Oft werden in 
Adventures Gegenstnde benutzt. Diese knnen wir in Variablen speichern. Wenn 
die jeweilige Variable 1 ist, dann besitzt die Person den Gegenstand, wenn sie 
0 ist, dann nicht. Man knnte 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 (hchstens die des Arbeitsspeichers)! 
Wie bereits im Beispiel aus der vorigen Folge gezeigt wurde, werden die 
Auswahlsmglichkeiten mit PRINT angezeigt. Danach wird die Wahl eingegeben und 
mit SELECT/CASE ausgewertet. Um die Eingabe wenigstens etwas komfortabler zu 
gestaltet (Maussteuerung kommt dann im Spezial-Kurs fr Spiele-Programmierer 
in Power Basic), ordnen wir jeder bis auf die letzte Auswahlsmglichkeit eine 
Zahl zu. Der Benutzer mu dann nur die Zahl, die der gewnschten 
Auswahlsmglichkeit zugeordnet ist, eingeben. Fr die letzte 
Auswahlsmglichkeit kann dann jede beliebige andere Zahl oder Zeichenkette 
eingegeben werden. 
Da LINE INPUT hier geradezu verschwenderisch als Eingabebefehl ist (immerhin 
mu nur ein Zeichen eingegeben werden), benutzen wir einen anderen, sehr 
praktischen Befehl. Eigentlich ist er kein Befehl, sondern eine Funktion. Den 
Unterschied zwischen Befehlen und Funktionen werden wir in Folge 10 genauer 
definieren. Hier sei nur gesagt, da Funktionen normalerweise wie 
Wertzuweisungen behandelt werden. Man kann sie aber auch mit einem Befehl 
kombinieren, z.B. wre 'PRINT INKEY$' durchaus mglich. INKEY$ werden wir erst 
viel spter lernen, es ist aber auch eine Funktion. Die Funktion, die wir 
jetzt besprechen, heit INPUT$. Die Syntax lautet 
#PROGEIN
Zeichenkettenvariable$ = INPUT$(AnzahlZeichen)
#PROGAUS
Da wir bei Adventures den Anwender immer nur ein Zeichen eingeben lassen, 
bentigen wir die Form 
#PROGEIN
Eingabe$ = INPUT$(1)
#PROGAUS
(Jetzt mte eigentlich ein Punkt kommen, aber normalerweise schreibt man 
keine Satzzeichen am Anfang einer neuen Zeile!) Die Funktion INPUT$(1) wartet 
nun, bis der Benutzer eine Zahl oder ein Zeichen eingibt und speichert dieses 
danach in der Variablen Eingabe$. Praktischer Nebeneffekt: Im Gegensatz zu 
INPUT und LINE INPUT wird weder der Cursor noch die Eingabe auf dem 
Bildschirm angezeigt, auer, wenn es durch eine spezielle Funktion des 
LOCATE-Befehls eingestellt wurde (siehe Online-Hilfe). Deshalb eignet sich 
INPUT$(1) auch gut, wenn man den Benutzer auffordert, eine beliebige Taste zu 
drcken, um fortzusetzen (so, wie es QBasic am Ende jeder 
Programmausfhrung tut). Von SLEEP rate ich dezent ab, weil die Eingabe dann 
im Tastaturpuffer gespeichert wird und dann fr die nchste Eingabe bernommen 
wird. 
Auch die SLEEP-Warteschleifen sind mies, weil sich erstens nur ganze Sekunden 
angeben lassen und sie mit einem beliebigen Tastendruck abgebrochen werden 
knnen. Also beachtet diesen Befehl, den sich sicherlich schon einige aus der 
Online-Hilfe "herausgepickt" haben, nicht! 
Weiters mssen wir bei Adventures oft im Programm "springen". Wenn wir z.B. 
ein Haus betreten und es spter wieder verlassen, mu zu der Stelle, wo wir 
vor dem Haus stehen, gesprungen werde. Auf die Gefahr hin, da ich mich jetzt 
unbeliebt mache (vor allem wegen meiner Aussagen ber die strukturierte 
Programmierung, die zu dem, was jetzt kommt, widersprchlich sind): Am 
einfachsten sind solche Sprnge mit dem berhmt-berchtigten Befehl GOTO 
realisierbar. Dazu mu zuerst ein sogenanntes Label definiert werden, zu dem 
GOTO dann springen kann. Ein Label besteht aus einer Zeichenkette, diesmal 
aber ausnahmsweise nicht in Anfhrungszeichen eingeschlossen, und einem 
Doppelpunkt. Es mu in einer eigenen Zeile stehen. Nach GOTO mu als 
Parameter der Name des Labels angegeben werden, denn es lassen sich natrlich 
auch mehrere Labels benutzen. Allerdings mssen die dann auch verschiedene 
Namen haben! (Ich wei aus eigener Erfahrung, da vieles, was 
fr mich heute selbstverstndlich ist, fr Anfnger unntig kompliziert sein 
kann. Deshalb erklre 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. 
#PROGEIN
'Die Reise zum Mond
'Stark gekrzte Version fr The Real Adok's Way to QBASIC

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 gekrzte Version fr The Real Adok's Way to QBASIC"
a$ = INPUT$(1)
CLS
PRINT "Clausi, Stefan, Philipp, Franzi, Gerhard, Marius, Zahra und Nele ";
PRINT "wollen gemeinsam auf den Mond fliegen! ";
PRINT "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 ";
PRINT "ist,"
PRINT "sondern der Antrieb. ";
PRINT "Er funktioniert so: Gerhard hngt sich an das Raumschiff"
PRINT "an und lt sich von Zahra fttern. ";
PRINT "Je mehr er (fr)it, desto mehr - pardon -"
PRINT "Abgase lt er. Und diese Abgase treiben das Raumschiff an!"
a$ = INPUT$(1)
CLS
PRINT "Nochmals fr 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"
a$ = INPUT$(1)
CLS
PRINT "Du bernimmst die Rolle von Clausi, dem Kommandanten. ";
PRINT "Du und deine Besatzung"
PRINT "sind schon sehr lange (seit einer Minute!) im Weltraum mit dem ";
PRINT "Schiff unter - "
PRINT "wegs. ";
PRINT "Deine Aufgabe ist es, dich und deine Besatzung sicher zum Mond zu ";
PRINT "bringen. "
PRINT "Einfach? ";
PRINT "Ja, so klingt es. ";
PRINT "Ist es aber nicht..."
a$ = INPUT$(1)

'Das Spiel beginnt!
HaupthalleStart:
 CLS
 PRINT "Du bist nun in der Haupthalle des Astrein-Shuttles. Von hier aus kannst du"
 PRINT "alle Rume des Raumschiffs erreichen und das Raumschiff sogar verlassen."
 PRINT "Bevor du letzteres tust, rate ich dir, die notwendige"
 PRINT "Ausrstung zu holen..."
 GOSUB Eingabe
 CLS
 SELECT CASE eingab$
  CASE "1"
   PRINT "Es ist niemand da, mit dem du sprechen knntest!"
  CASE "2"
HheRetry1:
   PRINT "Was willst du betrachten?"
   PRINT "  (1) Die Tren"
   PRINT "  (2) Den Raum"
   PRINT "  (3) Die Luft"
   PRINT "  (4) Das Schild"
   e1$ = INPUT$(1)
   CLS
   SELECT CASE e1$
    CASE "1"
     PRINT "Es sind fnf groe Tren, die durch ein Laserfeld geschlossen ";
     PRINT "sind. Berhrt"
     PRINT "man das Laserfeld, so wird es automatisch deaktiviert."
    CASE "2"
     PRINT "Ein groer, leerer Raum, der Haupthalle genannt wird. An den ";
     PRINT "Wnden kleben"
     PRINT "alte Butterbrote, und die fnf Tren werden durch ein Laserfeld ";
     PRINT "geschlossen. "
     PRINT "Wenn man diesen Raum mit einem bestimmten Klassenraum des ";
     PRINT "Goethe-Gymnasiums vergleicht, so ist eine gewisse hnlichkeit ";
     PRINT "erkennbar. "
    CASE "3"
     PRINT "Das Sehorgan behauptet, sie wre ein transparentes Nichts. Das ";
     PRINT "Geruchs- und"
     PRINT "das Atmungsorgan wissen es allerdings besser."
    CASE "4"
     PRINT "Auf ihm steht 'EXIT'. Offensichtlich fhrt es zum Ausgang ";
     PRINT "dieses Raumschiffs."
     PRINT "Das solltest du, der Erbauer dieses Raumschiffs, eigentlich am ";
     PRINT "besten wissen!"
    CASE ELSE
     GOTO HheRetry1
   END SELECT
  CASE "3"
HheRetry2:
   PRINT "Was willst du nehmen?"
   PRINT "  (1) Laserfeld"
   PRINT "  (2) Butterbrot"
   e1$ = INPUT$(1)
   CLS
   SELECT CASE e1$
    CASE "1"
     PRINT "Bist du lebensmde oder was!? Wenn du so weitermachst, wirst du ";
     PRINT "das Spiel nie"
     PRINT "schaffen!"
    CASE "2"
     PRINT "Igitt! Dieses grausame, an der Wand klebende, mit Butter ";
     PRINT "verzierte Brot ist"
     PRINT "ekelerregend! La es lieber kleben!"
    CASE ELSE
     GOTO HheRetry2
   END SELECT
  CASE "4"
HheRetry3:
   PRINT "Wohin willst du gehen?"
   PRINT "  (1) Tr 1"
   PRINT "  (2) Tr 2"
   PRINT "  (3) Tr 3"
   PRINT "  (4) Tr 4"
   PRINT "  (5) Tr 5"
   e1$ = INPUT$(1)
   CLS
   SELECT CASE e1$
    CASE "1", "2", "4"
     PRINT "Diesen Raum kannst du nur in der ungekrzten Fassung betreten!"
    CASE "3"
     GOTO KommandoraumStart
    CASE "5"
     GOTO OffizierszimmerStart
    CASE ELSE
     GOTO HheRetry3
   END SELECT
 CASE ELSE
  GOTO HaupthalleStart
 END SELECT
 a$ = INPUT$(1)
 GOTO HaupthalleStart

KommandoraumStart:
 CLS
 PRINT "Dies ist der Kommandoraum des Astrein Shuttles.  Vor dir ist ein ";
 PRINT "riesiges "
 PRINT "Steuerpult, neben dem Nele sitzt, die vergeblich versucht, es zu ";
 PRINT "bedienen. "
 PRINT "Dahinter befindet sich in diesem Raum ein riesiges Fenster."
 GOSUB Eingabe
 CLS
 SELECT CASE eingab$
  CASE "1"
KreRetry1:
   PRINT "Mit wem willst du sprechen?"
   PRINT "  (1) Nele"
   PRINT "  (2) Autopilot"
   e1$ = INPUT$(1)
   CLS
   SELECT CASE e1$
    CASE "1"
     SELECT CASE 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. La es"
       PRINT "         mich probieren!'"
       MitNeleGeredet = 1
     END SELECT
    CASE "2"
     PRINT "Clausi: 'Bitte, Herr Autopilot, fliegen Sie uns zum Mond!'"
     PRINT
     PRINT "............................"
     PRINT
     PRINT "Keine Antwort. Tja, so leicht geht es nicht!"
    CASE ELSE
     GOTO KreRetry1
   END SELECT
  CASE "2"
KreRetry2:
   PRINT "Was willst du betrachten?"
   PRINT "  (1) Nele"
   PRINT "  (2) Steuerpult"
   PRINT "  (3) Fenster"
   PRINT "  (4) Teppich"
   e1$ = INPUT$(1)
   CLS
   SELECT CASE e1$
    CASE "1"
     PRINT "Nele, die Navigatorin des Astrein-Shuttles, sitzt gemtlich auf ";
     PRINT "ihrem Sessel, "
     PRINT "hrt sich mit ihrem Discman eine neue CD an und versucht ";
     PRINT "herauszufinden, wie"
     PRINT "man den Autopiloten des Astrein-Shuttles aktiviert."
    CASE "2"
     IF MitNeleGeredet = 1 AND Joystick = 5 THEN
      PRINT "Du gibst den Code, den dir Franzi gesagt hat, ein."
      PRINT "Pltzlich ruft Nele: 'Hurra! Du hast es geschafft! Du hast den ";
      PRINT "Autopiloten "
      PRINT "aktiviert!'"
      a$ = INPUT$(1)
      CLS
      PRINT "Das war die gekrzte Version von 'Die Reise zum Mond' fr"
      PRINT "The Real Adok's Way to QBASIC. See you in the Full Version!"
      END
     ELSE
      PRINT "Das Steuerpult des Astrein-Shuttles besteht aus unzhligen ";
      PRINT "Knpfen, Hebeln,"
      PRINT "Schaltern, Joysticks und Joypads. Sogar ein Computer mit ";
      PRINT "vielen Spielen"
      PRINT "ist eingebaut! Wozu, glaubt ihr, sollte man die Joysticks und ";
      PRINT "Joypads sonst"
      PRINT "brauchen, auer zur Unterhaltung der Besatzungsmitglieder?"
     END IF
    CASE "3"
     PRINT "Ein riesiges Fenster, das den Blick zu dem, was sich auerhalb ";
     PRINT "des Shuttles"
     PRINT "befindet, gewhrt! He, Moment mal! Da drauen sind auch Zahra ";
     PRINT "und Gerhard!"
    CASE "4"
     PRINT "DEN TEPPICH ANSCHAUEN? Wie geht das, wenn hier gar kein ";
     PRINT "Teppich ist?"
    CASE ELSE
     GOTO KreRetry2
   END SELECT
  CASE "3"
KreRetry3:
   PRINT "Was willst du nehmen?"
   PRINT "  (1) Teppich"
   PRINT "  (2) Steuerpult"
   PRINT "  (3) Joystick"
   e1$ = INPUT$(1)
   CLS
   SELECT CASE e1$
    CASE "1"
     PRINT "DEN TEPPICH NEHMEN? Wie geht das, wenn hier gar kein Teppich ist?"
    CASE "2"
     PRINT "Ein bichen zu schwer, was? Ja, ein bichen viel zu schwer!"
    CASE "3"
     IF Joystick < 2 THEN
      PRINT "Du reit einen der vielen Joysticks aus dem Steuerpult heraus ";
      PRINT "und steckst ihn"
      PRINT "in die Tasche. Vielleicht kannst du ihn einmal brauchen?"
      Joystick = 2
     ELSE
      PRINT "Du hast schon einen!"
     END IF
    CASE ELSE
     GOTO KreRetry3
   END SELECT
  CASE "4"
KreRetry4:
   PRINT "Wohin willst du gehen?"
   PRINT "  (1) Tr"
   e1$ = INPUT$(1)
   CLS
   IF e1$ <> "1" THEN
    GOTO KreRetry4
   END IF
   GOTO HaupthalleStart
 CASE ELSE
  GOTO KommandoraumStart
 END SELECT
 a$ = INPUT$(1)
 GOTO KommandoraumStart

OffizierszimmerStart:
 CLS
 PRINT "Du befindest dich im Offizierskasino. Hier befinden sich die drei ";
 PRINT "Offiziere "
 PRINT "Franzi, Philipp und Stefan. Sie spielen gerade ein Schachspiel auf ";
 PRINT "ihrem "
 PRINT "Computer. (Knnen sie berhaupt Schach spielen!?)"
 GOSUB Eingabe
 CLS
 SELECT CASE eingab$
  CASE "1"
OzeRetry1:
   PRINT "Mit wem willst du sprechen?"
   PRINT "  (1) Stefan"
   PRINT "  (2) Franzi"
   PRINT "  (3) Philipp"
   e1$ = INPUT$(1)
   CLS
   SELECT CASE e1$
    CASE "1"
     PRINT "Stefan: 'Hmmm, soll ich meinen Knig opfern, um die Dame zu ";
     PRINT "retten?'"
    CASE "2"
     IF Joystick = 0 THEN
      PRINT "Franzi:  'Stefan, Philipp, seid nicht so gemein! Lat mich ";
      PRINT "auch mitspielen!'"
      PRINT "Philipp: 'Dann bruchten wir aber noch einen dritten Joystick, ";
      PRINT "und den haben"
      PRINT "          wir nicht!'"
     END IF
     IF Joystick = 5 THEN
      PRINT "Franzi: 'Bitte, gib mir die Tte!'"
      PRINT "Clausi: 'Die Tte gebe ich dir nicht!'"
      PRINT "Franzi: 'Wie ich schon sagte: Der Code heit oben, rechts, ";
      PRINT "unten, links, oben"
      PRINT "         oder umgekehrt!'"
     END IF
     IF Joystick > 2 AND Joystick < 5 AND MitNeleGeredet <> 1 THEN
      PRINT "Franzi: 'Vielen Dank fr den Joystick, Clausi!'"
      PRINT "Clausi: 'Gern geschehen!'"
     END IF
     IF Joystick = 4 AND MitNeleGeredet = 1 THEN
      PRINT "Clausi: 'Hey, Fratzi, wie wre es mit dieser original ";
      PRINT "philippinischen "
      PRINT "         Plastiktte? Sie ist von Philipps Bett ";
      PRINT "hinuntergefallen!'"
      PRINT "Franzi: 'Wirklich? Ein Gegenstand ist immer fr ein Gercht ";
      PRINT "gut! Gib her!'"
      PRINT "Clausi: 'Zuerst sagst du mir den Code!'"
      PRINT "Franzi: 'Na gut. Oben, rechts, unten, links, oben ... oder ";
      PRINT "umgekehrt?'"
      PRINT "Clausi: 'Du bist ja eine schne Hilfe! Dafr bekommst du die ";
      PRINT "Tte nicht!'"
      Joystick = 5
     END IF
     IF Joystick > 2 AND Joystick < 5 AND MitNeleGeredet = 1 THEN
      PRINT "Clausi: 'Hey, Fratzi, weit du, wie man den Autopiloten ";
      PRINT "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 ";
      PRINT "bist erstens mein"
      PRINT "         Kommandant und zweitens hattest du mir den Joystick ";
      PRINT "vorhin gegeben."
      PRINT "         Trotzdem: Ich gebe dir die Anleitung nur, wenn du mir ";
      PRINT "noch ein"
      PRINT "         Geschenk machst! Mache mich zum Kommandanten!'"
      PRINT "Clausi: 'Das mache ich nicht!'"
      PRINT "Franzi: 'Dann mache etwas anderes!'"
      Joystick = 4
     END IF
     IF Joystick = 2 THEN
      PRINT "Franzi:  'Komm, Philipp, la mich endlich mitspielen!'"
      PRINT "Philipp: 'Wie oft soll ich es dir noch sagen: Dazu brauchen ";
      PRINT "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
     END IF
    CASE "3"
     PRINT "Philipp: 'Schach ist ein wahrhaft lustiges Spiel! Wenn ich es ";
     PRINT "blo spielen"
     PRINT "          knnte...'"
    CASE ELSE
     GOTO OzeRetry1
   END SELECT
  CASE "2"
OzeRetry2: 
   PRINT "Was willst du betrachten?"
   PRINT "  (1) Schachcomputer"
   PRINT "  (2) Franzi"
   PRINT "  (3) Philipp"
   PRINT "  (4) Stefan"
   e1$ = INPUT$(1)
   CLS
   SELECT CASE e1$
    CASE "1"
     PRINT "Ein riesengroer Computer, mit dem man nur Schach spielen ";
     PRINT "kann, dafr aber"
     PRINT "zu dritt!"
    CASE "2"
     PRINT "Dieser Junge nennt sich Franzi und ist erster Offizier. Seine ";
     PRINT "Spitznamen sind"
     PRINT "Fratzi, Intrigator und FBI. Letzteres bedeutet 'Flotter ";
     PRINT "blonder Insulaner'."
     PRINT "Naja, Marius, der diesen Spitznamen erfunden hatte, meinte mit ";
     PRINT "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 ";
     PRINT "haut auf die"
     PRINT "Drums wie die anderen auf ihre lieben Mitschler."
    CASE "4"
     PRINT "Dieser Junge nennt sich Stefan und ist dritter Offizier. Wie ";
     PRINT "man es auch an"
     PRINT "einer zweiten Stelle in diesem Spiel erfahren kann, nennt sich ";
     PRINT "dieses Genie"
     PRINT "auch Stex Mel. Eine seiner berhmtesten, vielzitierten ";
     PRINT "Aussagen:      'Philosophie"
     PRINT "ist nichts anderes als eine Mischung aus Poesie und Dichtung.'"
    CASE ELSE
     GOTO OzeRetry2
   END SELECT
  CASE "3"
OzeRetry3:
   PRINT "Was willst du nehmen?"
   PRINT "  (1) Schachcomputer"
   PRINT "  (2) Philipp's Joystick"
   PRINT "  (3) Franzi"
   e1$ = INPUT$(1)
   CLS
   SELECT CASE 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, la mich dich in meine Arme nehmen!'"
     PRINT "Franzi: 'Du willst mich wohl AUF den Arm nehmen!?'"
    CASE ELSE
     GOTO OzeRetry3
   END SELECT
  CASE "4"
   PRINT "Wohin willst du gehen?"
   PRINT "  (1) Tr"
OzeRetry4:
  e1$ = INPUT$(1)
  IF e1$ <> "1" THEN
   GOTO OzeRetry4
  END IF
  GOTO HaupthalleStart
 CASE ELSE
  GOTO OffizierszimmerStart
 END SELECT
 a$ = INPUT$(1)
 GOTO OffizierszimmerStart

Eingabe:
 PRINT "  (1) Sprich"
 PRINT "  (2) Betrachte"
 PRINT "  (3) Nimm"
 PRINT "  (4) Gehe zu"
 PRINT "  (5) Ende"
 eingab$ = INPUT$(1)
 IF eingab$ = "5" THEN
  END
 END IF
RETURN
#PROGAUS
"Das soll ein kleines Beispiel sein?" wird sich so mancher jetzt fragen. Ja, 
mit seinen 443 Zeilen, die gut 14 KB Speicherplatz belegen, ist dieses 
Beispielprogramm schon sehr gro. Aber fr ein voll funktionsfhiges 
Adventure mit allem Drum und Dran bis auf Grafik, Maussteuerung und Sound ist 
es geradezu winzig! 
Falls ihr es mhselig findet, das Listing abzutippen: In den Diskmags Skyline 
und Hugendubelexpress wird mein Basic-Kurs auch verffentlicht. Es liegen alle 
Listings in eigenen Dateien bei. Ihr knnt diese dann einfach in QBasic laden 
und ausfhren. 
Zu dem Beispielprogramm noch einige Erluterungen: 
- Joystick, MitNeleGeredet etc. sind Variablen, in denen gespeichert wird, wie 
weit man im Spiel fortgeschritten ist, was man schon alles gemacht hat usw. 
Wenn ich schon frher gewut htte, da 'Die Reise zum Mond' in einem Kurs 
verffentlicht wird, htte ich es eindeutiger und bersichtlicher gemacht. 
- Der Befehl GOSUB entspricht von der Verwendung her im groen und ganzen 
GOTO, nur wird, wenn QBasic auf RETURN stt, zu der Zeile, in der GOSUB 
steht, zurckgesprungen. 
So, ich hoffe, da ihr eine Menge aus dieser Folge gelernt habt. Falls ihr 
noch irgendwelche Fragen habt: Stellt sie im PC-Heimwerker oder wendet euch 
direkt an mich! Meine Addy findet ihr in der Pseudo-Liste. 


                              ****************
                              ***  TEIL 7  ***
                              ****************
Willkommen zum siebten Teil von The Real Adok's Way to QBASIC! Heute geht es 
um die Grafikprogrammierung. Uff, das wird umfangreich sein! Fangen wir also 
am besten gleich an. 
Wenn wir die Grafikfunktionen ntzen wollen, mssen wir zunchst mit dem 
SCREEN-Befehl in den Grafikmodus umschalten. Da es verschiedene Grafikmodi 
gibt, mu als Parameter die Nummer des gewnschten Modi angegeben werden. Die 
gebruchlichsten Grafikmodi sind: 
#PROGEIN
0..........Textmodus, 16 Farben, mehrere Bildschirmseiten, keine Grafik. 
9..........EGA-Grafik, Grafikauflsung 640x350 Pixel, 16 Farben, mehrere 
           Bildschirmseiten, nicht so schne Farben wie in Modus 12. 
12.........VGA-Grafik, Grafikauflsung 640x480 Pixel, 16 Farben, eine 
           Bildschirmseite. 
13.........VGA-Grafik, Grafikauflsung 320x200 Pixel, 256 Farben, eine 
           Bildschirmseite, in Power Basic nicht anwhlbar! 
#PROGAUS
Dazu bedarf es einiger Klrung. Obwohl der Text auch in den Grafikmodi   
angezeigt werden kann, wird trotzdem oft auch weiterhin der reine Textmodus  
(0) verwendet. Das liegt daran, da die Textauflsung im reinen Textmodus mit 
80x25 Zeichen sehr hoch ist, wobei sie in manchen Grafikmodi wesentlich 
kleiner ist. Beispielsweise lassen sich im Modus 13 nur 40 Zeichen pro Zeile 
darstellen. Nur im Grafikmodus 12 ist sie mit 80x30 Zeichen sogar etwas besser 
als im reinen Textmodus. Man knnte sich jetzt fragen, warum nicht gleich der 
Modus 12 genommen wird. Dafr gibt es zwei Grnde. Zum einen wird eine 
VGA-Grafikkarte bentigt (und die hat nicht jeder), und zum anderen wird der 
Text im Modus 12 langsamer angezeigt. Das kann 
strend wirken, wenn z.B. der Hintergrund in einer anderen Farbe ist. Im 
reinen Textmodus lt sich, wie wir bereits wissen, die Hintergrundfarbe 
einstellen. Aber jetzt Schlu damit, obwohl ich diese kleinen Exkurse ab und 
zu einbauen mu, damit die Materie fr jeden verstndlich wird. Fahren wir 
mit dem Kurs fort. 
Die Grafikauflsung gibt an, aus wievielen Punkten der Bildschirm aufgebaut 
ist. Ein Wert von 640x350 gibt beispielsweise an, da sich in der 
horizontalen Richtung pro Zeile 640 Bildpunkte ansprechen lassen, und es 350 
Zeilen gibt. Der Wert bei den Farben gibt die Anzahl der verschiedenen Farben 
an, die sich gleichzeitig darstellen lassen. Was 'Bildschirmseiten' bedeutet, 
ist fr uns nicht von Bedeutung. Ich habe sie nur der Vollstndigkeit halber 
angefhrt. 
So, genug mit dem Gelaber. Ich verffentliche nun ein Beispielprogramm, damit 
das ganze verstndlicher wird. Es wird der Grafikbefehl PSET verwendet. Mit 
seiner Hilfe lassen sich Bildpunkte in einer beliebigen Farbe "setzen". Die 
Farbe kann entweder direkt im Parameter gewhlt werden, oder sie mu vorher 
durch COLOR festgelegt werden. Die genaue Syntax lautet: 
#PROGEIN
PSET (XKoordinateDesBildpunkts, YKoordinateDesBildpunkts), Farbe
#PROGAUS
Damit keine Probleme auftauchen: Bei ALLEN Grafikbefehlen mu immer zuerst die 
X-Koordinate angegeben werden. Bei LOCATE war das ja genau umgekehrt, wie wir 
es (hoffentlich) noch bestens wissen. 
#PROGEIN
'PSET-Demo

SCREEN 12                      'VGA-Grafikmodus 640x480 gewhlt

COLOR 13                       'Pink
PSET (100, 100)                'Farbe vorher gewhlt

PSET (320, 200), 14            'Farbe direkt angegeben
#PROGAUS
Wir werden in unseren Beispielprogrammen immer im Grafikmodus 12 arbeiten. 
Falls ihr nur eine EGA-Grafikkarte besitzt, benutzt einfach den hnlichen 
Grafikmodus 9. 
Es gibt dann noch den Befehl PRESET. Er funktioniert genauso wie PSET, nur 
wird, wenn die Farbe nicht direkt angegeben wird, die aktuelle 
Hintergrundfarbe verwendet. 
Der nchste wichtige Grafikbefehl ist LINE. Mit seiner Hilfe lassen sich, wie 
der Name sagt, Linien zeichnen. Das ist brigens nur eine seiner vielen 
Anwendungsmglichkeiten, wie wir gleich sehen werden. Die Syntax entspricht 
der von PSET, nur mssen zwei Koordinaten angegeben werden. Gleich ein 
Beispielprogramm: 
#PROGEIN
'LINE-Demo

SCREEN 12                      'VGA-Grafikmodus 640x480 gewhlt

COLOR 13                       'Pink
LINE (100, 100)-(320, 200)     'Farbe vorher gewhlt

LINE (80, 400)-(420, 400), 14  'Farbe direkt angegeben
#PROGAUS
Experimentiert ein wenig mit den Koordinaten, um die Anwendung dieses Befehls 
zu erlernen. 
Kommen wir nun zur anderen Anwendung von LINE. Mit LINE lassen sich auch 
Rechtecke zeichnen. Man kann sogar angeben, ob die Rechtecke ausgefllt werden 
sollen oder nicht. Falls sie ausgefllt werden sollen, mu man nach Angabe 
der Farbe ', BF' schreiben. Falls nicht, gengt ', B'. Wenn ihr die Farbe 
nicht direkt angeben wollt, sondern die in COLOR angegebene bernehmen wollt, 
so lat sie einfach weg! Der Beistrich mu aber schon geschrieben werden. 
Dazu gleich ein Beispiel. 
#PROGEIN
'LINE-Demo mit B- und BF-Option

SCREEN 12                            'VGA-Grafikmodus 640x480 gewhlt

COLOR 13                             'Pink
LINE (10, 200)-(600, 400), , B       'Nicht ausgeflltes Rechteck

COLOR 15                             'Leuchtend-Wei
LOCATE 24, 1                         'Meldung ausgeben
PRINT "Nicht ausgeflltes Rechteck"
PRINT "Beliebige Taste drcken..."
a$ = INPUT$(1)

CLS                                  'Bildschirm lschen
COLOR 13                             'Pink
LINE (10, 200)-(600, 400), , BF      'Ausgeflltes Rechteck

COLOR 15                             'Leuchtend-Wei
LOCATE 24, 1                         'Meldung ausgeben
PRINT "Ausgeflltes Rechteck"
PRINT "Beliebige Taste drcken..."
a$ = INPUT$(1)
#PROGAUS
Wie ihr seht, wird in unserem Beispielprogramm zwischen den Grafik- und den 
Textausgaben immer die Farbe umgeschaltet. Da wrde eine direkte Farbanwahl 
doch Sinn machen! Ich habe das deshalb gleich realisiert. Das Ergebnis 
lautet: 
#PROGEIN
'LINE-Demo mit B- und BF-Option

SCREEN 12                            'VGA-Grafikmodus 640x480 gewhlt

COLOR 15                             'Leuchtend-Wei

LINE (10, 200)-(600, 400), 13, B     'Nicht ausgeflltes Rechteck

LOCATE 24, 1                         'Meldung ausgeben
PRINT "Nicht ausgeflltes Rechteck"
PRINT "Beliebige Taste drcken..."
a$ = INPUT$(1)

CLS                                  'Bildschirm lschen
LINE (10, 200)-(600, 400), 13, BF    'Ausgeflltes Rechteck

LOCATE 24, 1                         'Meldung ausgeben
PRINT "Ausgeflltes Rechteck"
PRINT "Beliebige Taste drcken..."
a$ = INPUT$(1)
#PROGAUS
Nun mte euch klar sein, wozu eine direkte Farbanwahl gut ist: Wenn in einem 
Programm der Text in einer anderen Farbe als die Grafik ausgegeben werden 
soll, so ist es praktisch, die Textfarbe mit COLOR festzulegen und die 
Grafikfarbe immer direkt anzugeben. 
Der nchste Befehl ist CIRCLE. Mit ihm lassen sich Kreise zeichnen. Als 
Parameter mssen der Mittelpunkt, der Radius und bei direkter Farbanwahl die 
Farbe angegeben werden. Zu dem Resultat sei nur gesagt, da QBasic 
automatisch die Werte "nachkorrigiert", so da der Kreis auch wie ein Kreis 
aussieht. Die Koordinaten stimmen deshalb nicht immer mit den Werten, die ihr 
durch den Mittelpunkt und den Radius errechnen knnt, berein. Wie immer, hier 
ein Beispiel. 
#PROGEIN
'CIRCLE-Demo

'Variablen
MPunktX = 320
MPunktY = 200
Radius = 100

'Hauptprogramm
SCREEN 9                                           'EGA-Grafikmodus 640x350

CIRCLE (MPunktX, MPunktY), Radius, 15              'Kreis zeichnen

'Beweis, da die von Hand errechneten Koordinaten nicht mit den
'tatschlichen bereinstimmen:
LINE (MPunktX - Radius, MPunktY)-(MPunktX + Radius, MPunktY), 14
LINE (MPunktX, MPunktY - Radius)-(MPunktX, MPunktY + Radius), 14
#PROGAUS
Bei dem Befehl CIRCLE gibt es keinen Fill-Parameter. Trotzdem lassen sich 
Kreise und andere Gebilde ausfllen, und zwar mit dem Befehl PAINT. Das ganze 
funktioniert so hnlich wie die Flloptionen in diversen Grafikprogrammen. Es 
mssen ein Startpunkt, bei dem das Fllen begonnen werden soll, die 
Ausfllfarbe und die Randfarbe angegeben werden. Die Randfarbe gibt an, wo 
das Ausfllen gestoppt werden soll. Man mu also eine Art "Kfig" in dieser 
Randfarbe zeichnen, bevor man PAINT verwendet. Sonst wird der ganze 
Bildschirm ausgefllt. Beim Ausfllen eines Kreises sind diese Parameter 
sonnenklar: Startpunkt entspricht dem Mittelpunkt, Ausfllfarbe und 
Randfarbe der Farbe des Kreises. Dazu gleich ein Beispiel. 
#PROGEIN
'PAINT-Demo

SCREEN 12

LOCATE 2, 32
PRINT "Das ist PFLAUMI!"

CIRCLE (320, 200), 100, 9      'Kopf
PAINT (320, 200), 9, 9

CIRCLE (280, 166), 30, 14      'Linkes Auge
PAINT (280, 166), 14, 14

CIRCLE (360, 166), 30, 14      'Rechtes Auge
PAINT (360, 166), 14, 14

CIRCLE (280, 166), 10, 2       'Linke Pupille
PAINT (280, 166), 2, 2

CIRCLE (360, 166), 10, 2       'Rechte Pupille
PAINT (360, 166), 2, 2

LINE (320, 180)-(320, 240), 15 'Nase

LINE (260, 220)-(320, 280), 4  'Mund
LINE (320, 280)-(380, 220), 4
#PROGAUS
Lustiges Gesicht, nicht wahr? 
Der DRAW-Befehl wird wohl doch erst nchstes Mal kommen. Jetzt nur noch eine 
weitere Option, die man bei ALLEN bisher besprochenen Grafiken einsetzen kann. 
Sie heit STEP und gibt an, da die nchsten Bildschirmkoordinaten nicht 
absolut, sondern relativ zur letzten Bildschirmkoordinaten sind. Positive 
Koordinaten bedeuten, da sich der Bildpunkt um die angegebene Zahl von 
Punkten rechts unten vom letzten Bildpunkt befindet. Negative Koordinaten 
dagegen geben an, da sich der neue Bildpunkt links oben von dem alten 
befindet. Dadurch lassen sich Polygone (Vielecke) sehr einfach mit dem 
LINE-Befehl zeichnen, denn wenn STEP verwendet wird, kann der Startpunkt, von 
dem die Linie ausgeht, weggelassen werden. 
So, das waren die grundlegendsten Grafikbefehle. Nchstes Mal besprechen wir 
den umfangreichen DRAW-Befehl und die Datentypen von QBasic. 


                              ****************
                              ***  TEIL 8  ***
                              ****************
Willkommen zu The Real Adok's Way to QBASIC, Teil 8! Ich hatte mir fr diese 
Folge eigentlich die Datentypen vorgenommen, aber da wir letztes Mal mit den 
Grafikbefehlen noch nicht ganz fertiggeworden sind, hier der Rest. Wir sind 
beim DRAW-Befehl stehengeblieben. Er ist im Grunde genommen nichts anderes 
als der PLAY-Befehl, nur fr Grafiken. Hier eine Liste mit den wichtigsten 
DRAW-Kommandos: 
#PROGEIN
 Ux.......... Cursor um x Bildpunkte nach oben bewegen 
 Dx.......... Cursor um x Bildpunkte nach unten bewegen 
 Lx.......... Cursor um x Bildpunkte nach links bewegen 
 Rx.......... Cursor um x Bildpunkte nach rechts bewegen 
 Hx.......... Cursor um x Bildpunkte nach oben-links 
 Ex.......... Cursor um x Bildpunkte nach oben-rechts
 Gx.......... Cursor um x Bildpunkte nach unten-links 
 Fx.......... Cursor um x Bildpunkte nach unten-rechts 
 
 Mx,y........ Cursor wird nach x,y bewegt (absolute Koordinaten) 
 M+x,y....... Cursor wird nach x,y bewegt (relative Koordinaten)
 M-x,y....... Cursor wird nach x,y bewegt (relative Koordinaten)
 
 B........... Prfix: Cursor wird ohne zu zeichnen bewegt
 N........... Prfix: Zeichnet und setzt Cursor auf Ausgangsposition zurck 
#PROGAUS
Leichter zu merken ist brigens folgende Interpretation von LeidPen: 
#PROGEIN
 U up             E Estland 
 D down           G Gibraltar 
 L left           F finis 
 R right 
 H home, Holland 
#PROGAUS
Den Rest knnt ihr in der Online-Hilfe nachlesen. 
Nun zu einem anderen Thema: den Datentypen in QBasic. Wenn man die Datentypen 
mit der Mathematik vergleicht, so entsprechen sie am ehesten den 
Zahlenmengen. Das heit, da die Datentypen sozusagen die Grundmengen fr die 
Variablen festlegen. Bis jetzt sind uns zwei Datentypen bekannt: 
Fliekommazahlen und Zeichenketten. Der Datentyp der Fliekommazahlen, wie wir 
sie kennen, heit SINGLE. Wie der Name sagt, hat er nur eine begrenzte Anzahl 
an Vor- und Nachkommastellen. Eine hhere Anzahl von Stellen hat der 
Datentyp DOUBLE. Beide Fliekommazahlendatentypen haben jedoch den Nachteil, 
da sie sehr langsam sind, weil der Computer intern keine Fliekommazahlen 
verarbeiten kann und sie deshalb vorher von QBasic umgewandelt werden mssen. 
Deshalb gibt es mehrere Ganzzahl-Datentypen. Einer von ihnen, INTEGER, 
belegt 2 Byte Arbeitsspeicherplatz (pro Variable, versteht sich) und kann 
ganzzahlige Werte von -32768 bis +32767 annehmen. LONG belegt doppelt soviel 
Speicherplatz und kann -(2^32) bis +(2^32-1) annehmen. 
Der Zeichenkettendatentyp oder STRING besteht im Grunde genommen auch nur aus 
mehreren Integers, denn die einzelnen Zeichen werden als Zahlen, und zwar im 
sogenannten ASCII-Code, gespeichert. Wenn man es ganz genau nimmt, besteht 
ein String aus mehreren Bytes (Ganzzahlen von 0 bis 255, gibt's nur in 
Power Basic). 
Will man nun eine Variable mit einem bestimmten Datentyp anlegen, mu man den 
Befehl DIM anwenden. Seine Syntax lautet: 
#PROGEIN
DIM Variable AS Datentyp
#PROGAUS
Wenn man eine Variable als String definiert, braucht man bei ihr nicht mehr 
das Dollarzeichen schreiben! Praktisch, oder? 
Bei Strings gibt es noch eine Besonderheit. Normalerweise ist die Lnge der 
Strings variabel. Der String kann dann eine Lnge von 0 bis 32768 Zeichen 
haben. Mit DIM kann man aber auch Strings mit einer festen Lnge definieren. 
Wird eine zu lange Zeichenkette zugewiesen, so werden die berflssigen 
Zeichen einfach abgeschnitten. Wird eine zu kurze Zeichenkette zugewiesen, so 
wird der Rest mit Leerzeichen ausgefllt. Beispiel: 
#PROGEIN
'String-Demo
 
DIM Zeichenkette AS STRING * 8          'String mit fester Lnge von 8 Zeichen

SCREEN 12                               'Bildschirm ausfllen
PAINT (320, 200), 9

Zeichenkette = "Hallo! Wie geht's?"     'Erster Versuch
PRINT Zeichenkette

PRINT

Zeichenkette = "Hi!"                    'Zweiter Versuch
PRINT Zeichenkette
#PROGAUS
Mit dem DIM-Befehl lassen sich auch sogenannte Felder (englisch: Arrays) 
definieren. Die Anweisung 
#PROGEIN
DIM FeldName(1 TO x) AS INTEGER
#PROGAUS
erzeugt ein Feld, das aus x Integer-Variablen besteht. Jede dieser Variablen 
lt sich dann einzeln ansprechen, als ob sie nicht in einem Feld stnde. 
Will man beispielweise der fnften Variablen des Feldes GanzZahl den Wert 10 
zuweisen, so schreibt man einfach:
#PROGEIN
GanzZahl(5) = 10
#PROGAUS
Damit das ganze verstndlich wird, hier ein Beispielprogramm: 
#PROGEIN
'Array-Demo

DIM Summand(1 TO 3) AS SINGLE
DIM Summe AS SINGLE
DIM Zaehler AS INTEGER

COLOR 14, 1
CLS

FOR Zaehler = 1 TO 3
 PRINT "Summand"; Zaehler;
 INPUT Summand(Zaehler)
 Summe = Summe + Summand(Zaehler)
NEXT

PRINT
PRINT Summand(1); "+"; Summand(2); "+"; Summand(3); "="; Summe
#PROGAUS
Da dieses Beispielprogramm etwas komplizierter ist als die anderen, wollen wir 
es Zeile fr Zeile besprechen. 
In der 3. Zeile wird ein Single-Feld mit drei Elementen namens Summand 
definiert. In der 4. und der 5. Zeile werden zwei weitere Variablen definiert. 
Anschlieend werden die Farben gewhlt und der Bildschirm gelscht. 
In der 10. Zeile steht nun der Anfang einer FOR/NEXT-Schleife. Zuerst wird 
ausgegeben, wievielter Summand eingegeben werden soll. Danach mu der 
Benutzer diesen Summand eingeben. Ihr merkt, da man auch Variablen als 
"Arrayindex" verwenden kann. Bisher verwendeten wir dazu nur Zahlen. 
Anschlieend wird der eingegebene Summand gleich zu der Summe addiert. Man 
knnte zwar auch nachtrglich alle drei Summanden zusammenzhlen und der 
Variablen Summe zuweisen, doch das wrde 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 vernachlssigen, unsere Programme zu optimieren. (Eine Spezialitt! 
Wenn man das Optimieren vernachlssigt, entstehen solche Programme wie 
Winword, die zwar nicht schlecht, aber langsam sind. Einmal abgesehen von der 
Tatsache, da in Winword viele Bugs enthalten sind...) Spter 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. 
Wie wir bereits wissen, ist der Datentyp einer Variablen, wenn sie vorher 
nicht definiert wurde, automatisch SINGLE. Das knnen wir aber auch ndern. 
Wenn wir am Anfang eines Programms DEFINT A-Z schreiben, sind die nicht 
definierten Variablen automatisch vom Typ Integer. Es gibt auch DEFLNG 
(Long), DEFDBL (Double), DEFSTR (String) und natrlich DEFSNG (Single). Wie 
sich wohl jeder selbst denken kann, ist DEFSNG Standard. 
Lange keine Hausaufgaben mehr gehabt! Nun, mit den in den letzten Folgen 
erlernten Befehlen knnen wir unser Rechenprogramm aus Teil 3 ausbauen. 
Verndert es so, da 
- die Zahlen in einem Array gespeichert werden, 
- das Programm den Benutzer nach der Berechnung fragt, ob er zwei neue 
  Zahlen eingeben will (und auch dementsprechend handelt), 
- das ganze mit einigen Grafiken aufgelockert wird. 
Nchstes Mal geht es um die Dateiverwaltung. Wir werden lernen, wie man mit 
dem SHELL-Befehl DOS-Kommandos und andere Programme ausfhrt und sequentielle 
Dateien erstellt bzw. einliest. bernchstes Mal folgen die SUBs und die 
FUNCTIONs, und dann kommen noch einige ntzliche Befehle und Tools. 


                              ****************
                              ***  TEIL 9  ***
                              ****************
Willkommen zum neunten Teil von The Real Adok's Way to QBASIC! Nach langer 
Zeit gab es endlich wieder Hausaufgaben. Die Problemstellung war, unser 
Megarechenprogramm aus Folge 3 zu verbessern. Es gibt sicher eine Menge 
verschiedene Lsungen. Wer will, kann ja seine Lsung in dieser Rubrik 
verffentlichen. Hier nun eine mgliche Lsung. 
#PROGEIN
'DAS MEGARECHENPROGRAMM!!!!                   VERSION 5
'... aus The Real Adok's Way to QBASIC.


'+++ Variablenzuweisungen
DEFINT A-Z                              'Variablen ohne Kennung sind Integer
DIM Zahl(1 TO 2) AS SINGLE              'Array Zahl

blau = 1                                'Farbe Blau
gelb = 14                               'Farbe Gelb
weiss = 7                               'Farbe Wei
hell = 8                                'Zusatz fr Helligkeit


'+++ Hauptprogramm
SCREEN 9                                'EGA-Grafik
GOSUB Titelbild                         'Sprung nach Label Titelbild
GOSUB Titelmusik                        'Sprung nach Label Titelmusik
a$ = INPUT$(1)                          'Auf Tastendruck warten

Start:
 COLOR , blau                           'Blauer Hintergrund
 CLS                                    'Bildschirm lschen
                                      
 COLOR hell + weiss                     'Eingabe der ersten Zahl
 LOCATE 2, 2                            '
 PRINT "Wie lautet die erste Zahl";     '
 COLOR gelb                             '
 INPUT Zahl(1)                          '
 
 COLOR hell + weiss                     'Eingabe der zweiten Zahl
 LOCATE 5, 2                            '
 PRINT "Wie lautet die zweite Zahl";    '
 COLOR gelb                             '
 INPUT Zahl(2)                          '
 
 CLS                                    'Bildschirm lschen
 COLOR hell + weiss                     'Erste Zahl ausgeben
 LOCATE 2, 2                            '
 PRINT "Zahl 1:";                       '
 COLOR gelb                             '
 PRINT Zahl(1);                         '
 
 COLOR hell + weiss                     'Zweite Zahl ausgeben
 LOCATE , 60                            '
 PRINT "Zahl 2:";                       '
 COLOR gelb                             '
 PRINT Zahl(2)                          '
 
 COLOR hell + weiss                     'Verzierungsstrichlein ausgeben
 LOCATE 3, 1                            '
 PRINT "-----------------------";       '
 PRINT "-----------------------";       '
 PRINT "-----------------------";       '
 PRINT "-----------"                    '
 
 COLOR hell + weiss                     'Ergebnis der Addition ausgeben
 LOCATE 5, 2                            '
 PRINT "Addition:";                     '
 COLOR gelb                             '
 LOCATE , 17                            '
 PRINT Zahl(1) + Zahl(2)                '
 
 COLOR hell + weiss                     'Ergebnis der Subtraktion ausgeben
 LOCATE 6, 2                            '
 PRINT "Subtraktion:";                  '
 COLOR gelb                             '
 LOCATE , 17                            '
 PRINT Zahl(1) - Zahl(2)                '
 
 COLOR hell + weiss                     'Ergebnis der Multiplikation ausgeben
 LOCATE 7, 2                            '
 PRINT "Multiplikation:";               '
 COLOR gelb                             '
 LOCATE , 17                            '
 PRINT Zahl(1) * Zahl(2)                '
 
 COLOR hell + weiss                     'Ergebnis der Division ausgeben
 LOCATE 8, 2                            '
 PRINT "Division:";                     '
 COLOR gelb                             '
 LOCATE , 17                            '
 IF Zahl(2) = 0 THEN                    '
  PRINT " Division durch Null!"         '
 ELSE                                   '
  PRINT Zahl(1) / Zahl(2)               '
 END IF

 PLAY "t200 l8 o5 ddd p64 l2 g"         'Musik

 DO                                     'Abfrage, ob noch eine Berechnung
  COLOR hell + weiss                    '
  LOCATE 18, 2                          '
  PRINT "Noch eine Berechnung (J/N)";   '
  COLOR gelb                            '
  PRINT "?"                             '
  Wahl$ = INPUT$(1)                     '
 LOOP UNTIL Wahl$ = "J" OR Wahl$ = "j" OR Wahl$ = "N" OR Wahl$ = "n"

 SELECT CASE Wahl$                      'Auswertung der Wahl
  CASE "J", "j"                         '
   GOTO Start                           '
  CASE ELSE                             '
   END                                  '
 END SELECT                             '


'+++ Titelbild.
Titelbild:
 LOCATE 3, 27                           'Titelschrift
 PRINT "DAS MEGARECHENPROGRAMM!!!!"     '
 LOCATE 5, 21                           '
 PRINT "... aus The Real Adok's Way to QBASIC."

 CIRCLE (320, 200), 100, 9              'Kopf
 PAINT (320, 200), 9, 9                 '

 CIRCLE (280, 166), 30, 14              'Linkes Auge
 PAINT (280, 166), 14, 14               '

 CIRCLE (360, 166), 30, 14              'Rechtes Auge
 PAINT (360, 166), 14, 14               '

 CIRCLE (280, 166), 10, 2               'Linke Pupille
 PAINT (280, 166), 2, 2                 '

 CIRCLE (360, 166), 10, 2               'Rechte Pupille
 PAINT (360, 166), 2, 2                 '

 LINE (320, 180)-(320, 240), 15         'Nase

 LINE (260, 220)-(320, 260), 4          'Mund
 LINE (320, 260)-(380, 220), 4          '
RETURN                                  'Rckkehr zum Hauptprogramm


'+++ Titelmusik.
Titelmusik:
 PLAY "t120 l8 o4"                      'Der Lrm fngt an!
 PLAY "g g g > c c c < l4 a f c"        '
 PLAY "l8 g g g > c c c l4 d < b g"     '
 PLAY "l8 b- b- b- > e- e- e- l4 d < b- f"
 PLAY "l8 e- e- e- a- a- a- l4 g > l8 e p8 < l4 c"
RETURN                                  'Rckkehr zum Hauptprogramm

'+++ Ende des Programms.
#PROGAUS
Wie ihr seht, habe ich mir sehr viel Mhe gemacht, den Code bersichtlich 
zu gestalten. Ich hoffe, da sich meine Mhe lohnte. Dieses Programm werden 
wir in diesem Basic-Kurs nur noch ein einziges Mal verbessern, und zwar mit 
den Befehlen, die wir in Folge 11 besprechen werden. Nun aber zum eigentlichen 
Thema dieser Folge, der Dateiverwaltung. 
Oft mu man DOS-Befehle oder externe Programme aus einem eigenen Programm 
heraus ausfhren. Der Befehl hierzu ist SHELL. Mit ihm kann man sich eine 
Kommandozeile basteln. Diese wird dann 1:1 an DOS bergeben. Fr den, der sich 
mit DOS auskennt, ist der SHELL-Befehl also berhaupt kein Problem. Die 
Kommandozeile mu als String bergeben werden. 
#PROGEIN
SHELL "DIR /O"
#PROGAUS
zeigt beispielsweise den Inhalt des aktuellen Verzeichnisses auf dem 
Bildschirm alphabetisch sortiert an. Auch solche Aufrufe sind mglich: 
#PROGEIN
SHELL Pfad$ + DateiName$
#PROGAUS
QBasic sieht zunchst nach, wie die Inhalte der Variablen Pfad$ und 
DateiName$ aussehen. Danach werden die beiden Zeichenketten zu einer 
zusammengefgt. Steht z.B. in Pfad$ "C:\WINDOWS\" und in DateiName$ 
"WIN.COM", so wird die Zeichenkette "C:\WINDOWS\WIN.COM" bergeben. Das 
Pluszeichen dient bei Strings also dazu, die beiden Zeichenketten 
aneinanderzuhngen. Dies kann oft sehr ntzlich sein und funktioniert bei 
ALLEN Befehlen und Funktionen, in denen Strings verwendet werden. 
#PROGEIN
PRINT Pfad$ + DateiName$
#PROGAUS
wre zwar auch mglich, aber dazu gibt es ja schon den Strichpunkt: 
#PROGEIN
PRINT Pfad$; DateiName$
#PROGAUS
Diesen Strichpunkt gibt es bei SHELL nicht, weshalb man das Pluszeichen 
bentigt. Auerdem kann man ja auch zwei verkettete Strings einer anderen 
Stringvariablen zuweisen. Das geht dann genauso, wie wenn man zwei Zahlen 
addiert und diese einer Variablen zuweist. Nur bei LINE INPUT sollte man 
Strings nicht verketten...! 
Zurck zu SHELL. Fassen wir zusammen: Der SHELL als Parameter bergebene 
String wird dann von MS-DOS so ausgefhrt, als ob ihn der Anwender in der 
Kommandozeile eingegeben htte. Der SHELL-Befehl wird in Spielen benutzt, um 
Bilder, die mit dem Graphics Workshop zu selbstlaufenden EXE-Dateien 
umgewandelt wurden, anzuzeigen. 
Ein Beispielprogramm wre hier sinnlos, weil es ja nichts machen wrde, auer 
wieder ein anderes Programm zu starten. Kommen wir lieber zur eigentlichen 
Dateiverwaltung. Der wichtigste Befehl heit hier wohl OPEN. Mit ihm lt sich 
eine Datei erzeugen oder einlesen. Seine Syntax lautet: 
#PROGEIN
OPEN Datei FOR Modus AS Nummer
#PROGAUS
Datei ist ein String, der den Dateinamen enthlt. Auf Modus kommen wir noch 
spter zurck. Nummer ist eine Zahl, unter der die Dateiverwaltungsbefehle die 
Datei ansprechen knnen. Vor dem Ende eines jeden Programms mssen alle 
geffneten Dateien geschlossen werden. Dazu gibt es den Befehl CLOSE. Seine 
Syntax lautet: 
#PROGEIN
CLOSE Nummer
#PROGAUS
So, kommen wir nun zum Modus. In diesem Basic-Kurs werden wir die zwei Modi 
INPUT und OUTPUT kennenlernen. Wer etwas ber die anderen Modi erfahren will, 
soll in der Online-Hilfe oder in einem QBasic-Buch nachlesen. 
Der Modus INPUT dient dazu, eine Datei zeilenweise einzulesen. Wie der Name 
sagt, funktioniert dies mit einer speziellen Unterfunktion von LINE INPUT. 
Die Syntax lautet: 
#PROGEIN
LINE INPUT #Nummer, Variable
#PROGAUS
Nummer ist die Nummer der Datei, aus der eine Zeile gelesen, und Variable eine 
Stringvariable, in der die Zeile gespeichert werden soll. Beim ersten Aufruf 
wird die erste Zeile gelesen, beim zweiten die zweite usw. 
Dateien lassen sich auch mit INPUT und INPUT$ einlesen. Die Syntax von 
letzterem lautet: 
#PROGEIN
Variable = INPUT$(AnzahlZeichen, Nummer)
#PROGAUS
Hier wird die Datei Zeichen fr Zeichen eingelesen. Wichtig ist auch die 
Funktion EOF. Wenn EOF(1) einen Wert ungleich 0 ergibt, dann ist das 
Dateiende der Datei mit der Nummer 1 erreicht. Wird jetzt nocheinmal ein 
Lesezugriff mit den oben genannten Befehlen gettigt, wird das Programm mit 
einer Fehlermeldung abgebrochen. Das mu man natrlich verhindern, indem man, 
wenn EOF(1) ungleich 0 ist, das Einlesen der Zeilen abbricht. Hier gleich ein 
praktisches Anwendungsbeispiel, nmlich ein File-Viewer. 
#PROGEIN
'File-Viewer, unbrauchbare Version

COLOR 15, 1
CLS

PRINT "Dateiname";                'Name der Datei abfragen
COLOR 14
PRINT "? ";
LINE INPUT Datei$

OPEN Datei$ FOR INPUT AS 1        'Datei ffnen

CLS
COLOR 15

'Zeilen einlesen und anzeigen   
DO UNTIL EOF(1)                   'Wenn kein Vergleichoperator vorhanden ist,
 LINE INPUT #1, Zeile$            'wird automatisch <> 0 ergnzt!
 PRINT Zeile$
LOOP

CLOSE 1                           'Datei schlieen
#PROGAUS
Warum ich 'unbrauchbare Version' geschrieben habe? Ganz einfach: Probiert doch 
einmal aus, eine groe Datei zu ffnen (z.B. KURS0019.BAS)! Es tritt der 
gleiche Effekt wie beim DOS-Befehl TYPE ohne MORE auf: Die Datei wird 'in 
einem durch' angezeigt. Effektiv lt sich dann nur die letzte Seite 
betrachten. TYPE kann man ja durch PAUSE pausieren, doch das geht bei unserem 
Viewer nicht! Am besten, wir bauen gleich eine seitenweise Anzeige wie bei 
MORE ein. Wenn der Benutzer dann die nchste Seite sehen will, bettigt er 
einfach eine beliebige Taste. Das knnen wir erreichen, indem wir einen 
Zhler 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 drcken. Danach wird der Bildchirm gelscht, der Zhler auf 0 gesetzt, 
und weiter geht's! Hier das Listing. .......... Wieso denn? Es wre doch eine 
gute Idee, euch die Umsetzung in Basic als Hausaufgabe aufzugeben! Den 
Programmablauf haben wir ja jetzt schon besprochen. 
Kommen wir zum nchsten Modus, OUTPUT. Dieser Modus ist das genaue Gegenteil 
des INPUT-Modi, denn hier wird eine neue Datei erzeugt und dann in diese 
geschrieben. Der Schreibbefehl ist auch PRINT, nur mu wie bei LINE INPUT die 
Dateinummer angegeben werden. Als Beispiel ein einfacher ASCII-Texteditor. 
#PROGEIN
'Texteditor

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
LINE INPUT Datei$

CLS
COLOR 15
PRINT "Jetzt Text eingeben! Um das Programm zu beenden, Leerzeile eingeben."
COLOR 14

'Eingabe des Texts
OPEN Datei$ FOR OUTPUT AS 1
DO
 LINE INPUT Zeile$
 PRINT #1, Zeile$
LOOP UNTIL Zeile$ = ""
CLOSE 1
#PROGAUS
Das war fr heute alles! Eine Hausaufgabe habt ihr ja schon bekommen, aber wie 
immer sollt ihr euch auch mit den neuen Befehlen herumspielen. Nur Vorsicht 
bei OUTPUT! Wenn schon eine Datei mit dem gewhlten Namen existiert, wird sie 
gnadenlos berschrieben! Nchstes Mal kommen dann SUBs und FUNCTIONs an die 
Reihe. bernchstes Mal stelle ich dann eine Liste mit ntzlichen Befehlen 
zusammen, die ihr in der Online-Hilfe nachlesen knnt, und verffentliche eine 
Toolbox mit einigen SUBs und FUNCTIONs. Falls ihr selbst (mehr oder wenige) 
ntzliche Programme geschrieben habt, die vielleicht auch andere Leser 
interessieren knnten, dann verffentlicht sie doch einfach in der 
Basic-Rubrik des PC-Heimwerkers, im Hugendubelexpress oder im MicroCode! Bis 
zur nchsten Ausgabe! 


                              ****************
                              ***  TEIL 10 ***
                              ****************
Willkommen zum zehnten und vorletzten Teil von The Real Adok's Way to QBASIC! 
Als Hausaufgabe mutet ihr bei unserem File-Viewer seitenweises Anzeigen der 
Datei ergnzen. Eine mgliche Lsung wre folgendes Programm: 
#PROGEIN
'File-Viewer, brauchbare Version

DEFINT A-T

COLOR 15, 1
CLS

PRINT "Dateiname";                'Name der Datei abfragen
COLOR 14
PRINT "? ";
LINE INPUT Datei$

OPEN Datei$ FOR INPUT AS 1        'Datei ffnen

CLS
COLOR 15

'Zeilen einlesen und anzeigen  
Zaehler = 0
DO UNTIL EOF(1)                   'Wenn kein Vergleichoperator vorhanden ist,
 LINE INPUT #1, Zeile$            'wird automatisch <> 0 ergnzt!
 PRINT Zeile$
 Zaehler = Zaehler + 1
 IF Zaehler = 20 THEN
  a$ = INPUT$(1)
  CLS
 END IF
LOOP

CLOSE 1                           'Datei schlieen
#PROGAUS
Heute geht es um SUBs und FUNCTIONs, zwei der wichtigsten Merkmale der 
strukturierten Programmierung. Bevor wir damit anfangen knnen, mssen wir 
zunchst den Unterschied zwischen Befehlen und Funktionen klren. Befehle wie 
PRINT veranlassen den Computer, etwas bestimmtes zu tun, z.B. einen Text 
auszugeben. Es lassen sich Parameter bergeben, die mehrere Optionen mglich 
werden lassen. An Funktionen wie INPUT$ lassen sich auch Parameter bergeben. 
Doch Funktionen sind vielseitig. Eine Funktion gibt nmlich im Gegensatz zu 
einem Befehl einen Wert zurck. Mit diesem Wert kann man nun machen, was man 
will: ihn einer Variablen zuweisen, auf dem Bildschirm ausgeben, testen usw. 
Folgende Anwendungen sind gltig: 
#PROGEIN
a$ = INPUT$(1)            'der Variablen a$ wird das Ergebnis der Funktion 
                          'INPUT$(1) zugewiesen 
PRINT INPUT$(1)           'das Ergebnis der Funktion INPUT$(1), also die 
                          'gedrckte Taste, wird auf dem Bildschirm ausgegeben 
IF INPUT$(1) = "J" THEN...'das Ergebnis der Funktion INPUT$(1) wird mit 
                          '"J" verglichen 
#PROGAUS
Es gibt natrlich auch unzhlige andere Anwendungen, wie z.B. 
'SHELL INPUT$(1)' (sehr sinnig), aber diese sollten das Prinzip klar machen. 
Mit den Befehlen SUB und FUNCTION kann man nun seine eigenen Befehle bzw. 
Funktionen erstellen. Natrlich 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! 
#PROGEIN
'SUB-Demo
DECLARE SUB Hallo ()

DEFINT A-Z
'Beispielprogramm
FOR i = 1 TO 10
 Hallo
NEXT

DEFINT A-Z
'Eigentliche SUB
SUB Hallo
 PRINT "Hallo, Welt!"         'Ein bichen spt, nicht wahr?
END SUB
#PROGAUS
Jetzt werde ich viel erklren mssen. Nach der Zeile 'SUB Hallo' erffnet 
QBasic ein eigenes Fenster fr die SUB. Mit F2 kann man zwischen den Fenstern, 
in denen sich die SUBs und FUNCTIONs befinden, und dem Hauptprogramm hin- und 
herschalten. 
Gehen wir das Programm nun Zeile fr Zeile durch. Wozu Zeile 2 ('DECLARE SUB 
Hallo') gut ist, mt ihr nicht wissen. Sie wird von QBasic automatisch 
eingefgt. In der vierten Zeile werden mit 'DEFINT A-Z' alle Variablen, die 
nicht definiert sind, auf den Datentyp INTEGER gesetzt. Was ich euch in 
Folge 7 noch nicht sagen konnte, weil wir die SUBs und FUNCTIONs nicht 
kannten, ist, da dieser Aufruf nur fr das Hauptprogramm gilt. Fr die SUBs 
und die FUNCTIONs mssen wir 'DEFINT A-Z' extra schreiben. Wir knnen fr sie 
aber auch unabhngig vom Hauptprogramm DEFSNG, DEFLNG etc. verwenden. 
Mit den Zeilen 6 bis 8 wird nun erreicht, da die SUB Hallo zehnmal aufgerufen 
wird. In QBasic und Quick Basic kann man SUBs aufrufen, als wren sie normale 
Befehle. Wir haben beispielsweise nur 'Hallo' schreiben mssen. In Power Basic 
mu man vor jedem Aufruf einer SUB oder einer FUNCTION den Befehl CALL setzen. 
Ab Zeile 10 beginnt nun die eigentliche SUB. Zuerst wird mit DEFINT A-Z 
festgelegt, da auch sie, wenn nichts anderes angegeben wird, mit 
Integerwerten arbeitet. In Zeile 12 befindet sich nun der eigentliche Kern der 
SUB: der SUB-Befehl. Hinter dem Schlsselwort SUB mu der Name der SUB stehen. 
In unserem Beispiel lautet dieser 'Hallo'. Die Befehle, die nun beim Aufruf 
dieser SUB ausgefhrt werden, stehen zwischen der Zeile mit dem Befehl SUB und 
der Zeile 'END SUB'. Im Grunde genommen sind SUBs also nichts anderes als 
Blcke, die man an einer beliebigen Stelle des Hauptprogramms oder einer 
anderen SUB/FUNCTION aufrufen kann. Im Extremfall kann eine SUB sogar ein 
eigenes Programm beinhalten! 
Fassen wir also zusammen: 
Eine SUB ist ein Block von Anweisungen, der an jeder beliebigen Stelle des 
Hauptprogramms oder einer anderen SUB/FUNCTION aufgerufen werden kann. Er 
beginnt mit dem Befehl SUB und endet mit END SUB. Dazwischen befinden sich die 
eigentlichen Befehle. Neben dem Befehl SUB steht der Name dieser SUB. 
Eine SUB wird mit ihrem Namen aufgerufen. In Power Basic mu vorher der Befehl 
CALL stehen. 
SUBs wren nicht SUBs, wenn man sie nicht mit Parametern aufrufen knnte. 
Damit eine SUB mit Parametern aufgerufen werden kann, mssen diese zunchst in 
der Zeile mit dem Befehl SUB neben dem Namen der SUB definiert werden. 
Beispiel: 
#PROGEIN
SUB DruckeText (Text AS STRING, Anzahl AS INTEGER) 
#PROGAUS
Bevor hier jemand in Panik ausbricht, die Erkrung: Wenn die SUB DruckeText 
aufgerufen wird, mssen jetzt zwei Parameter bergeben werden. Wir haben mit 
obiger Zeile definiert, da der erste vom Typ STRING und der zweite vom Typ 
INTEGER sein mu. Text und Anzahl sind Variablennamen, unter denen die SUB 
die beiden Parameter ansprechen kann. Rufen wir jetzt die SUB DruckeText 
beispielsweise mit 
#PROGEIN
CALL DruckeText ("Hallo!", 1000)
#PROGAUS
auf, so erhlt die Variable Text den Wert "Hallo!" und Anzahl den Wert 1000. 
Diese Variablen lassen sich jedoch NUR in der SUB ansprechen, wie wir spter 
erfahren werden. Wird eine SUB mit Parametern aufgerufen, ist CALL brigens 
in allen drei Basic-Dialekten notwendig. 
Damit es jeder kapiert, ein Beispielprogramm: 
#PROGEIN
'Parameter-Demo
DECLARE SUB DruckeText (Text AS STRING, Anzahl AS INTEGER)

DEFINT A-Z
'Beispielprogramm
COLOR 15, 1
CLS
CALL DruckeText("QBasic ist super!", 20)

DEFINT A-Z
'Eigentliche SUB
SUB DruckeText (Text AS STRING, Anzahl AS INTEGER)
 FOR i = 1 TO Anzahl
  PRINT Text
 NEXT
END SUB
#PROGAUS
Falls jemand noch immer Probleme mit den Parametern haben sollte: einfach 
fragen! 
Kommen wir nun zu einem weiteren wichtigen Merkmal von SUBs und FUNCTIONs, den 
lokalen Variablen. Vorhin schrieb ich, da sich die Variablen Text und 
Anzahl nur in der eigentlichen SUB ansprechen lassen. Die Frage ist: Warum? 
Beginnen wir ganz langsam: Auch alle Variablen, die im Hauptprogramm 
verwendet werden, lassen sich NUR im Hauptprogramm ansprechen. Soll eine SUB 
oder eine FUNCTION eine Variable des Hauptprogramms ansprechen knnen, so mu 
diese als Parameter bergeben werden. Ebenso knnen das Hauptprogramm oder 
andere SUBs/FUNCTIONs nicht die Variablen, die in dieser SUB oder FUNCTION 
verwendet werden, ansprechen. Das bedeutet schlicht und einfach: Wenn in 
einer SUB/FUNCTION eine Variable verwendet wird und in einer anderen 
SUB/FUNCTION oder dem Hauptprogramm eine Variable mit demselben Namen 
verwendet wird, so sind das ZWEI VERSCHIEDENE Variablen! Am besten, wir lassen 
das von einem Beispielprogramm demonstrieren. 
#PROGEIN
DECLARE SUB ZeigeText ()
'Lokale Variablen

COLOR , 1
CLS

Text$ = "Tsch!"

ZeigeText

COLOR 15
PRINT "Wir befinden uns im Hauptprogramm. Der Inhalt von Text$ ist: ";
COLOR 14
PRINT Text$

SUB ZeigeText
 Text$ = "Hallo!"
 COLOR 15
 PRINT "Wir befinden uns in der SUB ZeigeText. Der Inhalt von Text$ ist: ";
 COLOR 14
 PRINT Text$
END SUB
#PROGAUS
Wozu sind solche lokalen Variablen gut? Nun, sie haben folgende Vorteile: 
- Jede SUB oder FUNCTION hat ihre eigenen lokalen Variablen. Auch, wenn diese 
  dieselben Namen wie die Variablen aus einer anderen SUB/FUNCTION oder dem 
  Hauptprogramm haben, sind sie 'eigenstndige' Variablen. 
- Nach dem Beenden der SUB/FUNCTION werden alle lokalen Variablen automatisch 
  gelscht. Gebe es keine lokalen Variablen, so mte dies der Programmierer 
  tun. 
Da die lokalen Variablen gelscht werden, kann man brigens dadurch 
verhindern, da man am Schlu der Zeile mit SUB das Schlsselwort STATIC 
schreibt. Es gibt auerdem noch globale Variablen. Diese knnen in allen SUBs, 
FUNCTIONs und im Hauptprogramm angesprochen werden. Um eine globale Variable 
zu erzeugen, mu man sie auf alle Flle mit DIM definieren. Zwischen DIM und 
dem Namen der Variablen mu man aber noch SHARED schreiben. 
Jetzt wissen wir im groen und ganzen, wie man SUBs erzeugt und aufruft. Jetzt 
stellt sich die Frage, wozu solche SUBs berhaupt gut sind. Immerhin lassen 
sich Unterprogramme auch mit GOSUB aufrufen! Die Verwendung von SUBs bringt 
aber folgende Vorteile: 
- Lokale Variablen (siehe oben). 
- bersichtlichkeit. Zumindestens in QBasic und Quick Basic kann man mit F2 
  eine Liste aller SUBs aufrufen und komfortabel zwischen ihnen wechseln. 
- Die SUBs sind vom Hauptprogramm genau abgegrenzt, whrend Unterprogramme, 
  die mit GOSUB aufgerufen werden, Teile des Hauptprogramms sind. Deshalb ist 
  es wichtig, vor die GOSUB-Unterprogramme END zu setzen. Bei SUBs ist dies 
  nicht notwendig. 
Auerdem haben SUBs noch einen Vorteil, den alle Blcke besitzen (und den ich 
euch schon lngst hatte sagen mssen): Es gibt einen Befehl, mit dem man aus 
einem Block "aussteigen" kann. Als Parameter mu der Name des Blocks, aus dem 
ausgestiegen werden soll, angegeben werden, also: EXIT IF, EXIT DO, EXIT FOR, 
EXIT SUB, EXIT FUNCTION,... Als Beispiel hier nochmals die Zhlschleife mit 
DO/LOOP aus Folge 4, diesmal unter Verwendung des EXIT-Befehls. 
#PROGEIN
'Zhlschleife

COLOR 14, 1
CLS

Zaehler = 0
DO
 Zaehler = Zaehler + 1
 PRINT "Schleife wird zum"; Zaehler; ". Mal durchlaufen."

 IF Zaehler = 10 THEN               'Wenn Schleifenzhler 10 erreicht hat,
  EXIT DO                           'wird aus der DO-Schleife
 END IF                             'herausgesprungen.
                                    '  ||
LOOP                                '  ||   hierher wird gesprungen
                                    '  \/
PRINT "Wert des Schleifenzhlers ist"; Zaehler; "=> PROGRAMMABBRUCH."
#PROGAUS
Ihr habt recht, wenn ihr jetzt sagt: "Das geht ja auch mit GOTO!" Aber diese 
Methode ist weder elegant noch speicherplatzsparend (ein zustzliches Label 
mu definiert werden). Damit ihr dies selbst seht, hier die Version mit GOTO: 
#PROGEIN
'Zhlschleife

COLOR 14, 1
CLS

Zaehler = 0
DO
 Zaehler = Zaehler + 1
 PRINT "Schleife wird zum"; Zaehler; ". Mal durchlaufen."

 IF Zaehler = 10 THEN               'Wenn Schleifenzhler 10 erreicht hat,
  GOTO Label                        'wird zu 'Label' gesprungen.
 END IF
                                    
LOOP
                                   
Label:                              'hierher wird gesprungen
PRINT "Wert des Schleifenzhlers ist"; Zaehler; "=> PROGRAMMABBRUCH."
#PROGAUS
Das war brigens unser 35. Beispielprogramm! Super, nicht wahr? 
Jetzt kennen wir uns mit den SUBs bestens aus (sollten wir zumindest). Nun 
kommen die FUNCTIONs an die Reihe. Sie sind im Grunde genommen bis auf 
folgende Unterschiede mit den SUBs identisch: 
- In der Anfangszeile wird statt SUB FUNCTION geschrieben. 
- Ebenso in der Endzeile. 
- Am Ende des Namens der FUNCTION steht ein Zeichen, das angibt, welchen 
  Datentyp der Rckgabewert besitzt. Folgende Zeichen sind zulssig: 
  %...Integer, 
  &...Long, 
  !...Single, 
  #...Double, 
  $...String. 
- Der Rckgabewert mu vor dem Ende der FUNCTION in einer Variablen 
  gespeichert werden, die genauso wie die FUNCTION heit (inklusive des 
  letzten Zeichens). 
- FUNCTIONs werden nicht wie Befehle, sondern wie Funktionen aufgerufen. 
Als Beispiel habe ich ein Programm geschrieben, mit dem man die n-te Wurzel 
einer Zahl ausrechnen kann. Ich verwendete dazu den Operator '^' (hoch). 
#PROGEIN
'FUNCTION-Demo    
DECLARE FUNCTION nteWurzel# (Zahl AS DOUBLE, n AS DOUBLE)

DEFDBL A-Z

COLOR 15, 1
CLS

PRINT "Von welcher Zahl soll die n-te Wurzel ausgerechnet werden";
COLOR 14
INPUT Zahl

PRINT
COLOR 15
PRINT "Wieviel ist n";
COLOR 14
INPUT n

PRINT
COLOR 15
IF n = 0 THEN
 PRINT "Die 0-te Wurzel kann nicht ausgerechnet werden!"
ELSE
 PRINT "Die n-te Wurzel der Zahl ist";
 COLOR 14
 PRINT nteWurzel#(Zahl, n);
 COLOR 15
 PRINT "."
END IF

DEFDBL A-Z
FUNCTION nteWurzel# (Zahl AS DOUBLE, n AS DOUBLE)
 nteWurzel# = Zahl ^ (1 / n)
END FUNCTION
#PROGAUS
Die mathematische Formel mchte ich euch nicht erklren (mte in jedem 
Mathe-Lexikon stehen), es sei aber gesagt, da sie dank den DOUBLE-Variablen 
mit einer sehr hohen Rechengenauigkeit von 15 (!) Nachkommastellen rechnet. 
Die Funktion nteWurzel# ist brigens Bestandteil der Toolbox, die in der 
nchsten oder der bernchsten Folge verffentlicht wird. 
In der nchsten Folge hatte ich ursprnglich vor, einige ntzliche Befehle 
aufzulisten, die ihr dann in der Online-Hilfe nachlesen knnt. Mittlerweile 
stellte ich jedoch fest, da die meisten dieser Befehle zur Stringbearbeitung 
dienen. Deshalb entschliee ich mich, die nchste Folge ganz allein den 
Strings zu widmen. 


                              ****************
                              ***  TEIL 11 ***
                              ****************
Willkommen zum elften und vorlufig letzten Teil von The Real Adok's Way to 
QBASIC! Wie bereits in der letzten Folge angekndigt, mchte ich mich heute 
besonders den Strings widmen. Auerdem verffentliche ich eine kleine 
Toolbox mit ntzlichen SUBs und FUNCTIONs. 
Ich mchte euch jetzt eine Reihe von Funktionen zur Stringbearbeitung 
vorstellen. 
- Funktion ASC. Syntax: Variable = ASC(Zeichen). Das Ergebnis ist der 
  ASCII-Code des angegebenen Zeichens. In der Online-Hilfe sind alle 
  ASCII-Codes zusammengefat. Beispiel: 
#PROGEIN
'ASC-Demo

DIM Zeichen AS STRING * 1

COLOR 15, 1
CLS

PRINT "Gib ein beliebiges Zeichen ein!"
Zeichen = INPUT$(1)

PRINT
PRINT "Du hast das Zeichen ";
COLOR 14
PRINT Zeichen;
COLOR 15
PRINT " eingegeben. Sein ASCII-Code lautet";
COLOR 14
PRINT ASC(Zeichen);
COLOR 15
PRINT "."
#PROGAUS
- Funktion CHR$. Syntax: Stringvariable = CHR$(ASCIICode). Das Ergebnis ist 
  das Zeichen mit dem angegebenen ASCII-Code. In der Online-Hilfe sind alle 
  ASCII-Codes zusammengefat. Beispiel: 
#PROGEIN
'CHR$-Demo

DIM ASCIICode AS INTEGER                     'Wer Power Basic verwendet, kann
                                             'hier auch BYTE schreiben.
COLOR , 1

DO
 CLS
 COLOR 15
 PRINT "Gib eine Zahl von 0 bis 255 ein!"
 COLOR 14
 INPUT ASCIICode
LOOP UNTIL ASCIICode >= 0 AND ASCIICode <= 255

COLOR 15
PRINT "Das Zeichen mit diesem ASCII-Code ist ";
COLOR 14
PRINT CHR$(ASCIICode);
COLOR 15
PRINT "."
#PROGAUS
  CHR$(7) ist insofern eine Ausnahme, als da 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: 
#PROGEIN
'Fr Verliebte

COLOR 13, 0
CLS

FOR i = 1 TO 24
 PRINT STRING$(80, CHR$(3))
NEXT
PRINT STRING$(80, CHR$(3));
a$ = INPUT$(1)
#PROGAUS
- Funktion MID$. Syntax: Stringvariable = MID$(Zeichenkette, x, y). Das 
  Ergebnis ist ein Teilstring der angegebenen Zeichenkette. Er beginnt mit 
  dem x-ten Zeichen der ursprnglichen Zeichenkette und ist y Zeichen lang. 
  'y' kann auch weggelassen werden. Dann reicht der Teilstring bis zum Ende 
  der Zeichenkette. Da sich dies komplizierter anhrt, als es in Wirklichkeit 
  ist, hier ein Beispiel: 
#PROGEIN
'MID$-Demo

COLOR 15, 1
CLS

PRINT "Gib eine Zeichenkette ein!"
COLOR 14
LINE INPUT Zeichenkette$

PRINT
COLOR 15
PRINT "Die ersten sechs Zeichen der eingegebenen Zeichenkette lauten ";
COLOR 14
PRINT MID$(Zeichenkette$, 1, 6);
COLOR 15
PRINT "."

PRINT
PRINT "Die Zeichen 2 bis 4 lauten ";
COLOR 14
PRINT MID$(Zeichenkette$, 2, 3);
COLOR 15
PRINT "."
#PROGAUS
  Siehe dazu auch: LEFT$, RIGHT$ (Online-Hilfe). 
- Funktion LTRIM$. Syntax: Stringvariable = LTRIM$(Zeichenkette). Das 
  Ergebnis ist ein String, der der ursprnglichen Zeichenkette gleicht, nur 
  ohne berflssige Leerzeichen vor dem eigentlichen Text. Siehe dazu auch: 
  RTRIM$ (Online-Hilfe). 
- Funktion LEN. Syntax: Variable = LEN(Zeichenkette). Das Ergebnis ist die 
  Lnge der Zeichenkette. 
- Funktion UCASE$. Syntax: Stringvariable = UCASE$(Zeichenkette). Das Ergebnis 
  gleicht der ursprnglichen Zeichenkette, nur die Kleinbuchstaben sind in 
  Grobuchstaben umgewandelt worden. Siehe auch: LCASE$ (Online-Hilfe). 
- Funktion STR$. Syntax: Stringvariable = STR$(Variable). Diese Funktion 
  wandelt eine Zahlenvariable in einen String um. Dieser String kann dann 
  wie alle anderen Strings bearbeitet werden. Beispiel: 
#PROGEIN
'STR$-Demo

COLOR 15, 1
CLS

PRINT
PRINT "              1000 + 1000 = ";
COLOR 14
PRINT 1000 + 1000

COLOR 15
PRINT "  STR$(1000) + STR$(1000) = ";
COLOR 14
PRINT STR$(1000) + STR$(1000)
#PROGAUS
  Wozu ist die STR$-Funktion sonst noch gut? Wenn wir bisher Zahlen auf dem 
  Bildschirm ausgaben, wurde vor und nach der Zahl jeweils ein Leerzeichen 
  ausgegeben. Wenn man STR$ in Kombination mit LTRIM$ und RTRIM$ verwendet, 
  kann man dieses Problem umgehen, wie nachfolgendes Programm zeigt: 
#PROGEIN
'Ausgabe von Zahlenvariablen

COLOR 10, 1
CLS

PRINT "Direkte Ausgabe"
COLOR 15
PRINT "Die Zahl lautet ";
COLOR 14
PRINT 1000;
COLOR 15
PRINT "."
PRINT

COLOR 10
PRINT "Mit STR$, LTRIM$ und RTRIM$"
COLOR 15
PRINT "Die Zahl lautet ";
COLOR 14
PRINT LTRIM$(RTRIM$(STR$(1000)));
COLOR 15
PRINT "."
#PROGAUS
- VAL ist das genaue Gegenteil von STR$. Mit ihm kann man eine Zahlenvariable 
  in einen String umwandeln. Dies hat folgenden Vorteil: Habt ihr schon 
  probiert, was passiert, wenn ihr in unserem Megarechenprogramm statt einer 
  Zahl eine Zeichenkette eingebt? Um diese dumme Fehlermeldung zu umgehen, 
  kann man den INPUT-Befehl durch einen LINE INPUT-Befehl ersetzen und 
  anschlieend die eingegebene Zeichenkette in eine Zahl umwandeln. 
Mit den neuen Befehlen habe ich das Megarechenprogramm verbessert. Hier ist 
nun die neueste Version. 
#PROGEIN
'DAS MEGARECHENPROGRAMM!!!!                   VERSION 6
'... aus The Real Adok's Way to QBASIC.

DECLARE SUB Titelbild ()                'Deklaration der SUB Titelbild
DECLARE SUB Titelmusik ()               'Deklaration der SUB Titelmusik

'+++ Variablenzuweisungen
DEFINT A-Z                              'Variablen ohne Kennung sind Integer
DIM Zahl(1 TO 2) AS SINGLE              'Array Zahl

blau = 1                                'Farbe Blau
gelb = 14                               'Farbe Gelb
weiss = 7                               'Farbe Wei
hell = 8                                'Zusatz fr Helligkeit


'+++ Hauptprogramm
SCREEN 9                                'EGA-Grafik
Titelbild                               'Aufruf der SUB Titelbild
Titelmusik                              'Aufruf der SUB Titelmusik
a$ = INPUT$(1)                          'Auf Tastendruck warten

Start:
 COLOR , blau                           'Blauer Hintergrund
 CLS                                    'Bildschirm lschen
                                     
 DO                                      'Eingabe der ersten Zahl    
  COLOR hell + weiss                     '
  LOCATE 2, 2                            '
  PRINT "Wie lautet die erste Zahl";     '
  COLOR gelb                             '
  PRINT "? ";                            '
  LINE INPUT Temp$                       '
  Temp$ = LTRIM$(RTRIM$(Temp$))          '
  Zahl(1) = VAL(Temp$)                   '
 LOOP UNTIL Temp$ = LTRIM$(RTRIM$(STR$(Zahl(1))))

 DO                                      'Eingabe der zweiten Zahl
  COLOR hell + weiss                     '
  LOCATE 5, 2                            '
  PRINT "Wie lautet die zweite Zahl";    '
  COLOR gelb                             '
  PRINT "? ";                            '
  LINE INPUT Temp$                       '
  Temp$ = LTRIM$(RTRIM$(Temp$))          '
  Zahl(2) = VAL(Temp$)                   '
 LOOP UNTIL Temp$ = LTRIM$(RTRIM$(STR$(Zahl(2))))

 CLS                                    'Bildschirm lschen
 COLOR hell + weiss                     'Erste Zahl ausgeben
 LOCATE 2, 2                            '
 PRINT "Zahl 1:";                       '
 COLOR gelb                             '
 PRINT Zahl(1);                         '

 COLOR hell + weiss                     'Zweite Zahl ausgeben
 LOCATE , 60                            '
 PRINT "Zahl 2:";                       '
 COLOR gelb                             '
 PRINT Zahl(2)                          '

 COLOR hell + weiss                     'Verzierungsstrichlein ausgeben
 LOCATE 3, 1                            '
 PRINT "-----------------------";       '
 PRINT "-----------------------";       '
 PRINT "-----------------------";       '
 PRINT "-----------"                    '

 COLOR hell + weiss                     'Ergebnis der Addition ausgeben
 LOCATE 5, 2                            '
 PRINT "Addition:";                     '
 COLOR gelb                             '
 LOCATE , 17                            '
 PRINT Zahl(1) + Zahl(2)                '

 COLOR hell + weiss                     'Ergebnis der Subtraktion ausgeben
 LOCATE 6, 2                            '
 PRINT "Subtraktion:";                  '
 COLOR gelb                             '
 LOCATE , 17                            '
 PRINT Zahl(1) - Zahl(2)                '

 COLOR hell + weiss                     'Ergebnis der Multiplikation ausgeben
 LOCATE 7, 2                            '
 PRINT "Multiplikation:";               '
 COLOR gelb                             '
 LOCATE , 17                            '
 PRINT Zahl(1) * Zahl(2)                '

 COLOR hell + weiss                     'Ergebnis der Division ausgeben
 LOCATE 8, 2                            '
 PRINT "Division:";                     '
 COLOR gelb                             '
 LOCATE , 17                            '
 IF Zahl(2) = 0 THEN                    '
  PRINT " Division durch Null!"         '
 ELSE                                   '
  PRINT Zahl(1) / Zahl(2)               '
 END IF

 PLAY "t200 l8 o5 ddd p64 l2 g"         'Musik

 DO                                     'Abfrage, ob noch eine Berechnung
  COLOR hell + weiss                    '
  LOCATE 18, 2                          '
  PRINT "Noch eine Berechnung (J/N)";   '
  COLOR gelb                            '
  PRINT "?"                             '
  Wahl$ = UCASE$(INPUT$(1))             '
 LOOP UNTIL Wahl$ = "J" OR Wahl$ = "N"  '

 SELECT CASE Wahl$                      'Auswertung der Wahl
  CASE "J"                              '
   GOTO Start                           '
  CASE ELSE                             '
   END                                  '
 END SELECT                             '

'+++ Ende des Programms.

                                        'Variablen ohne Kennung sind Integer
SUB Titelbild                           'Anfang der SUB
 LOCATE 3, 27                           'Titelschrift
 PRINT "DAS MEGARECHENPROGRAMM!!!!"     '
 LOCATE 5, 21                           '
 PRINT "... aus The Real Adok's Way to QBASIC."

 CIRCLE (320, 200), 100, 9              'Kopf
 PAINT (320, 200), 9, 9                 '

 CIRCLE (280, 166), 30, 14              'Linkes Auge
 PAINT (280, 166), 14, 14               '

 CIRCLE (360, 166), 30, 14              'Rechtes Auge
 PAINT (360, 166), 14, 14               '

 CIRCLE (280, 166), 10, 2               'Linke Pupille
 PAINT (280, 166), 2, 2                 '

 CIRCLE (360, 166), 10, 2               'Rechte Pupille
 PAINT (360, 166), 2, 2                 '

 LINE (320, 180)-(320, 240), 15         'Nase

 LINE (260, 220)-(320, 260), 4          'Mund
 LINE (320, 260)-(380, 220), 4          '
END SUB                                 'Ende der SUB

                                        'Variablen ohne Kennung sind Integer
SUB Titelmusik                          'Anfang der SUB
 PLAY "t120 l8 o4"                      'Der Lrm fngt an!
 PLAY "g g g > c c c < l4 a f c"        '
 PLAY "l8 g g g > c c c l4 d < b g"     '
 PLAY "l8 b- b- b- > e- e- e- l4 d < b- f"
 PLAY "l8 e- e- e- a- a- a- l4 g > l8 e p8 < l4 c"
END SUB                                 'Ende der SUB
#PROGAUS
Weil es so schn war, habe ich auch alle GOSUB-Unterprogramme durch SUBs 
ersetzt. Fr den User sind zwar Version 5 und 6 unseres Megarechenprogramms 
identisch, nicht jedoch fr den Programmierer. Super, jetzt haben wir schon 
ein brauchbares Programm auf die Beine gestellt! 
Als nchstes folgt endlich die lang erwartete QBasic-Toolbox. Einige der 
Befehle, die ich hier verwende, haben wir noch nicht gelernt. Wer es 
unbedingt will, kann ja in der Online-Hilfe nachsehen. 
#PROGEIN
'The Real Adok's Way to QBASIC Library

DECLARE SUB CloseProg ()
DECLARE SUB cPrint (Text AS STRING)
DECLARE FUNCTION Formatted$ (Zahl AS INTEGER)
DECLARE FUNCTION nteWurzel# (Zahl AS DOUBLE, n AS DOUBLE)
DECLARE FUNCTION ZufallsZahl% (Min AS INTEGER, Max AS INTEGER)

DEFINT A-Z
RANDOMIZE TIMER

SUB CloseProg
 SCREEN 0, 0, 0, 0
 WIDTH 80
 COLOR 7, 0, 0
 CLS
 END
END SUB

SUB cPrint (Text AS STRING)
 LOCATE , INT((80 - LEN(Text)) / 2)
 PRINT Text;
END SUB

FUNCTION Formatted$ (Zahl AS INTEGER)
 Formatted$ = LTRIM$(RTRIM$(STR$(Zahl)))
END FUNCTION

DEFDBL A-Z
FUNCTION nteWurzel# (Zahl AS DOUBLE, n AS DOUBLE)
 nteWurzel# = Zahl ^ (1 / n)
END FUNCTION

DEFINT A-Z
FUNCTION ZufallsZahl% (Min AS INTEGER, Max AS INTEGER)
 ZufallsZahl% = INT(RND * (1 + Max - Min) + Min)
END FUNCTION
#PROGAUS
Eine kleine Dokumentation der SUBs und FUNCTIONs: 
- SUB CloseProg: Ersatz fr den END-Befehl. Sollte am Ende jedes Programms 
  aufgerufen werden. 
- SUB cPrint: Als Parameter mu eine Zeichenkette angegeben werden. Diese wird 
  dann zentriert auf dem Bildschirm ausgegeben. 
- FUNCTION Formatted$: Als Parameter mu eine Integervariable angegeben 
  werden. Diese wird dann in einen String umgewandelt. berflssige 
  Leerzeichen werden abgeschnitten. Diese FUNCTION ist besonders gut fr die 
  Ausgabe von Zahlen geeignet. Sie lt sich auch leicht an Fliekommazahlen 
  anpassen. 
- FUNCTION nteWurzel#: Als Parameter mssen zwei Variablen vom Typ DOUBLE 
  angegeben werden. Diese FUNCTION haben wir ja schon in der letzten Folge 
  besprochen. 
- FUNCTION ZufallsZahl%: Als Parameter mssen zwei Integervariablen 
  bergeben werden. Diese bestimmen die Unter- und die Obergrenze fr die 
  zu erzeugende Zufallszahl. Die Zufallszahl ist vom Typ INTEGER. Der Typ 
  lt sich aber leicht ndern. Falls Fliekommazahlen erzeugt werden sollen, 
  mu noch zustzlich der INT-Befehl verndert werden. 
Das war auch schon The Real Adok's Way to QBASIC. Ich hoffe, da es euch Spa 
gemacht hat und ihr auch etwas dabei gelernt habt. Eine kleine Statistik: 
In 11 Folgen verffentlichte ich insgesamt 43 Beispielprogramme, gab euch aber 
nur 8 Hausaufgaben. Unter den Beispielprogrammen befanden sich viele 
ntzliche Programme, darunter auch drei grere Projekte: ein Adventure, ein 
Rechenprogramm und eine Toolbox. 
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 Mhe und Zeit, die ich in den Kurs investiert habe, hat sich 
gelohnt und euch geholfen, sich mit der Programmiersprache QBasic vertraut zu 
machen. Ich bin gerne bereit, euch bei Problemen zu helfen. 
Mit den Befehlen und Funktionen, die ihr in diesem Kurs erlernt habt, knnt 
ihr schon eine ganze Menge anfangen. Alles andere hngt von eurer 
Vorstellungskraft, Phantasie, Ideen ab. 
Mit dem Erlernen einer Programmiersprache erffnet sich einem eine neue Welt. 
Nun kann man mit dem Computer kommunizieren, ihm eigene Ideen verstndlich 
machen und seine ungeahnte Mglichkeiten fr eigene Zwecke ntzen. Jeder, ob 
in der Schule oder im Beruf, ist laufend mit Problem konfrontiert, die er mit 
Hilfe des Computers wesentlich vereinfachen und lsen kann. 
Man soll aber nicht dabei bleiben, nur die Routinearbeiten zu erledigen. 
Wichtig wre es, neue Ideen umzusetzen, etwas Neues zu schaffen. 
Wenn man eine Programmiersprache erlernt hat, heit es aber noch lange nicht, 
da man nichts mehr Neues dazulernen kann. Es gibt hier keine Grenzen. Alles 
hngt 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... 
