Aui | DesMas

So. längere Zeit war mal wieder nichts zu hören, nun so ist das nunmal wenn erst einmal die Feiertage da liegen und dann auch noch der Beruf einem die Zeit wegfrisst.

Heute möchte ich einmal allgemein vorab auf die Berechnung des Gewinners eingehen, die nach jedem Spielzu erfolgen muss.

Aus meinem letzten Post über die Logik für den Einwurf eines Steines ging ja bereits der Einsprungpunkt für die Berechnung des Gewinners, bzw. der Funktionsname hervor. Hier noch einmal der Code Abschnitt:

Für die Berechnung des Gewinners muss eine Iteration über das gesamte Spielfeld stattfinden, und von jedem Feld aus geprüft werden, ob der Spieler dessen Spielstein hier liegt auch in den folgenden 4 Richtungen des Spielfeldes mindestens 1mal eine 4er Reihe besitzt:

• rechts
• unten
• diagonal rechts unten
• diagonal links unten

Der Findige sagt zwar jetzt, dass man doch auch nach oben und links etc prüfen muss, diese Richtungen ergeben sich jedoch von selbst aus der Iteration über das Spielfelds. Die kleine Grafik soll das Muster der Prüfung ein wenig schemattisch veranschaulichen.

die gesamte Iteration lässt sich nun noch ein wenig vereinfachen:

1. Die einzelnen Prüfungen müssen nur angestossen werden, wenn das aktuelle Feld belegt ist.
2. Zwar ist es prinzipiell für den menschlichen Verstand einfacher von oben links durch das Spielfeld zu laufen, jedoch füllt sich das Spielfeld von unten und so ist es sinnvolssten auch hier anzufangen.
3. Wenn man unten anfängt ist es nicht sinnvoll die Wege nach unten zu prüfen, sondern statt dessen nanch oben, oben links, oben rechts.

Auf diese Weise läuft die Berechnung des Siegers vom ersten Spielzug an schnell und wird nur durch die Menge der Spielsteine mit der Zeit langsamer. Es lässt sich dagegen noch eine weitere Optimierung einbauen: wenn beim Durchlauf einer Zeile (davon ausgehend das man nach dem Muster “über alle Zeilen – über alle Spalten” prüft eine komplette Zeile als nicht belegt erkannt wird, braucht man die darüber liegenden Zeilen gar nicht mehr zu prüfen. )

So, damit hätten wir alles nötige um die Implementierung im Prinzip abbilden zu können. Nachfolgend noch einmal der Ablauf in eienr Art Pseudocode, ohne zu viele Optimierungen

von unten lins aus

über alle Zeilen

über alle Spalten

Zelle belegt?

prüfe 3 nach rechts

prüfe 3 nach oben

prüfe 3 nach oben links

prüfe 3 nach oben rechts

Nachdem ich die letzten Tage eine Reihe von Hilfsfunktionen veröffentlicht habe, kommt heute die Funktion, mit diese alle verwendet werden um den Einwurf eines Steins durch den aktiven Spieler zu realisieren und somit den Spielablauf zu steuern.

Die Funktion selbst ist letztendlich im Kern nichts weiter als ein Aufruf der einzelnen Hilfsfunktionen in einer bestimmten Reihenfolge:

1. Prüfungen
   1. auf Initialisierung
   2. auf gültigen Spaltenindex
2. Ermittlung des aktiven Spielers
3. Ermittlung dessen Spielsteins
4. Setzen des Steins in die erste freie Zelle in der Spalte
5. Aktualisierung des Spielfeldes
6. Prüfung auf Gewinner
7. Wechsel des Spielers

Die heutige Hilfsfunktion Aktualisiere Spielfeld, stellt die letzte der zentralen Funktionen dar, die für den Einwurf eines Spielsteins und die notwendigen daraus resultierenden Berechnungen (ausser der Gewinnerermittlung) notwendig sind.

Zweck dieser Funktion ist es die interne Abbildung des Spielfelsdes, im Code als 2dimensionales Array definiert, zu visualisieren.

Die Funktion selbst ist noch so trivial implementiert, dass eine feste Größe des Spielfeldes von jeweils 7 Feldern angenommen wird. De facto sollte man aber die Iteration in den beiden Schleufen dynamisch mittels UBound() und LBound() halten.

Die Funktion durchläuft nun jedes Feld des 2dimensionales Arrays Spielfeld und trägt deren Wert in das entsprechende Feld in der Excel Arbeitsmappe ein. Welches Feld das korrespondierende ist, wird über die beiden Arrays Zeilen() und Spalten() bestimmt, für die jeweils der Wert am Schleifenindex X bzw. Y bestimmt wird. Diese Werte werden verkoppelt und dienen dann als Zelldefinition.

