Wir benötigen im Hauptprogramm auch noch einige globale Variablen für unser Spiel:

Das KEY_DOWN()-Datenfeld gibt für 255 verschiedene Tasten(-codes) an, ob die entsprechende Taste gedrückt ist oder nicht. KEY_LAST gibt die zuletzt betätigte Taste an. PFAD$ ist, wie im letzten Spiel auch, eine globale Variable, die den Pfad setzt, in dem die Spieldaten zu finden sind. SICHT_X und SICHT_Y geben die Scrollposition des Spielfelds und aller Objekte in X- und Y-Richtung an.

COUNT_DOTS gibt an, wie viele essbare Punkte, also diesen typischen runden gelben Dinger die in jedem PACMAN-Spiel vorkommen, sich auf dem Spielfeld befinden. Damit wird überprüft, ob der Spieler alle Punkte eingesammelt hat oder nicht. LEVEL_SCORE gibt die Punktzahl an, die insgesamt in dem Level erreicht worden ist. LEVEL_NEXT gibt an, ob der Spieler das nächste Level erreicht hat oder "gestorben" ist. Die Variable HIGHSCORE_EINTRAGEN dient dazu, der späteren Form für die Highscore-Liste mitzuteilen, ob sie prüfen soll, ob sich der Spieler eintragen kann (=1) oder ob er sie nur ansehen will (=0).

Und nun noch die wichtigsten zwei Datenfelder:

Nun haben wir für das Spiel alle wichtigen Variablen definiert und Konstanten gesetzt. Es kann also losgehen.

Wenn man ein Spiel schreiben will, das in einer Form und unter Windows abläuft, muss man sich zwangsweise überlegen, wie man es realisiert, so dass gleichzeitig das Menü funktioniert und das Spiel läuft. Die am leichtesten erscheinende Lösung ist vielleicht ein Timer, der beispielsweise alle 10 Millisekunden den Bildschirm aufbaut und die Ereignisse des Spiels verwaltet. Jedoch hat diese Methode auch mehrere entscheidende Nachteile:

• Diese Methode ist langsam!

• Sie müssen das Spiel so programmieren, dass man es über einen Zeitgeber verwaltet wird.

• Es ist mit einigem Verwaltungsaufwand verbunden.

Die andere Alternative ist, den Spieß umzudrehen: Das Spiel läuft permanent und nur den Menüs wird bei jedem Durchlauf etwas Zeit gegeben, Ereignisse weiterzugeben. Dazu verwenden wir die DoEvents-Anweisung. Diese gibt die Kontrolle für kurze Zeit an Windows zurück und ermöglicht, dass z.B. Menüereignisse überprüft werden.

Was wir jetzt noch benötigen ist eine Variable, die angibt, welches Ereignis eingegangen ist. Dazu  definieren wir folgende Variablen und Konstanten im Deklarationsteil der PACMAN.FRM, die Sie nun neu erstellen:

Unser späteres Spiel soll dann in der Prozedur SPIEL verwaltet werden und über die Variable MENU_WAHL mitbekommen, ob und wenn ja, welcher Menüeintrag angeklickt wurde. Die Abfrage der Tastatur erfolgt natürlich wieder über DISPLAY_KEYDOWN und DISPLAY_KEYUP und wirkt sich auf das KEY_DOWN()-Datenfeld und die KEY_LAST-Variable aus.

Zuerst behandeln wir den Aufruf der Form. Der Inhalt der FORM_LOAD-Ereignisprozedur ist relativ simpel:

Als erstes stellen wir sicher, dass die Form schon auf dem Bildschirm zu sehen ist, bevor das Spiel gestartet wird. Anschließend wird die Prozedur SPIEL aufgerufen.

Der nächste Punkt der "Tagesordnung" ist die neue PACMAN.FRM-Datei die neugestaltet werden muss.

Die Form selbst bekommt später noch ein Menü. Setzen Sie nun zwei Bildfelder und ein Bezeichnungsfeld auf die Form:

Es folgt das Menü. Rufen Sie dazu wie bekannt den Menüeditor auf.

Jetzt zum Ereigniscode für die Form.

Die Ereignisroutinen für das Display-Bildfeld sollten Ihnen noch vom letzten Spiel bekannt sein. Hier werden Tastendrücke des Benutzers abgefangen und registriert. Sobald eine Taste gedrückt wird, setzt die Routine den entsprechenden Eintrag im KEY_DOWN()-Datenfeld auf 1 und weist der Variable KEY_LAST den KeyCode zu. Wird die Taste wieder losgelassen, so wird der Eintrag im KEY_DOWN()-Datenfeld wieder zurück auf 0 gesetzt. Somit können wir im Spiel überprüfen, welche Tasten gerade gedrückt sind und welche nicht.

