Referat ProPra SS95 Endbericht

ProPra SS95 Endbericht

Einführung

Die Aufgabe des Programmierpraktikums SS '95 bestand darin, ein Spiel zu programmieren, daß man allgemein unter dem Namen dreidimensionales 4-Gewinnt kennt.

So machten sich also 16 Studenten unter der Leitung von Manfred Poepping an die Arbeit diese Aufgabe zu lösen. Probleme enstanden, wenn es um die Koordination der Arbeitsabläufe ging und den Kommunikationsteil des Programmes zum Laufen zu bringen.

Nach mehreren Monaten harter Arbeit enstand nun diese lauffähige Version von 3D - 4 Gewinnt.

Mehr ist nicht mehr über dieses Spiel zu sagen, außer sich davor zu setzen und es auszuprobieren.

Einsatzbereich

Das dreidimensionale Strategiespiel Vier--Gewinnt ermöglicht es dem Spieler zum einem gegen den Computer zu spielen, zum anderen besteht die Möglichkeit, gegen ein anderes Vier--Gewinnt--Programm, sofern es die unter ''Kommunikation'' Kapitel kommunikation beschriebenen Voraussetzungen erfüllt, zu spielen.

Anwendungsbereich und Zielgruppe

Das Programm dient dem Vergnügen. Es wendet sich an Anfänger, die dieses Spiel noch nicht kennen, aber auch an Fortgeschrittene, die ihre Spielkenntnisse vertiefen wollen.

Soft- und Hardwareanforderungen

Benötigt wird ein Unix--Rechner mit der Benutzeroberfläche X--Windows und OSF--Motif.

Geschwindigkeit

Das Programm reagiert im allgemeinen in vernachlässigbar kurzer Zeit, außer beim Menüpunkt ,,Hilfe``, da dann der html-Viewer Mosaic gestartet wird.

Funktionalität

Legende

Start des Programms

Neues Spiel

Wird der Menüpunkt ''Neues Spiel'' ausgewählt, so geschieht folgendes:

Läuft bereits ein Spiel, so erscheint eine Abfrage, die sicherstellt, daß das aktuell laufende Spiel nicht versehentlich abgebrochen wird.

Soll kein neues Spiel gestartet werden, so erfolgt der Rücksprung an die Stelle, von der der Aufruf ''Neues Spiel'' kam. Im anderen Fall muß nun der Spielmodus und die Spielstärke gewählt sowie die Namen der Spieler eingegeben werden.

Folgende Spielmodi sind verfügbar: siehe auch Kapitel kommunikation

Mensch---Mensch

Mensch---Programm

Programm---Programm

Es gibt 3 Spielstärken: leicht, mittel und schwer

Falls ein neues Spiel beginnt, wird der, der anfängt, per Zufall bestimmt.

Daraufhin werden die Farben der Spieler entsprechend gesetzt und es folgt der Beginn des Spieles.

Die Funktionen ''Hilfe'' und ''Programmende'' sind hier immer verfügbar.

Spielbeginn

Wird ein neues Spiel begonnen, so gilt:

Fängt der Gegner an, dann erfolgt ein Gegenzug. Falls dies nicht der Fall ist, so kann der Spieler nun einen Zug machen.

Nach jedem Zug erfolgt ein Gegenzug und umgekehrt, sofern nicht die UNDO--Funktion gewählt wurde und das Spiel noch nicht gewonnen ist. Nach jedem Zug wird geprüft, ob das Spiel von einer Partei gewonnen ist bzw. ein Remis besteht.

Ist bereits ein eigener Zug erfolgt, so läßt sich mit der UNDO--Funktion genau dieser Spielzug zurücknehmen. Ist bereits der Zug des Gegners erfolgt, so wird auch dieser zurückgenommen. Bei der Spielvariante ''Programm gegen Programm'' ist diese Funktion nicht ausführbar.

Die Funktionen ''Hilfe'', ''Programmende'' und ''Neues Spiel'' sind jederzeit möglich.

Nochmal Spielen

Bei ''Nochmal Spielen'' gilt folgendes:

Die Abfrage ''Wirklich'' erscheint nur bei bereits laufendem Spiel.

Soll kein neues Spiel gestartet werden, so erfolgt der Rücksprung an die Stelle, von der der Aufruf ''Nochmal Spielen'' kam. Andernfalls werden die Optionen des letzten Spieles übernommen.

Optionen des letzten Spieles bedeuten hier die Übernahme von Spielmodus, -stärke und Spielernamen; sie können hier nicht mehr verändert werden.

Bei ''Wer beginnt'' wird der Beginner der neuen Partie festgelegt. Es fängt derjenige an, der das vorherige Spiel verloren hat.

Die Funktionen ''Hilfe'', ''Neues Spiel'', ''Nochmal Spielen'' und ''Programmende'' sind jederzeit verfügbar.

Hilfe

Der Aufruf der Hilfe ist jederzeit möglich.

Die ''Spielregeln'' von 3D--Vier--Gewinnt werden erläutert.

Die Funktion ''Tip'' gibt dem Spieler einen möglichen Spielzug an. Sie kann nur bei laufendem Spiel und bei eigenem Zug aufgerufen werden.

Unter ''Bedienung'' wird die Programmbedienung des Spieles erklärt.

Bei ''Info'' wird eine Information über das Programm und seine Autoren ausgegeben.

Spielende

Es wird geprüft, ob einer der Spieler gewonnen hat, oder ob das Spiel mit Remis endet. (siehe auch Kapitel spiel gewonnen)

Spielstrategien - Spielregeln

Spielstrategien

Es existieren 3 Spielstrategien mit unterschiedlicher Spielstärke, von denen die erste Spielstrategie (Random Placement) die schwächste Spielstärke ist, und die zweite Spielstrategie stärker ist als Randomplacement. Die dritte Spielstrategie ist die stärkste Strategie von allen.