Da ich die letzten Tage nichts gepostet hatte, gibts heute gleich noch einmal eine triviale Funktion hinterher.

Die Funkion AktiverSpieler() ermittet dient zur Rückgabe des aktuell eingetragenen aktiven Spielers. Da dieser durch die Funktion SpielerWechsel immer an einer Festen Position steht, liest diese Funktion den Feldwert schlicht aus der Zelle im Excel Sheet aus.

Der Vorteil dieser Funktionskapselung besteht daran, das man einfach in jeder anderen Funktion mittes des Aufrufs AktiverSpieler direkt den Namen parat hat, ohne jedesmal auf die Zelle gehen zu müssen. Dies bietet besonders dann einenVorteil, wenn man das Spielfeld oder auch nur die Ausgabeposition des Spielernamens in der Excel Tabelle verändert, denn dann muss man nur eine Zeile im Programmcode an einer Stelle anpassen und nicht alle möglichen Vorkommen suchen.

Die heutige Funktion dient dem Zweck, zu einem übergebenen Spaltenwert, analog einer Excel Spaltennummer, den korrespondierenden Wert aus dem Spaltenarray für das Spielfeld zu ermitteln.

Hintergrund dieser Funktion war der Gedanke die Programmierung so weit abstrakt und dynamisch zu halten, damit das Spielfeld sich in Excel an jeder Position befinden kann.

Der Abnlauf der Funktion ist dafür denkbar einfach:

Es wird das Array Spalten() durchaufen und jeder Wert mit dem übergebenen Spaltenbuchstaben verglichen. Sobald eine Übereinstimmung vorliegt, wird die Schleife und die Funktion verlassen. Der ermittelte index liegt dann über die Variable iIndex der rufenden Funktion vor.

Anmerkung:

Im Gegensatz zu den letzten Hilfsfunktionen hat diese den “nach meiner Ansicht” korrekten Standardaufbau einer Scriptfunktion:

• boolscher Rückgabewert zur Kennzeichnung des korrekten oder fehlerhaften Ablaufs
• Wertübergabe aus der Funktion rein über Call by Reference Variablen

Die heutige Hilfsfunktion Spielerstein() ist ebenfalls eine triviale Funktion, die ich direkt im Ganzen postet.

Zweck der Funktion ist es, zu einem übergebenen Spielernamen den entsprechenden Spielerstein zu ermitteln.

Name und Stein des Spielers sind wie gewohnt im 2dimensianalen Spielerarray enthalten. somit wird in einer einzelnen Schleife über die erste Dimension des Arrays iteriert und der übergebene Name mit dem im Array verglichen.

Sobald ein Treffer vorliegt, wird die Schleife verlassen und der Stein als Ergebnis zurückgeliefert. Wurde bis zum Ende der Iteration nichts gefunden, do wird als Funktionswert ein leerer String zurückgegeben.

Die heutige Hilfsfunktion ist wieder eine sehr triviale Funktion, die ich gleich im Ganzen angebe. Sinn und Zweck der Funktion ist es, zu einem übergebene Spielernamen aus dem Spielerarray den Indexwert zu ermitteln:

Dazu durchläuf die Funktion das Spielerarray in einer Zählschleife von der Untergrenze (LBound() ) bis zur Obergrenze (UBound()) und prüft für jeden Index, on der übergebene Name mit dem Namen an der aktuellen Stelle übereinstimmt.

Sobald ein Treffer vorliegt, wird der Index als Funktionswert belegt und die Schleife beendet. Wird nichts gefunden, so erreicht die Funktion das Ende der Schleife und als Standardwert wird 0 zurückgegeben. Dies ist natürlich nur bedingt sinnvoll, wenn das Array bei 0 beginnt. Es sollte als bedacht werden, welche Wert letztendlich als Fehlercode verwendet wird (für ein SpielerArray von 1-n ist 0 durchaus gültig).

Bevor ich mit der Erläuterung der Funktion zur Umsetzung des Einwurfs eines Steins in einer Spalte des Spielfeldes beginne, möchte ich zunächst einmal eine Reihe von Hilfsfunktionen, die hierbei verwendet werden erläutern.

Einige davon sind speziell nur für den “Einwurf” gedacht, andere wiederum haben einen eher generellen Charakter und sind auch für die Verwendung in weiteren Bereichen der Answendung gedacht.

Auf die erste Funktion, BerechneStartSpieler(), bin ich ja bereits im vorherigen Post eingegangen. Kommen wir heute zur Funktion SpielerWechsel()