Die FORM_RESIZE-Routine sorgt dafür, dass alle Elemente in der Form jederzeit die richtige Größe haben.

Das Display-Bildfeld wird auf die Koordinaten 0,0 gesetzt. Das ist die obere linke Ecke direkt unter dem Menü. Die Größe ergibt sich aus der Innengröße der Form minus die Größe des Statusfeldes. Die Breite entspricht der gesamten Breite der Form. Das Statusfenster wird immer am unteren Rand der Form positioniert. Und anschließend wird noch das Hintergrundbild gestreckt und auf das DISPLAY-Bildfeld kopiert. 

Da wir in FORM_LOAD die FORM anzeigen gibt es Probleme, sobald die Form geschlossen wird. In diesem Fall würde die FORM_LOAD-Prozedur nämlich dafür sorgen, dass die Form gleich wieder angezeigt werden würde. Aus diesem Grund wäre die Form nicht zu schließen. Daher benutzen wir die FORM_UNLOAD-Prozedur um VB explizit mitzuteilen, dass die Form nicht nur geschlossen, sondern auch das ganze Programm beendet werden soll.

Jetzt müssen wir noch den Code für die Menüs schreiben:

Wenn der Benutzer einen Menüeintrag anklickt wird die Variable MENU_WAHL auf einen entsprechenden Wert gesetzt. Auch hierbei benutzen wir Konstanten.

Und als letzte Routine für dieses Modul verfassen wir die zentrale Routine SPIEL, in der alle Ereignisse zusammenlaufen und die das ganze Spiel steuert.

In der obersten Zeile wird per On Local Error Resume Next dafür gesorgt, dass alle eventuell vorkommende Fehler abgefangen werden.

Danach werden die Routinen PACMAN_INIT (Initialisierung des Spiels) und PACMAN_LOAD "LEVEL.001","BACK1.BMP" (Datei LEVEL.001 laden und als Hintergrund BACK1.BMP) aufgerufen. Am Ende wird noch einmal FORM_RESIZE aufgerufen, damit gleich am Anfang des Spiels alles richtig aussieht.

Die Variable Level (gibt logischerweise das aktuelle Level an) wird auf 1 und die Variable StartTime (Anfangszeit) wird auf TIMER gesetzt. Aus der Anfangs- und der aktuellen Zeit können wir immer leicht errechnen, wie lange das Spiel schon läuft ohne dass wir auf einen Timer zurückgreifen müssen.

Nun startet die Hauptschleife, in der das Spiel abläuft.

Zuerst überprüfen wir die Hintergrundmusik und starten sie ggf. wieder, wie wir es aus dem ersten Spiel kennen.

Nun wird PACMAN_RUN aufgerufen. In dieser Routine wird später das Spiel selbst (also die Bewegungen usw.) untergebracht. Anschließend zeigen wir im Statusfenster noch die Punkte und die bisher vergangene Zeit an, die sich aus der aktuellen Zeit minus der Startzeit errechnet. Danach wird DoEvents benutzt, um Windows Zeit für andere Ereignisse zu geben.

Nun überprüfen wir, ob ein Menüereignis vorliegt. In diesem Fall hat MENU_WAHL einen Wert ungleich Null. Diesen fragen wir dann in einem SELECT-CASE-Block ab und reagieren entsprechend.

Wurde der Eintrag Spiel  -> Neues Spiel starten gewählt, so wird wieder das erste Level geladen und alle zugehörigen Werte werden zurückgesetzt.

Der Eintrag Spiel  -> Beenden ist schnell abgehandelt. Darauf reagiert unser Spiel mit der schlichten Anweisung END die hier nicht weiter besprochen werden muss, oder etwa doch? ;-)

Als nächstes kommt der Eintrag Info -> Highscore sehen. Dieser hat zur Folge, dass die Variable HIGHSCORE_EINTRAGEN auf Null gesetzt wird (damit die Form weiß, dass der User nur mal reinsehen will) und die Form HIGHSCORE eingetragen wird.

Der Eintrag Info -> Hilfe sorgt für das Aufrufen der Hilfe-Form.

Bei Info -> Info über sieht es ähnlich einfach aus:

Damit wäre der CASE-Block abgeschlossen und die MNU_WAHL-Variable wird wieder auf Null zurückgesetzt.