Spielregeln

Das Spiel beginnt mit einem leeren Spielfeld, das man sich als einen Würfel vorstellen kann, welcher 4 Felder breit, 4 Felder hoch und 4 Felder tief ist. Abwechselnd wird jeweils von einem Spieler jeweils eine Kugel seiner Farbe auf ein Feld gelegt. Dabei wird die Kugel von oben auf den Würfel gelegt und fällt anschließend auf die oberste darunterliegende Kugel, so daß die Schwerkraft berücksichtigt wird und daher keine Kugel frei schweben kann. Demjenigen, dem es als erstes gelingt, eine gerade Reihe von 4 eigenen Kugeln zu bilden hat gewonnen, und das Spiel wird damit beendet. Eine gültige 4er Reihe ist horizontal, vertikal und diagonal möglich. Wenn alle Felder belegt sind, ohne daß eine 4er Reihe gebildet wurde, so endet das Spiel unentschieden.

Die Ebene 4 soll die höchste Ebene sein.

Horizontal lassen sich pro Ebene 4 Viererreihen (= 16 Möglichkeiten) bilden (Eine Möglichkeit zeigt Beispiel A)

Vertikal lassen sich pro Ebene 4 Viererreihen (= 16 Möglichkeiten) bilden (illustriert Beispiel B)

Diagonal lassen sich pro Ebene 2 Viererreihen (= 8 Möglichkeiten) bilden (die zwei Möglichkeiten zeigen Beispiel C und D)

Die Ebene 4 soll die höchste Ebene sein.
Es ist auch möglich, die Viererreihe durch die Ebenen zu bilden, was durch Beispiel E veranschaulicht wird. Dadurch ergeben sich 16 Möglichkeiten, auf diese Weise eine senkrechte Viererreihe zu bilden.

Die Ebene 4 soll die höchste Ebene sein.
Viererreihen lassen sich außerdem senkrecht diagonal im Raum bilden. Hier sind 8 Möglichkeiten denkbar. Eine Möglichkeit zeigt Beispiel F.

Die Ebene 4 soll die höchste Ebene sein.
Es lassen sich außerdem Diagonalen auch waagerecht im Raum bilden. Hier existieren auch wiederum, ähnlich Beispiel F, 8 mögliche Viererreihen. Eine Möglichkeit illustriert Beispiel G.

Die Ebene 4 soll die höchste Ebene sein.
Noch eine weitere Art der Viererreihe zeigt Beispiel H. Es gibt hier 4 mögliche Viererreihen, die gebildet werden können.

Benutzeroberfläche

Die Benutzeroberfläche ist X--Windows und OSF--Motif unter einem UNIX-Betriebssystem. Die Benutzungsführung erfolgt in Deutsch; die Bedienung erfolgt mittels Maussteuerung.
Der Aufbau sämtlicher Bildschirmdialoge, d.h. Menüs, Dialogboxen und das Hauptfenster (siehe Skizze unten) ist konform mit den Motif Style Guides; dies ergibt sich u.a. durch den Einsatz des Interface Builders.
Das Programm arbeitet vollständig in einem eigenen Fenster, das als Icon verkleinert werden kann.

Elemente der Programmoberfläche

Spielfeld

Das Spielfeld wird durch vier übereinanderliegende, 4 x 4 Felder große Gitter in dreidimensionaler Ansicht ohne Perspektive dargestellt.

Spielsteine

Die Spielsteine werden als Kugeldarstellung realisiert, wobei die Spielsteine zur Unterscheidung der Spieler verschiedenartig gefärbt sind.

Informationsfenster

Hier werden die folgenden Informationen angezeigt:

Spielermodus; z.B. Mensch gegen Programm

Farbe der Spielsteine der Spieler; z.B. Spieler ''Name'' spielt mit den schwarzen Steinen

Wer beginnt

Spielstand, d.h. Spieler 1 oder Spieler 2 hat gewonnen oder Remis

Bedienelemente

Bei der Spielvariante ''Mensch---Programm'' werden die Züge des Menschen mit der Maus realisiert, wobei nur das oberste Gitter des Spielfeldes als Eingabefeld bestimmt ist. Dort ändert sich der Mauscursor, so daß der Spieler erkennt, wo er eine Kugel setzen darf. Die linke Maustaste bewirkt das Setzen der Kugel auf das Spielfeld. Die Kugel landet danach in der untersten Ebene, die noch frei ist. Fehlerhafte Eingaben werden nicht akzeptiert.

Menüleiste

Eine Menüleiste am oberen Fensterrand enthält die folgenden Menüpunkte.

Datei  

Spielende:

In einer Dialogbox wird nach einer Sicherheitsabfrage der Art ''Programm wirklich beenden'', das Programm bei einer positiven Antwort beendet, ansonsten läuft das aktuelle Spiel weiter.

Neues Spiel:

Bei einem laufenden Spiel wird mittels einer Dialogbox nach einer Sicherheitsabfrage der Art ''Eine neue Spielserie starten'' bei einer positiven Antwort eine neue Spielserie gestartet. Bei einer negativen Antwort läuft das aktuelle Spiel weiter. Läuft aktuell kein Spiel, so wird eine neue Spielserie gestartet. Über eine Dialogbox wird der Spielmodus, -stärke und Spielernamen ausgewählt.

Nochmal spielen:

Bei einem laufenden Spiel wird ebenfalls in einer Dialogbox nach einer Sicherheitsabfrage der Art ''Neues Spiel beginnen?'' bei einer positiven Antwort ein neues Spiel gestartet. Bei einer negativen Antwort läuft das aktuelle Spiel weiter. Läuft aktuell kein Spiel, so wird ein neues gestartet. Dabei werden die Optionen (wie Spielmodus etc.) des vorherigen Spieles übernommen.

Zug zurücknehmen:

