Aui | DesMas

Seit mehr als einem Jahr nutze ich meine Synology Diskstation bereits als Festplattenserver um meine Daten vom PC System frei verwenden zu können.

Mit der zuletzt anstehenden Migration meines MulitOS PC mit der ich gleich auch einige verkorkste Partitionseinstellungen ändern wollte kam dann der Gedanke, das Gerät auch für Entwicklungszwecke zu benutzen.

Während PHP und MySQL von der Kiste bereits nativ unterstützt werden und sich die PhpMyAdmin Oberfläche als einfaches Addon nachinstallieren lässt, fehlt nur noch das Subversion zum Glücklich sein.

Zum Glück führt Synology eine gute Wiki, die beschreibt, was hierfür von Nöten ist.

Zuerst einmal muss das “Itsy Package Management System” installiert werden, damit man damit wiederum das SVN installieren kann. Dafür wiederum muss man erst mal den SSH Zugriff auf der Kiste aktivieren, sofern das nicht nicht geschehen ist. Alles weitere wird in der Wiki sehr ausführlich erklärt. Auch den abschließenden Part mit der Umstellung der Startskripte sollte hierbei befolgt werden. Für die Installation ist es durchaus hilfreich, den FTP Zugang auf der DiskStation zu konfigurieren und so das Ipkg Paket und das shellscript schon mal auf die Kiste zu laden.

Den zweiten Schritt bildet dann die Installation des Subversion. Auch hier für gibt es wieder eine gute Erklärung seitens Synology in deren Wiki, die man einfach abarbeiten muss. Diese ist im Gegensatz zum ipkg auch wesentlich schneller erledigt. Nun fehlt nur noch der Umzug des Repository.

Dazu wird zunächst mittels des svnadmin auf dem Quellsystem eine Sicherung angelegt.
sudo svnadmin dump /Pfadt/zum/repository > /home//Dokumente/repo.dump

Das erzeugt File lässt sich dann mit dem FTP Zugang auf die DiskStation kopieren und dort mit einem Befehl wieder direkt in das vorab erzeugte Repository installieren
svnadmin load /volume1/svn/repository < /volume1/DS211j/repo.dump

Erschreckend einfach, einfach erschreckend

Erkenntnis des heutigen Tages bei der Installation von Gnome3 unter Ubuntu 11.10:

Die Entwickler haben (vielleicht beabsichtigt) vergessen, die Tastenkombination Alt+F2 zur Darstellung der Eingabezeile für Befehle zu aktivieren.

Für alle, die aus Gewohnheit diese gerne wieder haben möchten gibts jedoch keine Notwendigkeit darauf zu verzichten.

• Unter Gnome 3 mittels Supertaste (i.d.R. jene mit dem Windoof Symbol) und Eingabe von “Systemeinstellungen” im Suchdialog diese Konfigurationsoberfläche laden.
• Dort auf den Eintrag “Tastatur” klicken, um das Widget zu laden
• Hier nun auf den Karteireiter “Tastaturkürzel” klicken und zum Eintrag System navigieren
• Mittels Klick auf den Eintrag “Deaktiviert” der Zeile “Den >Befehl ausführen< Dialog anzeigen” kann nun wieder die Tastenkombination vergeben werden
• et voila

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.