Die Variable LEVEL_NEXT wird von PACMAN_RUN auf 1 gesetzt. Falls der Spieler vor dem Sieg abtritt wird sie auf -1 gesetzt. Im ersten Fall wird die Level-Variable erhöht, und dann wird der Name der neuen Level-Datei errechnet. Zuerst erstellen wir aus der Variable Level einen String, schneiden die Lücke vorne ab, und setzen solange Nullen davor, bis es insgesamt ein String mit drei Zeichen ist.

Dann überprüfen wir, ob eine solche Datei (Pfad + "LEVEL." + Levelendung) existiert. Wenn ja wird sie geladen und LEVEL_NEXT wird zurückgesetzt. Wenn nein wird HIGHSCORE_EINTRAGEN auf 1 gesetzt, die Form wird angezeigt. Anschließend ruft das Programm noch die Form GELÖST auf (die bisher auch noch nicht da ist) und dann wird ein neues Spiel gestartet. Das ist die Standardprozedur, wenn der Spieler gewinnen sollte.

Sollte der Spieler verlieren, wird die VERLOREN-Form angezeigt und alle Werte werden zurückgesetzt. Zusätzlich wird hier ebenfalls die Highscoreliste aufgerufen, in der sich der Spieler eintragen kann, wenn er gut genug war :-)

Nun kommt natürlich noch der Abschluss der Schleife und das Ende der Prozedur.

Damit Sie später beim Schreiben des Hauptprogramms immer nachsehen können wie weit das Spiel läuft, werden wir nun die restlichen Fenster erstellen.

Wenn der Benutzer nun auf einen der Knöpfe klickt, muss das entsprechende Bild geladen werden (nun gut, man hätte auch vier Bildfelder in die Form setzen können - aber machen wir es mal auf diese Weise). Dazu können wir einfach den Index verwenden:

Und noch der Code für den ZURÜCK-Knopf, der keine besondere Herausforderung mehr ist ...

In vielen guten Actionspielen gibt es Highscore-Listen, die für den Spieler einen Anreiz darstellen, möglichst viele Punkte zu holen. Auch in diesem Spiel wollen wir darauf eingehen. Wenn Sie Lust haben, können Sie ja versuchen, eine ähnliche Liste in das Actionspiel (aus dem ersten Teil über Spiele) einzubinden.

Das N$()-Datenfeld fasst logischerweise die Namen, das P()-Datenfeld die Punktzahlen auf. Nun müssen wir in FORM_LOAD die alte Highscore-Liste laden, die Punktzahl prüfen und die neue Liste dann ausgeben.

Am Anfang zentrieren wir wieder die Form auf dem Schirm.

Nun sehen wir mit DIR$(<Datei>) nach, ob schon eine Highscore-Datei vorhanden ist. DIR$ ist eine der vielen Dateifunktionen von Visual Basic. Sie liefert die erste gefundene Datei eines Suchmusters zurück. Wir können z.B.  Ergebnis$=DIR$("*.TXT") benutzen um die erste Textdatei im Verzeichnis zu finden. Wenn das nicht reicht, können wir mit Ergebnis$=DIR$() die nächste Datei solange suchen, bis DIR$ uns einen leeren String zurückgibt. Dann ist keine weitere Datei mehr da. In diesem Fall nutzen wir das aus, um zu prüfen, ob eine ganz bestimmte Datei, nämlich <Pfad>\SCORE.DAT vorhanden ist. Wenn ja, wird diese Datei geöffnet und die Highscores werden eingelesen.

Wenn die Datei nicht vorhanden ist wird eine neue Highscore-Liste erstellt, in der schon einige Namen und Punktzahlen voreingestellt sind, um Ansporn zu geben, diese Leute zu schlagen und Platz eins zu erobern:

Das ich in diesem Fall meine E-Mail-Adresse benutzt habe ist nebensächlich, ich trage es Ihnen bestimmt nicht nach, wenn Sie hier etwas anderes einsetzten ;-)

Als nächstes wird geprüft, ob der Benutzer sich eintragen kann (also ob er "gestorben" ist oder gewonnen hat). In diesem Fall geht die eigentliche Arbeit los.

Wir durchlaufen nun mit einer Schleife alle Einträge von 0 bis 6. Jedes Mal prüfen wir, ob die Punktzahl dieses Eintrags kleiner oder gleich der des Spielers ist. In diesem Fall erobert nämlich der Spieler den Platz. Das wird hierbei von oben nach unten vorgehen ist wichtig, da sonst der Name des Spieler an alle Plätze unterhalb der eigentlich Position eingetragen werden würde.