Nur der jeweils zuletzt gesetzte eigene Zug des Spielers wird rückgängig gemacht.

Hilfe

Bedienung:

Die Bedienung des Programmes wird erklärt.

Spielregeln:

Die Spielregeln von 3D-Vier-Gewinnt werden erläutert. Der Text erscheint in einem seperaten Fenster, dessen Inhalt mit der Maus gescrollt werden kann.

Info:

In einem Textfenster werden Informationen über das Spiel und die Autoren ausgegeben.

Tip:

Dem Spieler wird optisch durch eine Kugel, die sich farblich von den Spielerkugeln unterscheidet, ein möglicher nächster Zug angezeigt. Dieser Button kann nur angewählt werden, wenn man am Zug ist und bereits ein Spiel läuft.

Buttons

Die folgenden Buttons, deren Funktion bereits unter Programmoberfläche zur Verfügung.

Nochmal spielen

Neues Spiel

Zug zurücknehmen

Dabei können -- je nach Spielsituation -- einzelne Buttons nicht angewählt werden. Diese sind in dem Fall von den wählbaren optisch unterscheidbar dargestellt.

Kommunikation

Spielmodi

Es ergeben sich - neben dem Modus , Mensch gegen Programm` - folgende Möglichkeiten:

a)

Ein Programm spielt automatisch gegen ein anderes Programm

Die Spielstärke des Programmes kann vor Beginn des Spieles ausgewählt werden. (Das Programm kann auch zweimal gestartet werden und auf diese Weise gegen sich selbst spielen.)

b)

Zwei menschliche Spieler spielen gegeneinander, wobei jeder Spieler an einem 'eigenen` Programm spielt.
In diesem Fall entfällt die Möglichkeit der Spielstärkenwahl.

Beginner einer Partie