Sinn dieser Funktion ist es, vom aktuellen Spieler ausgehend den anderen Spieler zu ermitteln.

Die Funktion arbeitet nach dem folgenden einfachen Muster:

1. Auslesen des Feldwerts für den aktiven Spieler
2. Ermittlung des 2. Spielerwertes aus dem Spielerarray (dessen Name abweicht)
3. Eintragung des Namens in das Feld für den aktiven Spieler

Da die Funktion recht trivial in ihrem Inhalt ist, denke ich mal nicht dass eine tiefere Beschreibung notwendig ist.

Heute folgt die Erläuterung der Hilfsfunktion BerechneStartSpieler(), die in der Initialisierung verwendet wird.

Die Funktion ist an sich äußerst trivial, und wird daher hier einmal komplett aufgelistet. Damit zeige ich auch gleich den generellen Aufbau der Funktionen in VBA für diese Anwendung mitsamt Kommentarkopf unf Fehlerbehandlung.

Die gesamte Logik steckt eigentlich in nur 2 Zeilen. Zum einen wird zuerst mittels Math.Randomize der Zufallszahlengenerator initialisiert. Danach erfolgt die Berechnung der Zufallszahl in den vorgegebenen Grenzen gem., der aus der VBA Hilfe für Rnd übernommenen Struktur.

Der Aufbau der Funktion ist hier auch gleich mal Beispiel für die von mir verwendete Programmierkonvention. Die Funktionen selber haben als Rückgabewert einen Boolean Typ mit dem der rufenden Funktion eine korrekte oder fehlerhafte Verarbeitung signalisiert wird.

Der Datentransfer zur rufenden Funktion erfolgt rein über die Parameter (hier iResult als Ausgabeparameter), die generell als “call by reference” übergeben werden. Die eintige Ausnahmevon dieser Notation bilden “Trivialfunktionen” die i.d.R einen String zurückgebenund im Fehlerfall einfach einen Standardwert oder “”als Funktionswert haben. zu diesenHilfsunktionen komme ich im Zuge der Erläuterung der Funktion für den Einwurf eines Spielsteins in eienr Spalte des Spielfeldes.

Bevor man eigentlich mit dem Spiel loslegen kann, muss das Spielfeld erst einmal initialisiert werden. Bei einem ersten Start mag das vielleicht noch nicht ganz so wichtig erscheinen, doch spätestens wenn man eine 2. Spielrunde starten will, muss man ja erst einmal das Spielfeld löschen.

Schritt 1: Variablen

Der erste Schritt der Funktion, die ich StartSpiel() genannt habe führt die Initialisierung des Spalten und Zeilenarrays aus:

Die beiden Arrays dienen im weiteren Programmablauf dazu, die einzelnen Excel Zellen des Spielfeldes einzugrenzen. Jede Kombination der beiden Arrays bestimmen als X/Y Wert eine Zelle des Spielfeldes auf der “Excelmaske”.

Schritt 2: Spielerdaten

Schritt 2 befasst sich mit dem Auslesen und Validieren der Spielerdaten.

Spieler() ist hierbei wiederum ein 2 dimensionales Array, bei dem der 1. Index den Spielernamen, der 2 Index den “Spielstein” aufnimmt.

Nur wenn beide Spielernamen angegeben sind, wird die Verarbeitung der Funktion weiter ausgeführt. Andernfalls erfolgt eine Meldung über das Fehlen mindestens eines Spielernamens oder auch Beider und ein gezielter Abbruch der Funktion.

 Schritt 3: Spielfeld löschen

Als nächstes wird in einem kleinen Schleifendurchlauf das Spielfeld, dass als globales 2 dimensionales Array deklariert wurde gelöscht/initialisiert:

Schritt 4: ersten Spieler ermitteln

Damit nicht immer mit dem gleichen Spieler begonnen wird, habe ich eine kleine Hilfsfunktion implementiert, die mittes Zufallszahlen einen Spieler als startenden Spieler ermittelt.

Das Ergebnis der Funktion wird dann als Wert im Spielfeld eingetragen. Im Laufe des Spiels wird diese Zelle “I4″ immer mit dem Spieler angedruckt, der seienn Zug machen soll. Die ausprogrammierte Logik der BerechneStartSpieler() wird in einem späteren Post erläutert werden.

Schritt 5: Abschlußmeldung:

Wie sich das für jede Initialisierungsfunktion gehört, wird zum Abschluß, wenn die Verarbeitung erfolgreich war, eine Meldung ausgegeben, die dem Spieler signalisieren soll, dass er loslegen darf.