Haben wir nun den Platz gefunden schieben wir alle Einträge darunter eins nach unten. Dies machen wir, indem wir von 6 an aufwärts zählen, bis wir einen Eintrag unter dem des Users sind. Dabei kopieren wir immer den oberen nach unten:

1. Name A
2. Name B
3. Name C
4. Name D

Der User kann sich auf Platz eins in unserem Schema eintragen, daher gehen wir von 4 nach 2 alle durch und machen folgendes:

Nun sind alle Namen, Name A einschließlich, nach unten verschoben und wir können Platz 1 überschreiben. Damit wäre unsere Aufgabe erfüllt:

Nachdem die Namen verschoben sind, können wir den User informieren, nach seinem Namen fragen, und diesen dann gleich samt seiner Punktzahl auf den errungenen Platz eintragen. Anschließend müssen (!!) wir die Schleife verlassen, damit er sich nicht auch noch auf den unteren Plätzen einträgt.

Jetzt übernehmen wir die aktuelle Liste in die Form. Hier sehen Sie jetzt auch, warum es so wichtig ist, dass die Steuerelementefelder in der Form oben den Index 0 haben und die unteren größere Werte:

  For M = 0 To 6
      SPIELER(M).Caption = N$(M)
      PUNKTE(M).Caption = Str$(P(M))
   Next M
End Sub

Wenn der Benutzer genug von dem Bildschirm hat klickt er auf OK und die Form wird mit folgendem Code vom Bildschirm geputzt:

Es wird wieder die Datei SCORE.DAT geöffnet und die Namen und Punkte werden eingetragen. Damit wir beim Öffnen mit Input #1, N(m), P(m) arbeiten können ist es wichtig, dass wir beim Speichern auch ein Komma einbringen. Dies machen wir, indem wir einen String mit einem Komma zwischen den Werten speichern lassen. Fertig :-)

Um das Spiel endlich zum Laufen zu bewegen, müssen wir nun die PACMAN.BAS fertig schreiben (ich weiß, einige Leser haben schon richtig drauf gewartet *g*).

Fangen wir mit PACMAN_INIT an, da diese Prozedur als erste aufgerufen wird. Die nun folgenden Routinen müssen natürlich in das Modul PACMAN.BAS geschrieben werden...

Als erstes setzten wir den Pfad. Zu Testzwecken, also während der Entwicklung, können Sie hier einen absoluten Pfad setzen, damit Sie nicht mit dem VB-Verzeichnis in Konflikt kommen, was bei Version 3.0 öfters der Fall ist. Wenn Sie das Spiel später endgültig kompilieren, sollten Sie die erste Zeile entfernen und vor der zweiten das Hochkomma wegnehmen.

Nun setzten wir MAX_DIFF auf drei. Das ist der Wert für die Genauigkeit bei der Kollisionsabfrage. Eine gewisse Toleranz ist wichtig, um die Steuerung zu vereinfachen.

Anschließend laden wir alle nötigen Bilder.

Jetzt wird die Variable Anzahl auf 0 gesetzt. Danach zerlegen wir die Bilder in das Sprite-Datenfeld, wie wir es bei der Demo gemacht haben.

Nun kommen wir zu PACMAN_LOAD. Diese Prozedur hat sowohl die Aufgabe den Hintergrund zu aktualisieren und die Werte zurückzusetzen, als auch das Level zu laden. Daher wird die Routine etwas länger...

Als nächste Laden wir das Hintergrundbild, was in BACK$ übergeben wird:

Nun wird die Variable COUNT_DOTS (der Zähler für die essbaren Punkte) auf Null gesetzt, und das Level geöffnet. Beim ersten Durchgang werden nur die Zeilen gezählt, und die Datei wird geschlossen. Anschließend wird die Breite des Levels in Zeichen mit der Länge einer Zeile errechnet (Spalten = Len(A$)). 

Da wir die Anzahl der Zeilen und Spalten kennen, können wir nun das Spielfeld initialisieren. Da unsere Routine FIELD_SIZE (bekannt aus den letzten Teilen) die Koordinaten von 0 an zählt, müssen wir jeweils noch eine Zeile abziehen. Haben wir beispielsweise 60 Zeilen, müssen wir eins abziehen, damit wir ein Datenfeld von 0-59 erhalten. Das ergibt 60 - denn 0 ist die erste Zeile.

