QBasic unter DOS – Zurück zu den Anfängen

Die Welt der Programmiersprachen hat sich in den letzten Jahrzehnten enorm weiterentwickelt. Doch manchmal ist es auch schön, in die Vergangenheit zu reisen und sich mit den Wurzeln der Programmierung auseinanderzusetzen. Eine solche Reise führt uns zu QBasic unter MS-DOS, einer beliebten Programmiersprache der 90er Jahre.

Was ist QBasic?

QBasic steht für “Quick Beginners All-purpose Symbolic Instruction Code” und wurde von Microsoft entwickelt. Es handelt sich um eine einfache, aber dennoch leistungsstarke Programmiersprache, die insbesondere für Anfänger geeignet ist. QBasic wurde mit MS-DOS-Betriebssystemen ausgeliefert und erfreute sich großer Beliebtheit aufgrund seiner einfachen Syntax und der Möglichkeit, schnell Ergebnisse zu erzielen.

Was ist QuickBASIC?

QuickBASIC ist eine Weiterentwicklung von QBasic und wurde erstmals 1987 veröffentlicht. Im Vergleich besitzt QuickBASIC eine leistungsstärkere und umfangreichere Entwicklungsumgebung mit mehr Funktionen und Möglichkeiten.

  • QuickBASIC unterstützt sowohl den Interpreter-Modus als auch den Compiler-Modus, was es ermöglicht, Programme in ausführbare Dateien zu kompilieren und unabhängig von der QuickBASIC-Umgebung auszuführen. Dies führte zu einer verbesserten Leistung
  • QuickBASIC bietet erweiterte Funktionen für die Grafik- und Soundausgabe, was die Erstellung von einfachen Spielen und Multimedia-Anwendungen ermöglicht
  • Die Sprache ist durch zusätzliche Funktionen und Bibliotheken erweitert, die die Entwicklung komplexerer Anwendungen erleichtert

Da Programme, die in QBasic geschrieben wurden, in der Regel auch unter QuickBASIC laufen, beschreibe ich im weiteren Ablauf die Nutzung von QuickBASIC.

Das Nerd-ABC: Das ABC der Videospiele: Alles, was Gamer…*
  • Marke: Lappan Verlag
  • Das Nerd-ABC: Das ABC der Videospiele: Alles, was Gamer über Videospielgeschichte wissen müssen…

Letzte Aktualisierung am 28.02.2024 / Affiliate Links / Bilder von der Amazon Product Advertising API

Installation DOSBox und einbinden eures Laufwerks

Als erstes benötigt ihr einen DOS-Emulator oder eine virtuelle Maschine mit DOS. Für virtuelle Maschinen könnt ihr Programme nutzen wie VMWare Player, Oracle Virtualbox, etc. Ich finde aber die Emulator-Lösung am schönsten und beschreibe euch daher hier den Weg mit DOSBox. Dazu sind folgende Schritte notwendig:

  • Öffnet euren Webbrowser und besucht die offizielle DOSBox-Website, um die neueste Version herunterzuladen
  • Ladet die passende Version für euer Betriebssystem herunter (z. B. Windows, macOS, Linux) und führt die Installationsdatei aus
  • Befolgt die Anweisungen im Installationsassistenten, um DOSBox auf eurem Computer zu installieren
  • Öffnet den Windows Explorer oder den Datei-Explorer
  • Navigiert zum gewünschten Speicherort, an dem ihr euren DOS-Ordner erstellen möchtet (z. B. C:\DOS). Dies ist später die “Verbindung” zwischen eurem Rechner und der emulierten DOS-Welt
  • startet DOSBox und gebt folgenden Befehlt ein um die Verbindung herzustellen: mount c C:\DOS
  • wechselt nun in DOSBox auf das Laufwerk C mit dem Befehl c:
  • Alles, was ihr ab sofort auf eurem Rechner im Ordner C:\DOS abspeichert ist auch in DOSBox auf Laufwerk C zu sehen
  • geht auf die Webseite des QBasic Café und ladet dort QuickBASIC 4.5 in Deutsch herunter. Den Link findet ihr hier
  • Entpackt den Inhalt der ZIP-Datei ins Verzeichnis C:\DOS
  • gebt in DOSBox den Befehl qb.exe ein und QuickBasic wird gestartet
Addition von zwei Zahlen unter QBasic
QBasic wurde gestartet, hier ist schon die Beispieldatei geladen

ein erstes, einfaches Beispiel

Als erstes beschäftigen wir uns mit der Verwendung von Variablen und der Durchführung von Berechnungen. Hier ist ein einfaches Beispiel, das zwei Zahlen addiert und das Ergebnis ausgibt. Am besten öffnet ihr Notepad auf eurem PC, kopiert den Code dort hinein und speichert die Datei anschließend im Ordner C:\DOS unter einem Dateinamen mit Endung .bas. Wer mag kann auch den gesamten Code abtippen, das wäre mir aber zu anstrengend 🙂

CLS
PRINT "Geben Sie die erste Zahl ein:"
INPUT a
PRINT "Geben Sie die zweite Zahl ein:"
INPUT b
sum = a + b
PRINT "Die Summe ist: "; sum

In diesem Beispiel löscht CLS den Bildschirm, INPUT ermöglicht die Eingabe von Werten, und PRINT gibt den Text oder das Ergebnis auf dem Bildschirm aus. Die Variable sum speichert das Ergebnis der Addition.

Ausgabe des Beispielprogramms
Ausgabe des Beispielprogramms

Einen Sound ausgeben

In diesem Beispiel verwenden wir die SOUND-Anweisung, um einen Ton mit einer Frequenz von 500 Hz und einer Dauer von 5 Millisekunden abzuspielen. Danach warten wir eine Weile, um den Ton zu hören, indem wir eine einfache Schleife mit 1000 Durchläufen ausführen. Anschließend schalten wir den Sound mit SOUND 0 aus.

SOUND 500, 5


FOR i = 1 TO 1000
NEXT i


SOUND 0, 0
Atari Flashback Gold Special Edition 50. Geburtstag –…*
  • [SPEZIELLE EDITION] Konsole Atari Flashback Gold Special Edition 50. Geburtstag.
  • [SPIELE] Die Konsole enthält 130 klassische Atari-Konsolenspiele wie „Air-Sea Battle“,…

Letzte Aktualisierung am 28.02.2024 / Affiliate Links / Bilder von der Amazon Product Advertising API

Tonleiter abspielen

Jetzt steigern wir den Schwierigkeitsgrad und spielen gleich die ganze Tonleiter, indem wir die Frequenzen der Noten hinterlegen.

DIM Melodie$(200)
Melodie$ = "C D E F G A B "

CLS
PRINT "Spiele Tonleiter"

CONST E = 329.63
CONST F = 349.23
CONST G = 392.00
CONST D = 293.66
CONST C = 261.63
CONST A = 440.00
CONST B = 466.16

DEF SEG = VARSEG(Melodie$)
FOR i = 1 TO 100 STEP 2
    t$ = MID$(Melodie$, i, 2)
    SELECT CASE t$
        CASE "E "
            SOUND E, 18.2
        CASE "F "
            SOUND F, 18.2
        CASE "G "
            SOUND G, 18.2
        CASE "D "
            SOUND D, 18.2
        CASE "C "
            SOUND C, 18.2
	    CASE "A "
            SOUND A, 18.2
	    CASE "B "
            SOUND B, 18.2
    END SELECT
NEXT i

END

Hier eine detaillierte Erklärung, was der Quelltext macht:

  • DIM Melodie$(200): Es wird ein String-Array mit dem Namen Melodie$ erstellt, das 200 Elemente (0 bis 199) speichern kann. Jedes Element kann einen Zeichenkettenwert (String) aufnehmen.
  • Melodie$ = "C D E F G A B ": Dem Melodie$-Array wird eine Zeichenkette zugewiesen, die die Notennamen der Tonleiter enthält (C, D, E, F, G, A, B). Zwischen den Notennamen gibt es Leerzeichen als Trennzeichen.
  • CLS: Der Bildschirm wird geleert, um eine saubere Ausgabe zu ermöglichen.
  • PRINT "Spiele Tonleiter": Eine Meldung “Spiele Tonleiter” wird auf dem Bildschirm ausgegeben.
  • CONST E = 329.63, CONST F = 349.23, usw.: Es werden Konstanten für die Frequenzen der einzelnen Noten erstellt. Die verwendeten Frequenzen entsprechen den Standardfrequenzen in Hertz (Hz) für die jeweiligen Noten.
  • DEF SEG = VARSEG(Melodie$): Mit dieser Anweisung wird der Datenbereich (Segment) des Melodie$-Arrays ausgewählt, damit auf die Noten im Array zugegriffen werden kann.
  • FOR i = 1 TO 100 STEP 2: Hier beginnt eine Schleife, die von 1 bis 100 läuft, wobei i jeweils um 2 erhöht wird. Dadurch wird sichergestellt, dass nur die ungeraden Elemente im Melodie$-Array verwendet werden (die Note selbst und das Leerzeichen als Trennzeichen).
  • t$ = MID$(Melodie$, i, 2): Die Funktion MID$ wird verwendet, um aus dem Melodie$-Array eine zweistellige Zeichenkette (Note und Leerzeichen) auszulesen und in der Variablen t$ zu speichern.
  • SELECT CASE t$: Es wird eine Auswahlstruktur (Switch-Case) basierend auf dem Wert von t$ gestartet, um die entsprechende Note abzuspielen.
  • In den CASE-Zweigen wird jede Note basierend auf ihrer Frequenz über den Befehl SOUND abgespielt. Die Zahl 18.2 ist die Länge (in Millisekunden), für die der Ton gespielt wird.
  • NEXT i: Die Schleife wird beendet, und der Code wird nach dem Abspielen der gesamten Tonleiter fortgesetzt.
  • END: Das Programm wird beendet.

Damit seid ihr in der Lage ganze Lieder zu spielen. Natürlich müssten noch Werte für ganze Noten, halbe Noten, usw. sowie Pausen hinzugefügt werden.

Grafik kommt ins Spiel – der Code

Jetzt können wir schon etwas hören, nun möchten wir aber auch etwas sehen. Daher hier ein Beispiel, bei dem sich ein Quadrat nach unten rechts bewegt. Stößt das Quadrat an den Bildschirmrand, wechselt es die Richtung:

SCREEN 12

CLS

DIM SHARED x, y, dx, dy AS INTEGER
x = 320
y = 240
dx = 1
dy = 1

DO
    x = x + dx
    y = y + dy

    IF x <= 0 OR x >= 620 THEN
        dx = -dx
    END IF

    IF y <= 0 OR y >= 460 THEN
        dy = -dy
    END IF

    CLS
    COLOR 14
    LINE (x, y)-(x + 40, y + 40), , BF

    FOR i = 1 TO 10000
    NEXT i

LOOP UNTIL INKEY$ = CHR$(27)

SCREEN 0
CLS

Grafik kommt ins Spiel – die Erklärung

Ein einfaches, sich bewegendes Quadrat
Ein einfaches, sich bewegendes Quadrat in QBasic

Hier wieder eine ausführliche Erklärung für die einzelnen Schritte im Programm:

  • SCREEN 12: Dieser Befehl setzt die Grafikbildschirm-Modus auf 320×200 Pixel mit 256 Farben (Screen Mode 12).
  • CLS: Dieser Befehl löscht den Bildschirm, um eine leere Zeichenfläche zu schaffen.
  • DIM SHARED x, y, dx, dy AS INTEGER: Hier werden vier Integer-Variablen deklariert, die im gesamten Programm gemeinsam genutzt werden können. Diese Variablen sind x, y, dx und dy.
  • x = 320: Hier wird die Startposition des Objekts auf der X-Achse des Bildschirms festgelegt.
  • y = 240: Hier wird die Startposition des Objekts auf der Y-Achse des Bildschirms festgelegt.
  • dx = 1: Hier wird die Bewegungsgeschwindigkeit des Objekts in horizontaler Richtung festgelegt (1 Pixel pro Schritt).
  • dy = 1: Hier wird die Bewegungsgeschwindigkeit des Objekts in vertikaler Richtung festgelegt (1 Pixel pro Schritt).
  • DO: Hier beginnt eine Schleife, die die Animation kontinuierlich ausführt.
  • x = x + dx: Hier wird die X-Position des Objekts um die Bewegungsgeschwindigkeit in horizontaler Richtung (dx) erhöht, um die Bewegung zu simulieren.
  • y = y + dy: Hier wird die Y-Position des Objekts um die Bewegungsgeschwindigkeit in vertikaler Richtung (dy) erhöht, um die Bewegung zu simulieren.
  • IF x <= 0 OR x >= 620 THEN dx = -dx: Diese Bedingung überprüft, ob das Objekt den linken oder rechten Rand des Bildschirms erreicht hat. Wenn ja, ändert sich die Bewegungsrichtung in horizontaler Richtung (dx wird negiert), um das Objekt umkehren zu lassen.
  • IF y <= 0 OR y >= 460 THEN dy = -dy: Diese Bedingung überprüft, ob das Objekt den oberen oder unteren Rand des Bildschirms erreicht hat. Wenn ja, ändert sich die Bewegungsrichtung in vertikaler Richtung (dy wird negiert), um das Objekt umkehren zu lassen.
  • CLS: Hier wird der Bildschirm gelöscht, um das Objekt in seiner vorherigen Position zu entfernen.
  • COLOR 14: Hier wird die Farbe auf Gelb (Farbindex 14) gesetzt.
  • LINE (x, y)-(x + 40, y + 40), , BF: Hier wird ein gelbes Rechteck gezeichnet, dessen obere linke Ecke bei (x, y) liegt und dessen untere rechte Ecke bei (x + 40, y + 40) liegt. Das “BF” steht für “Box-Filled” und füllt das Rechteck mit der gewählten Farbe.
  • FOR i = 1 TO 10000 NEXT i: Dies ist eine kleine Verzögerungsschleife, die dazu dient, die Animation langsamer ablaufen zu lassen. Sie führt eine Schleife mit 10000 Durchläufen durch, ohne dabei irgendetwas zu tun, was einige Millisekunden dauern kann.
  • LOOP UNTIL INKEY$ = CHR$(27): Hier wird die Schleife fortgesetzt, solange die Escape-Taste (ASCII-Code 27) nicht gedrückt wird. Sobald die Escape-Taste gedrückt wird, endet die Schleife und das Programm wird beendet.
  • SCREEN 0: Hier wird der Grafikbildschirmmodus auf den Standardmodus zurückgesetzt (Textmodus).
  • CLS: Der Bildschirm wird erneut gelöscht, um eine leere Zeichenfläche zu schaffen, bevor das Programm beendet wird.

Beenden könnt ihr das Programm, indem ihr die ESC-Taste drückt. Die Ausgabe sollte wie in diesem Screenshot aussehen.

Letzte Aktualisierung am 28.02.2024 / Affiliate Links / Bilder von der Amazon Product Advertising API

Beitrag teilen

Schreibe einen Kommentar

Deine E-Mail-Adresse wird nicht veröffentlicht. Erforderliche Felder sind mit * markiert

Cookie Consent Banner von Real Cookie Banner