Sollen zwei Programme gegeneinander spielen, so beginnt diejenige Seite, bei der die Spielstärkenwahl zuerst abgeschlossen wird. Genauer: Der Prozeß, in dem zuerst die Pipe `player_1' angelegt worden ist, beginnt. Siehe Datenstrukturen

Realisierung

Kurze Beschreibung der Strategien

Die erste und in psychologischer Sicht auch wichtigste Strategie ist zweifellos die erste (Spielstärke: leicht).

Gemeinhin auch unter dem Pseudonym 'Random Placement' bekannt bietet es allen uns bisher bekannten Vertretern der Klasse DAU zumindest die Hoffnung, einmal im Leben gegen einen Computer irgendetwas reißen zu können. Diese unsere Lieblingsstrategie wählt aus den noch freien Positionen zufällig eine aus und wuchtet ihr Steinchen hinein, ohne auf die Konsequenzen zu achten.

Alle anderen Strategien arbeiten mit einem Bewertungsystem für die jeweils möglichen Positionen. Die zweite Strategie prüft zunächst, ob eine 4er-Reihe des Gegners verhindert werden muß oder ob sie selbst eine bilden, sprich gewinnen kann. Dann wird jede mögliche Position daraufhin geprüft, ob ein Setzen an die jeweilige Stelle eine 3er-Reihe des Gegners verhindern, bzw eine eigene ermöglichen kann; für beide Fälle sind Punkte festgesetzt, die dann addiert bzw subtrahiert werden. Gesetz wird schließlich an die Stelle, die die meisten Punkte im Bewertungsystem hat sammeln können, nachdem noch getestet wurde, ob ein Setzen an der Stelle vielleicht dem Gegner eine Gewinnreihe in der Eben darüber möglich macht.

Die vierte Strategie arbeitet nach genau dem gleichen Prinzip, nur daß hier schon auf 2er-Reihen (eigene und die des Gegners) getestet wird und geprüft wird, ob der Gegner vielleicht eine von diesen niedlich-tödlichen Doppelmühlen im Sinn hat. Weiterhin besitzt diese Strategie eine Prioritätenliste für die einzelnen Positionen; so ist zB ein Eckpunkt in der untersten Ebene strategisch günstiger als in Ebene 2 oder 3, in denen die mittleren Punkte die besseren Chancen bieten. Diese Bewertung ist allerdings im Verhältnis zur obigen Zugbewertung klein gewählt, so daß sie nur zum Tragen kommt, wenn zwei mögliche Züge die gleiche Punktzahl erreicht haben. Die fünfte Strategie arbeitet nach genau demselben Prinzip, allerdings mit leicht veränderten Werten.

Die dritte Strategie bewertet nun die möglichen Positionen nicht nach einem Punktesystem, sondern danach, wieviele Möglichkeiten diese Position noch für Gewinnreihen bildet, d.h. wieviel freie oder nur von eigenen Steinen besetzte Reihen von diesem Punkt ausgehen. Vorher wird, wie bei den obigen Varianten, noch auf 4er-Reihen und Doppelmühlen geprüft.

Callbacks

Anmerkung

Im Gegensatz zu anderen Teilen des Programms, wurden die Callbacks genau nach dem vorher erstellten Dokument (und nicht umgekehrt) implementiert. Dadurch halten sich die Anderungen in Grenzen. Auf Anderungen wird im folgenden explizit hingewiesen.

Start des Programms

Beim Start des Programms wird durch den von Motifation erzeugten Quellcode das Hauptfenster von 3D--Vier--Gewinnt initialisiert und dargestellt. Nachdem das Fenster dargestellt wurde, wird dem Hauptprogramm über einen Event signalisiert, daß mit spielspezifischen graphischen Darstellungen etc. begonnen werden kann. Dies wird über den Callback XmPostInitialize realisiert, der global die Klasse 3D4G initialisiert. Diese erzeugt Brett und Spielbrett und stellt mittels Spielbrett.Neuzeichnen() und Spielbrett.gebe_info_aus() das Spielraster und Infofenster dar. Bei der Initialisierung von 3D4G wird ein globales Flag gesetzt, welches speichert, daß der Neues Spiel--Button noch nicht gedrückt wurde. Solange dieses Flag gesetzt ist werden Mausbewegungen und Mausklicks auf der Stein--setzen--Fläche von den entsprechenden Callbacks ignoriert. Dieses Flag wird beim Erzeugen der Spieler (also dem tatsächlichen Spielbeginn) gekippt.

Ergänzung: Alle global verwalteten Daten werden in globalen structs vom Typ CallbackInfo bzw. SpielModusInfo gespeichert.

Zu diesem Zeitpunkt ist das Spiel komplett initialisiert und bereit fuer weitere Benutzereingaben, allerdings werden die Buttons Nochmal Spielen und Zug zurück für Eingaben gesperrt.

Ergänzung: Dies wird ebenfalls über interne Flags abgefangen.

Fenster--Ereignisse

Fenster--Verdeckung

Nach vollständiger oder teilweiser Verdeckung des Spielfensters wird durch einen entsprechenden Refresh--Callback die Programmoberfläche neu gezeichnet. Dies wird über die Funktionen Spielbrett.Neuzeichnen() und Spielbrett.gebe_info_aus() realisiert.

Fenster--schließen

Wird das Fenster über den WindowClose--Button geschlossen, wird der gleiche Callback wie bei dem Menüpunkt Spiel beenden ausgelöst (d.h. es erscheint ein Requester, welcher erfragt, ob wirklich abgebrochen werden soll. Die weitere Vorgehensweise kann beim Callback für Spielende nachgesehen werden.

Anderung: Die Spiel verlassen? Sicherheitsabfrage fiel einer GUI Überarbeitung zum Opfer

Wird im Kommunikationsmodus gespielt, muß dem gegnerischen Programm über Kommunikation.Abbruch() mitgeteilt werden, daß das Spiel beendet wurde.

Fenster--zerstören

Wird das Programm über destroy verlassen, werden vom Callback Destroy() die entsprechenden Destruktoren der bereits erzeugten Klassen aufgerufen. Danach wird das Programm (ohne Requester--Abfrage) verlassen.
Wird im Kommunikationsmodus gespielt, muß dem gegnerischen Programm über Kommunikation.Abbruch() mitgeteilt werden, daß das Spiel beendet wurde.

Maus--Ereignisse

Mausbewegung

Bei diesem Ereignis wird ein Callback namens Mausbewegt() ausgelöst.

Anderung: Alle Funktionen des Callbacks Mausbewegt sind in die Klasse 3D4G gewandert. Die Mausbewegung wird dieser übergeben und an die Klasse Spielbrett weitergeleitet.

Dieser ermittelt und übergibt die Mauskoordinaten an die Funktion Spielbrett.Feldpositionberechnen(), welche die zurückgibt (bzw. falls der Mauszeiger sich nicht über dem Zug-Eingabefeld befindet). Wurde eine gültige Koordinate zurückgegeben, wird dann Brett.Zuglegal() aufgerufen. Ist der Zug legal, wird der Klasse Spielbrett über die Methode Spielbrett.Markieren( a,b ) mitgeteilt, über welchem Eingabefeld sich der Mauszeiger befindet. Von der Klasse Spielbrett wird die Farbe des entsprechenden Eingabefeldes geändert und gespeichert, welches Feld verändert wurde. Zuvor wird diese Variable ausgelesen um ein evtl. vorher markiertes Feld wieder zu de--markieren. Sollte nach dem Start des Programms noch kein Spielmodus gewählt sein, so werden die Mausbewegungs--Ereignisse nicht bearbeitet, da das Setzen eines Spielsteines noch nicht möglich ist. Gleiches gilt falls die Kommunikation das Spiel übernommen hat.

Mausklick

Bei diesem Event wird der Callback Kugelsetzen() mit den aktuellen Mauskoordinaten aufgerufen.

Anderung: Alle Funktionen dieses Callbacks sind in die Klasse 3D4G gewechselt. Bei einem Mausklick wird nur noch die Methode Zug von 3D4G (mit den aktuellen Mauskoordinaten) aufgerufen.

Dieser testet zunächst, ob ein Mausklick im momentanen Spielmodus überhaupt beachtet werden soll. Im Spielmodus Rechner--Rechner oder vor Auswahl eines Spielmodus sind Mausklicks nicht zugelassen.
Ist ein Mausklick erlaubt, ruft er (wie bereits oben beschrieben) die Funktionen Spielbrett.Feldpositionberechnen() und Brett.Zuglegal() auf, um zu ermitteln, ob es sich um einen gültigen Zug handelt. Ist es ein gültiger Zug, wird die gültige Position über 3D4G der Klasse des menschlichen Spielers über die Methode Zug mitgeteilt. Innerhalb dieser wird dann Brett.Zugsetzen() aufgerufen. Durch Brett.Zugsetzen() wird auch der momentane Spielstatus ermittelt (gewonnen/remis/gültiger Zug). Dieser Rückgabewert wird von der Methode Zug als Rückgabewert an die aufrufende Callback--Funktion zurückgegeben. Mittels Spielbrett.Neuzeichnen() wird dann die Bildschirmausgabe aktualisiert.
Wechselt der Spielstatus in den Zustand ,,gewonnen``, wird die Funktion Spielbrett.Spielbeendet( Spieler, Grund ) aufgerufen, welche einen Requester erzeugt, der diese Tatsache kundtut.

Anderung: Die hier erwähnten Requester sind einer Ausgabe im Statusfenster gewichen.

Nach Bestätigen des Requesters wird das Brett mittels Brett.Brettleeren() neu initialisiert und die Variable für den letzten Zug gelöscht. Desweiteren werden die Spielerklassen über SpielerKlasse.init() neu initialisiert.
Wird im Kommunikationsmodus gespielt, muß die Kommunikation dem gegnerischen Programm mittels der Methode Zug das Spielergebnis mitteilen. Danach kann das Spiel erneut beginnen. Wechselt der Spielstatus in den Zustand ,,remis``, wird ebenso verfahren.

Liegt der Zustand ,,gültiger Zug`` vor, wird über Spielbrett.Neuzeichnen() die Bildschirmausgabe aktualisiert. Danach wird über 3D4G.AntwortZug() ein Gegenzug berechnet und im Brett gesetzt. Dazu ruft 3D4G die Methode Zug der jeweiligen Gegnerklasse auf und gibt deren Rückgabewert an die aufrufende Callback--Funktion zurück. Wechselt dadurch der Spielstatus, werden jeweils die gleichen Funktionen wie nach einem per Mausklick ausgelösten Zug ausgelöst. Ist der Gegenzug getätigt, wird mittels Spielbrett.Neuzeichnen() die Bildschirmausgabe aktualisiert.

Button--Ereignisse

Button: Neues Spiel

Dieser Event ruft den Callback NeuesSpiel() auf, welcher den Requester für die Spieleinstellungen beinhaltet. Die im Spieleinstellungsfenster enthaltenen Bedienelemente rufen jeweils Callbacks auf, die die jeweils betroffene Variable im (zu den Callbacks gehörenden) struct SpielModusInfo verändern.
SpielModusInfo wird bei der Erzeugung der Spieler von der Klasse 3D4G ausgewertet.

Auswahl des Spielmodus

Für jeden wählbaren Spielmodus (Mensch--Mensch, Mensch--Computer, Computer--Computer) existiert ein Callback, der im entsprechenden Feld des SpielModusInfo--structs den gewünschten Spielmodus einträgt.

Auswahl der Spielstärke

Für jede auswählbare Spielstärke existiert ein Callback, der in SpielModusInfo speichert, welche Spielstärke gewählt wurde. Diese Information wird bei der Erzeugung der Spieler von 3D4G berücksichtigt.

Namensvergabe

Eintrag des Namens im Texteingabefeld und Bestätigen mittels Return führt zu einem Callback, der den eingegebenen Text in SpielModusInfo speichert.

Wer fängt an?

Beim Aufruf des Spieleinstellungsrequesters wird der Zufallsgenerator gestartet und ermittelt, wer beginnen soll. Auch diese Information wird in SpielModusInfo gespeichert.

Weiter

Betätigen des Weiter--Buttons führt dazu, daß der struct SpielModusInfo mittels der Methode 3D4G.Spielersetzen() an die Klasse 3D4G übermittelt wird. Mit den so erhaltenen Daten erzeugt 3D4G die entsprechenden Spieler und initialisert die spielbezogenen Daten neu. Danach wird das Neues Spiel--Fenster geschlossen und über Spielbrett.gebe_info_aus() das Info--Fenster aktualisiert.
Wird ein Spielmodus gewählt, welcher Einschränkungen für die Oberfläche beinhaltet, müssen diese vorgenommen werden (z.B. Buttons sperren etc.).

Abbruch

Dieser Button führt dazu, daß ohne eine Veränderung zum Hauptfenster zurückgekehrt wird.

Button: Nochmal Spielen

Dieser Event initialisiert das Brett mittels Brett.Brettleeren() und Spielbrett.Neuzeichnen(), und setzt die Variable für den letzten Zug zurück. Desweiteren werden die Spielerklassen von 3D4G über SpielerKlasse.init() neu initialisiert. Danach kann weitergespielt werden.
Diese Funktion ist nicht verfügbar, falls im Kommunikationsmodus gespielt wird.

Button: Zug zurück

Dieser Event löst einen Callback namens ZZurueck() aus, welcher Brett.Zugzurueck und dann Spielbrett.Neuzeichnen() aufruft.
Diese Funktion ist nicht verfügbar falls im Kommunikationsmodus gespielt wird.

Menü--Ereignisse

Menü: Nochmal spielen, Neues Spiel, Zug zurücknehmen

Diese Menüpunkte rufen die gleichen Callbacks wie die entsprechenden Buttons auf.

Menü: Spielende

Löst einen Callback auf die Funktion Spielbeenden() und einen Requester aus. Wird in diesem Ja (=Ja, es soll abgebrochen werden) gewählt, wird der Destruktor der Klasse 3D4G aufgerufen. Dadurch wird das Spiel beendet.
Wird im Kommunikationsmodus gespielt wird dem gegnerischen Programm von der Klasse 3D4G über die Methode Kommunikation.Abbruch() mitgeteilt, daß das Spiel beendet wurde. Danach wird wie oben bereits beschrieben verfahren.
Wird Nein angewählt, wird ohne eine Aktion auszuführen zum Hauptfenster zurückgekehrt.

Menü: Tip

Bei der Anwahl dieses Menüpunktes wird über 3D4G.AntwortZug() ein Zug von der jeweiligen Gegnerstrategie angefordert (diese berechnet natürlich einen für den Menschen günstigen Zug). Die erhaltene Position wird über Spielbrett.gebe_info_aus() im Infofenster dargestellt.
Diese Funktion ist nicht verfügbar falls im Kommunikationsmodus gespielt wird.

Menü: Hilfe

Die Menüpunkte 1--3 lösen jeweils einen Callback auf eine Funktion aus, die einen externen Textanzeiger (z.B. MOSAIC oder hilfsweise ein XTERM--Fenster) mit dem jeweiligen Text asynchron startet.

Die Klasse dD4G

Diese Klasse ist der Mittler zwischen den Fronten.

Sie weiß im allgemeinen was Sache ist.

Atribute

SpielerxPtr

zeigt auf Spieler x

KommunikationPtr

zeigt auf Kommunikation

BrettPtr

zeigt auf Brett

SpielbrettPtr

zeigt aufs Spielbrett

tFarben

enthält die Farbe des Spielers, der an der Reihe ist

Info

enthält die Informationen zum Spiel

ComputerNamen

Array das die schönen von uns erfundenen Namen für die 3 Strategien enthält

kommdestruct

weiß ob Pipes gelöscht werden müssen

Methoden

Constructor:

Brett und Spielbrett werden erzeugt

Neues Spiel

Spieler1 und -2 werden erzeugt

NochmalSpielen

SetStarter

ZugSetzen

Der Zug wird im Brett gesetzt

AntwortZug

Ein Antwortzug wird angefordert

Tip

Ein Tip wird angefordert

ZugZurueck

Der letzte Zug wird zurückgenommen

Spielersetzen

Spielerklassen initialisieren

Die Klasse Spieler

Die Klasse Spieler ist eine virtuelle Basisklasse für die Klassen Mensch, Computer1, Computer2, Computer3 und Kommunikation. Sie legt die allgemeinen Schnittstellen fest.

Methoden

Zug
Alle Klassen stellen die Methode Zug zur Verfügung. Diese holt oder berechnet einen Zug und setzt diesen im Brett.
Der Rückgabewert dieser Methode gibt an, ob durch diesen Zug das Spiel gewonnen wurde, unentschieden endete oder ob und wie während des Zugs das Spiel abgebrochen wurde.

init(int i)
Beim Aufruf dieser Funktion werden die internen Daten neu initalisiert. Der Parameter i gibt an ob diese Klasse beginnt (1) oder nicht (2).

Die Klasse Mensch

Die Klasse Mensch ist eine Dummy-Klasse.

Die Klassen Computer1, Computer2, Computer3

Methoden

Zug
Ein Zug wird berechnet und im Brett gesetzt. Es wird die Methode ``letzter Zug'' der Klasse Brett benötigt.

Klasse Kommunikation

Die Klasse Kommunikation stellt die Verbindung zu einem anderen entsprechend vorbereiteten 3D--Vier--Gewinnt--Programm zur Verfügung.

(Diese Klasse repräsentiert dann sozusagen den Gegenspieler.)

Attribute

private

tFarben GegnerFarbe:

Die Farbe, mit der die Steine der gegnerischen Seite dargestellt werden.

bool fAbbruchEmpfangen

ist ein Flag als Merker für den Fall, daß die andere Seite das Spiel beendet.

bool angefangen

ist gleich true, genau wenn 'unser' Programm das Spiel beginnt.

public

XtInputId InputId

enthält den Rückgabewert von XtAppAddInput(). Dieses Attribut wird in LegePipesAn() und LoeschePipes() benötigt.
Wegen Streß mit XtAppAddInput und XtAppAddTimeOut ist dieses Attribut public.

XtIntervalId

ist die Id eines Aktiven TimeOut-Timers, der mit XtApp''AddTimeOut() gestartet wurde.
Wegen Streß mit XtApp''AddInput und XtApp''AddTimeOut ist dieses Attribut public.

int PipeHandle:

Handle der Pipe, in die die Daten von Gegenseite geschrieben werden. Muß für Aussen_Lese_Zug() (in comsupport.c) leider public sein.

Methoden

private

void LegePipesAn()

legt zwei Pipes ``player_1'' und ``player_2'' an, über die die Züge zwischen beiden Programmen ausgetauscht werden. Sind die Pipes bereits vorhanden, so fängt die Gegenseite das Spiel an; im anderen Fall beginnt dieses Programm. Diejenige Pipe, aus der Daten des Gegners gelesen werden sollen, wird bei Motif über XtAppAddInput als Eingabemöglichkeit angemeldet.

void LoeschePipes()

meldet ReadPipe bzw. InputId als Eingabemöglichkeit bei Motif ab und löscht die Pipes ``player_1'' und ``player_2''.

void SignalHandler(int)

wird im Konstruktor als Funktion angegeben, die bei Signalen wie SIGSEGV, SIGABRT etc. noch abgearbeitet werden soll.
Es wird die Methode LoeschePipes() aufgerufen, eine Meldung über stderr ausgegeben und das Programm beendet.

public

Kommunikation(tFarben farbe, dD4G *pointer):

Der Konstruktor erhält als Parameter die Farbe, mit der gegnerische Steine in diesem Programm dargestellt werden. Der Wert wird im Attribut GegnerFarbe gespeichert. [Vergleiche auch init(tFarben).]
Der Zeiger dD4G *pointer zeigt auf die Instanz der Klasse dD4G, die den Konstruktor aufgerufen hat. Über diesen Zeiger wird auf Methoden der Klassen dD4G und Brett zugegriffen.
Das Flag fAbbruchEmpfangen wird initialisiert (auf false gesetzt).
Die Methode SignalHandler wird als Handler für Signale wie SIGSEGV etc. angemeldet.
Weiterhin wird LegePipesAn() aufgerufen. Innerhalb dieser Methode wird das Flag angefangen auf den korrekten Wert gesetzt.
Danach wird der Instanz von dD4G mitgeteilt, welche Seite das Spiel beginnt. (Auf die Methode dD4G::SetStarter kann über den von der Klasse Spieler geerbten Zeiger auf dD4G zugegriffen werden.)

Kommunikation():

Im Destruktor wird ein eventuell noch laufender TimeOut-Zähler entfernt.
Wenn dieses Programm gewonnen hat, werden die Pipes durch
LoeschePipes() gelöscht. (Die Gegenseite muß genauso verfahren, damit die Pipes nach einem Spiel auf jeden Fall entfernt werden.)

void Abbruch():

Wird diese Methode aus LeseZug heraus aufgerufen bzw. gilt fAbbruchEmpfangen==true, so wird LoeschePipes() aufgerufen.

Rueckgabewert Zug(tFarben farbe):

Entspricht farbe der Farbe 'unserer' Spielsteine, so wird über Brett::Letzter_Zug() der letzte Zug dieses Programms geholt und an das gegnerische Programm übermittelt.
Ist farbe gleich GegnerFarbe, so wird die Antwort des gegnerischen Programmes aus der entsprechenden Pipe gelesen und ausgewertet. Ein vom Gegner gesendeter Spielzug wird über Brett::''ßug_setzen(tZug) gesetzt.
Sind in der Pipe keine neuen Daten vorhanden, so ist der Rückgabewert 'NixDa'; ansonsten wird der Rückgabewert von
Brett::''ßug_setzen(tZug) oder ein entsprechender Wert für eine Meldung der Gegenseite (wie ``Abbruch'') zurückgegeben.

void init(tFarben farbe)

setzt GegnerFarbe auf farbe, also die Farbe, mit der gegnerische Steine in diesem Programm dargestellt werden.

Funktionen außerhalb der Klasse:
Die folgenden Funktionen werden von der Klasse Kommunikation benötigt und sind in der Datei comsupport.c implementiert.

void Aussen_Lese_Zug()

wird über XtAppAddInput aufgerufen, wenn neue Daten in der zu ReadPipe gehörenden Pipe anliegen und ruft ihrerseits eine Methode der Klasse dD4G auf. Aus dD4G heraus wird Kommunikation::Zug(tFarben) aufgerufen, um die neuen Daten zu bearbeiten.

void Aussen_DoTimeout()

wird über XtAppAddTimeOut aufgerufen, wenn eine festgelegte Zeitspanne abgelaufen ist und ruft ihrerseits void Kommunikation::DoTimeOut() auf.

Die Klasse Brett

Diese Klasse repräsentiert die Daten des Spielbretts, auf die mit speziellen Methoden zugegriffen werden kann.

Attribute

Datenstruktur

Die Daten werden in einem 4 x 4 x 4 Array (Würfel) mit dem Inhalt schwarz, weiss und frei vom Typ tFarben verwaltet.

letzterZug

Das Attribut letzterZug ist ein eindimensionales Feld vom Typ tZug. In ihm werden die gemachten Züge gespeichert.

letzteZugNummer

Das Attribut letzteZugNummer ist ein Index (vom Typ integer), welcher immer auf den letzten Eintrag in dem Feld letzterZug zeigt.

Anz_Steine

Das Attribut Anz_Steine speichert die Anzahl der schon gesetzten Steine und ist vom Typ integer.

Methoden

Methode Zug-setzen
Parameter: tZug, wobei der z-Wert nicht relevant ist und Null sein kann
Rückgabewert:

0 : ungültiger Zug

1 : gültiger Zug

2 : Spiel gewonnen

3 : Remis

Diese Methode bekommt die 2D-Koordinaten(x,y) und die Farbe des Spielers übergeben, der gerade am Zug ist und liefert oben genannte Rückgabewerte zurück. Dabei wird intern nur dann ein Stein (d.h. 1 oder 2) gesetzt, falls der Zug ein gültiger Zug war (wird mit Hilfe von Zug_legal abgeprüft). In dem Fall wird dann zuerst das Attribut Anz_Steine und das Attribut letzterZug aktualisiert. Dann wird überprüft, ob das Spiel mit diesem Zug gewonnen wurde oder ein Remis vorliegt. Dementsprechend ist der Rückgabewert. Wenn ein Stein gesetzt wurde, wird Neuzeichnen(Ebene) des Spielbretts aufgerufen.

Methode Zug-zurueck
Parameter: tFarben
Rückgabewert: FALSE: Zug wurde nicht zurückgenohmen
TRUE: Zug oder Züge wurden zurückgenohmen

Diese Methode löscht den letzten oder die beiden letzten Züge (falls der Gegner schon am Zug ist) und gibt TRUE als Rückgabewert zurück. Falls der aktuelle Zug schon zurückgenommen oder im bisherigen Spielverlauf noch kein Zug gemacht wurde (Attribut letzteZugNummer = -1), wird FALSE als Rückgabewert zurückgegeben.

Methode Daten-auslesen
Parameter: tPosition
Rückgabewert: tFarben, Farbe des Spielsteins an der Position

Methode Brett-leeren
Parameter: keine
Rückgabewert: keiner

Diese Methode initialisiert (löscht) das komplette Brett. D.h. jedes Feldelement des Attributes wuerfel[ ][ ][ ] wird auf 'frei', das Attribut Anz_Steine auf 0 und das Attribut letzteZugNummer auf -1 gesetzt.

Methode Zug-legal
Parameter: tPosition, wobei der z-wert nicht relevant ist
Rückgabewert: tPosition, wobei der z-Wert angibt, wo der Stein reinfallen würde
Ist der z-Wert gleich -1, dann ist die senkrechte Reihe schon voll

Diese Methode prüft anhand der ihr übergebenen Parameter, an welche z-Position der Stein fallen würde, oder ob der Zug illegal ist. Je nachdem ist der Rückgabewert. Diese Methode prüft nur UND setzt nicht den Zug.

Methode Letzter-Zug
Parameter: keine
Rückgabewert: tZug, d.h. den letzten gemachten Zug
tZug = -1,-1,-1,frei falls noch kein Zug gemacht wurde

Diese Methode liefert den letzten gültigen Zug. Falls im Spielverlauf noch kein Zug gemacht wurde, wird ein dummyZug vom Typ tZug zurückgegeben.

Die Klasse Spielbrett

Attribute

private:

Spielwiese: technisch: struct polygon Spielwiese wobei D.h. die Spielwiese besteht aus 4 Gittern, wobei nur das oberste Gitter Zugeingaben zuläßt.

Ein Gitter besteht aus 16 Polygonen bzw. Parallelogrammen.

wobei die c-te Ebene

Das private Linienarray Gitter beinhaltet die vier Außenlinien des obersten Gitters. Diese werden im Konstruktor berechnet und bei der Methode Feldpositionberechnen bzw. ist_in_Gitter benötigt.

Die Struktur polygon besteht aus den Punkten A,B,C,D und einem Mittelpunkt M; der Schnittpunkt der beiden Diagonalen.

Die Struktur linie besteht aus den zwei Punkten A und B, welche jeweils die globale Struktur tPunkt haben.

Ein Punkt besteht aus einem globalen Tupel der Form tPunkt(int x; int y;).

Integerkonstante anzahl_meldungen legt fest, wieviel Meldungen im Info--Fenster angezeigt werden sollen; sie wird für die Methode gebe_Infos_aus gebraucht.

Integerkonstante anzahl_buchstaben legt fest, wie lang ein Textstring sein soll und wird für die Methode gebe_Infos_aus benötigt.

Sonstige:

Methoden

private:

Konstruktor: Berechnet die Linien des Spielbretts und initialisiert die Attribute.

ccw

Parameter: Tripel von Punkten, welche die globale Struktur tPunkt haben.

Rückgabe:

Teste, ob man für die drei Punkte, wenn man vom ersten zum zweiten und dann zum dritten geht, sich im oder gegen den Uhrzeiger dreht.

schneidet

Parameter: Tupel von Linien, wobei eine Linie die Struktur linie hat.

Rückgabewert:

Prüft, ob sich zwei Linien schneiden.

ist_in_Gitter

Parameter: Koordinate des Mauscursors mit der Struktur tPunkt

Rückgabewert:

Prüft, ob Mauscursor sich innerhalb des obersten Gitters befindet.

public:

Neuzeichnen

Stellt gesamte Spielwiese graphisch dar. Dabei wird auf die Methode Brett.Daten_auslesen(tPosition) zugegriffen. Das Info--Fenster bleibt dabei unverändert.

Parameter: keiner

Rückgabewert: keiner

aktualisiert nur die c-te Ebene von unten und verändert das Info--Fenster nicht. Es erfolgt ein mehrmaliger Aufruf von Brett.Daten_auslesen.

Parameter:

Rückgabewert: keiner

gebe_Info_aus

Parameter: Struktur SpielModusInfo und Integer was_noch mit:

Das Info--Fenster hat den Widgetnamen infoT. Eine Textzeile hat Platz für anzahl_buchstaben. Es ist Platz für anzahl_meldungen vorgesehen.

Rückgabewert: keiner

Die Methode gibt Informationen über den Spielmodus, Spielstärke, wer beginnt und wer gewonnen hat aus.

Feldpositionberechnen

Parameter: Mauskoordinaten (bezogen auf das Programmfenster) in der Struktur tPunkt

Rückgabewert: Koordinate mit der Struktur tPunkt

Versuch, die Mauskoordinate auf Koordinaten des oberen Gitters abzubilden.

FeldMarkieren

Parameter: Mauskoordinaten (bezogen auf das Programmfenster) in der Struktur tPunkt

Rückgabewert: keiner

Die Methode verändert den Mauscursor, falls dieser sich über einem zulässigen Eingabefeld befindet.

Kommentare:

Der von keinem erwartete Abschnitt mit Carstens [Anm.: Carsten Thurau] Kommentar
Mein Kommentar zum Propra:
Wieder einmal eine Pflichtveranstaltung hinter mir

Nein, so schnell und abwertend kann man das Thema nicht abhaken. Entgegen anders lautenden Gerüchten hat es mir Spaß gemacht, und sogar einen Sinn habe ich entdeckt.

Was hat es gebracht:

es war für die meisten wahrscheinlich der erste Versuch, in einer größeren Gruppe zu arbeiten. Sicherlich hätte das Problem auch zu zweit lösen können aber darum ging es nicht. Hier konnte man einfach lernen, was man bei Gruppenarbeit zu beachten hat, welche Fehler auftreten können und wir nutzten die Gelegenheit, aus Fehlern zu lernen, sehr gut aus. Vor allen Dingen dürften wir gelernt haben, dass genaue Absprache selbst der Details, die selbstverständlich erscheinen, selbstverständlich sein sollte.
,,Die Ebene 0 ist bei uns unten.``
,,BEI UNS IST SIE ABER OBENt`

Während in INFO A nur einige lückenhafte Grundlagen der Sprache C++ vermittelt wurden, in B diese ignoriert wurde, kam INFO C. Meine Hoffnungen, dort etwas mehr über C++ zu erfahren waren genauso groß wie falsch. Durchaus konnte man etwas dazulernen - jedoch nur auf wenig vernünftige Weise: es kamen neue Elemente in den Programmen der Vorlesung vor, die man dann zu Hause verstehen sollte.
Im Propra lernte ich zwangsläufig mehr über mir vorher verborgen gebliebene Elemente wie virtuelle Funktionen und abstrakte Basisklassen, auch einiges über Konzepte, die hinter C++ stehen - jedoch nur in Eigenarbeit.
Vielleicht sollte man mal darüber nachdenken, eine Vorlesung zum Thema C++ nicht erst im Hauptstudium anzubieten, wenn sich fast jeder schon selbst die Kenntnisse angeeignet hat
Aber immerhin: nun ist mir C++ kein Fremdwort mehr, nur ein Reizwort

Gut, dass man sich Kenntnisse mit diversen Hilfsprogrammen selbst aneignen musste; dass wird den Informatiker auch später noch belasten. Interessant die Argernisse mit diesen ,,Hilfen`` - manchmal scheinen sie Eigenleben zu entwickeln.

,,Manfred hat Humor -- man sieht es an Motifation.``

Das wichtigste jedoch war der Bericht über Computer-Psychologen in Norwegen

Stephan I.:
Es waere ,,günstig`` gewesen, wenn alle nicht nur Dokumente produziert hätten, sondern diese auch zur Impelementation nochmal gelesen (!!!) hätten
Ansonsten fand ich, daß wir Eine starke Truppe waren!! :-)
Brain over --- Insert coin