Nun werden alle bisher erstellen Objekte wieder gelöscht und die Steuerungs-Tasten für Pacman (also die Cursor-Tasten) werden auf  "ungedrückt" gesetzt.

Jetzt setzen wir unseren Objektzähler AObj auf Null und Y auf Null. Dann erstellen wir Pacman an der Position 0,0. Wenn Sie die Syntax von OBJ_SET nicht mehr kennen, so lesen Sie diese bitte in den letzten Teilen nach. Hier sehen Sie auch wieder, dass wir mit den Konstanten NR_xxxxxxx und ID_xxxxxxx gut arbeiten können. Anschließend erhöhen wir AObj für das nächste Objekt. Dieses Verfahren ist wichtig, damit Pacman immer Objekt Nr. 0 ist und so leicht angesprochen werden kann.

Die Leveldatei wird wieder geöffnet, und wir beginnen mit dem eigentlichen Einlesen.

Nachdem wir jeweils eine Zeile gelesen haben, gehen wir diese Zeile mit einer FOR-Schleife durch. Dabei zählen wir von 0 bis Länge-1. Das Zeichen erhalten wir mit Hilfe der MID$()-Funktion:

Jetzt kommt der längste Teil: Wir haben ein Zeichen aus einer Datei eingelesen. Dieses Zeichen stellt ein Objekt dar. In einem SELECT-CASE-Block sehen wir nun nach, welches Zeichen es ist und welches Objekt wir dafür setzten. Dieser Teil ist für das Design der Level wichtig. Ich habe Ihnen folgendes Format vorgegeben:

Jede Leveldatei ist, wie Sie sicher schon gemerkt haben, wie eine Karte aufgebaut. Jedes Zeichen entspricht einem Objekt, so dass man ein Level sehr gut und einfach mit einem Texteditor und einer unproportionalen Schrift, wie z.B. Courier New, erstellen kann.

Wenn Sie selbst einige Level entwerfen wollen, was ich Ihnen bei nur drei Level empfehlen kann, sollten Sie sich die Liste oben ausdrucken, und beim Editieren neben den Rechner legen. Sie können natürlich auch einen Leveleditor schreiben, aber dies wollte ich in diesem Kurs auf Grund von Zeit & Platz nicht auch noch machen.

Jetzt muss jedes Spielelement, das auch oben in der Liste steht, in den SELECT-CASE-Block hinein. Der nun folgende Teil sieht zwar SEHR unübersichtlich aus, basiert aber im Grunde nur auf folgenden Teilen (fett gedrucktes ändert sich von Fall zu Fall):

Und mit diesem Wissen ist es leicht einen Block zu erstellen. Als Beispiel für das blaue Monster nehmen wir als Zeichen "1" (aus der Liste zu entnehmen) und die Konstanten NR_MONSTER_BLUE und ID_MONSTER_BLUE. Hier sehen Sie, warum ich am Anfang Konstanten benutzt habe.

Nun an die Arbeit! Ich werde nur auf einige besondere Fälle eingehen. Alle anderen, die nach dem oben gezeigten Schema funktionieren, werde ich nur auflisten. Ich schlage Ihnen vor, den folgenden Code zu kopieren, es sei denn, Sie haben sehr viel Lust die nächsten 15 Minuten zu tippen ;-)

Ach ja, bei den Wänden wird jeweils noch ein Zufallswert zwischen 0 und 4 addiert, damit wir Wände in unterschiedlichen Schattierungen (Helligkeiten) haben.

Es kommen jetzt die Wände.

Pacman wird einfach nur verschoben:

Und nun die Extras:

Ah! Die Monster kommen!!

Schlüssel:

Bei den Punkten wir zusätzlich noch COUNT_DOTS erhöht...

Jetzt kommen die Schalter:

Und die Teleporter...

Puh, das war ein ganz schönes Stück Arbeit. Aber dafür geht's jetzt erst einmal etwas ruhiger zu. Wir schließen die FOR-Schleife. Anschließend wird Y um eins erhöht. Die Abbruchbedingung der offenen DO-Schleife lautet UNTIL EOF(1), was bedeutet, dass der ganze Block solange durchlaufen wird, bis die Datei zu Ende ist. Dann wird sie geschlossen, und wir sind fürs erste durch.

So, nun eine etwas einfachere Prozedur: PACMAN_RUN. Diese Routine wird bei jedem Durchlauf der Hauptschleife aufgerufen. Hier sitzt die Steuerung von PACMAN: