Programmiertagebuch

So, nachdem nun eine lange Pause war, werde ich mich die nächsten Tage wieder intensiver mit der Programmierung beschäftigen. Studium geht ja auch bald los.

Weitere Blog-Einträge werde ich auf meinem normalem Blog posten:
blog.spunkmeyer.de

Ich habe lange nichts mehr geschrieben. Das liegt hauptsächlich daran, dass ich mich um die schriftliche Arbeit zu der KI gekümmert habe. Programmiert habe ich in dieser Zeit eher weniger. Allerdings ist die KI mittlerweile besser geworden. Sie speichert alles ab und ein neuronales Netz versucht die guten Entscheidungen zu generalisieren, damit sich die KI immer gut verhält. Die KI berücksichtigt nun auch Abhängigkeiten und baut einen Compiler bevor sie Einheiten baut. Ein grafisches Interface ist von Markus fertiggestellt worden und wird heute auch noch eingefügt. Die Screenshot-Seite bekommt dann auch wieder ein paar Bilder spendiert. Auch wenn ich die Arbeit morgen abgebe wird noch an dem Spiel gearbeitet, denn es ist zwar alles drin, aber die Bedienung ist noch nicht optimal und grafisch lassen sich auch noch Verbesserungen einbauen. Als Release-Termin steht jetzt der 27. Juli und das soll auch so bleiben :-)

So, nun werden auch 'Malloc'-Units von der KI gebaut. Wenn die KI gegen die KI antritt dauert das Spiel meist sehr lang, da sie sich ähnlich schnell entwickeln. Der nächste Schritt ist ein Benchmark-Level, um zu prüfen, wie die KI abschneidet. Sie soll ja besser werden. Da ist ein objektives Bewertungsmittel angebracht. Ich habe auch noch Symbolgrafiken eingefügt für die niedrigste Zoomstufe. So erkennt man auch aus Entfernung noch, ob es Gebäude oder angreifende Einheiten sind.

Im Moment machen die KI Gegner schon gute Dinge, aber es sind noch ein paar Fehler vorhanden. Und um ihre Ressourcen kümmern sie sich gar nicht. Das wird sich aber noch ändern...

Mittlerweile habe ich die Klasse DecisionMaker in die KI-Player-Klasse eingefügt und die ersten Bauentscheidungen werden von der KI getroffen. Im Moment aber total zufällig, da ich die Spielsituation noch zur Laufzeit bewerten muss und die 'Erinnerungen' der KI noch auf die Festplatte schreiben muss, sonst fängt man jedesmal von vorne an. Dann muss auch noch die Gewinnbedingung der Spieler eingebaut werden, damit Spiele auch ein Ende haben. Danach kann ich hier wohl die erste Tech-Demo zum Runterladen anbieten, da dann die Kernfunktionen des Spiels fertig sind. An einem Menü und evtl. sogar einem Intro-Video wird gearbeitet.

Dann mach ich mich mal an die Arbeit :-)

Ich habe das reinforcement learning mal mit einem komplexeren Beispiel getestet und es hat völlig versagt. Ich habe dann nochmal überlegt und habe mich für einen Situationsspeicher entschieden. Wenn die KI eine Situation schon kennt (Mit einer gewissen Ähnlichkeitstoleranz), überprüft Sie, ob die Aktion, welche sie damals ausgeführt at, gut oder schlecht war. Bei einem guten Ergebnis macht sie dasselbe nochmal. War das Ergebnis schlecht, macht sie was anderes.
Das funktioniert sehr gut bisher und wird deshalb auch Eingang ins Spiel finden.

Danach habe ich mich erstmal den Influencemaps gewidmet. Diese funktieren auch ganz gut. Dadurch kann der Computer gefährliche Gegenden erkennen und meiden. Davon gibt es auch einen Screenshot.

Nachdem ich nun lang genug gegrübelt habe, welche Strategie ich benutze, um dem Computer das lernen beizubringen, habe ich mich für Reinforcement learning entschieden. Es kommt der Natur recht nahe, da gewinnbringendes Verhalten 'belohnt' wird und sich festsetzt und verlustbringendes Verhalten 'bestraft' wird und vergessen wird. Dadurch brauche ich dem Computergegner nicht sagen, was in einer Situation gut oder schlecht ist, sondern der Computer probiert es aus und erfährt es selbst. Dadurch wird er anfangs viele Fehler machen. Mal sehen wie stark sich das auf die Spielbarkeit auswirkt.

Desweiteren habe ich über developia.de jemanden gefunden, der bereit ist, die Spielgrafiken zu machen. Meine waren ja geradezu unansehnlich. Das ist auch der Grund für das neue Logo und den neuen Menüpunkt 'Team' auf der linken Seite.

Einen ersten Test für Reinforcement learning habe ich bereits programmiert. Auf der KI-Webseite gibt es dazu wieder ein wenig zu lesen und zu schauen.

So, nun ist das Spiel in einem Spielbaren Zustand, auch wenn noch ein paar Details fehlen. Aber es kann nun begonnen werden eine KI zu implementieren.
Ich bin mir noch nicht sicher, was für eine Spieler KI ich verwende. Tendieren tue ich zu neuronalen Netzen... Auf der linken Seite ist nun ein neuer Punkt für Codestatistiken. Da kann man sehen, wie gut ich mit dem Kommentieren vorankomme und wieviele Zeilen Code geschrieben wurden.

Getrieben vom Willen, endlich was Spielbares zu haben, arbeite ich nun vermehrt an dem Projekt. Ich muss mich ja so schnell es geht auch um die KI kümmern (Womit ich schon längst richtig angefangen haben wollte).

Jedenfalls bewegen sich nun die ersten Einheiten über den Schirm. Die Malloc-Unit allokiert speicher und ein Garbage-Collector räumt wieder auf :-)

Der Scout läuft auch schon rum, kann aber noch nicht schiessen. Wenn die Schiessen-Logik erledigt ist, und auch Einheiten sowie Gebäude zerstört werden können, ist noch ein bischen was an der GUI zu machen und danach ist das Spiel spielbar.
Dann gehts an die KI, damit man auch einen Gegner hat, denn die Netzwerkschnittstelle macht momentan probleme, das es zu mehrfachen Deklarationen von Funktionen kommt. Liegt wohl an TNL oder an Boost. Mal sehen.
Es gib jedenfalls noch einen neuen Screenshot.

Damit man Einheiten und Gebäude voneinander unterscheiden kann, habe ich nun einen Texturmanager programmiert. Dieser kümmert sich automatisch um das laden der richtigen Texturen zur richtigen Zeit. Dadurch spart man sich die ladeZeit um Anfang und braucht keinen Code in anderen Klassen schreiben und hat die Texturverwaltung zentral. Man kann auch am Anfang alle Texturen einmal abfragen, wodurch sie geladen werden. Dies erlaubt dann einen flüssigeren Spielablauf. Dazu gibt es einen aktuellen Screenshot.


Die Grafiken sind natürlich so, wie masn sie von einem Programmierer erwartet ^^

(Wer mir da helfen möchte, kann gern mit mir in Kontakt treten.) Es hat sich schon jemand gemeldet !!

Nun kann man an beliebiger Stelle mit dem Mausmenü Einheiten einfügen. Im Moment bewegen diese sich noch nicht, aber das folgt bald. Damit man eine Rückmeldung hat, ob der Befehl erfolgreich ist, bekommt man dies im Logfile-Fenster angezeigt.

Dazu gibt es mal wieder einen aktuellen Screenshot.

73% Meines Codes sind Ohne Kommentar... Das muss ich wohl nochmal Nachholen...
Deshalb habe ich mir nun Doxygen installiert und beginne dementsprechend zu kommentieren. Nicht das mir mein Code über den Kopf wächst. Ist ja schon erstaunlich wie viel Code man für die einfachsten Dinge braucht...

Apropro's Code: Ich will mich demnächst mal hinsetzen und meine KI-'Tutorials' (Wenn ich sie so nennen kann) mal mit Beispielquellcode versehen und noch etwas ausbauen.

Es werden nun die Dateien der Einheiten gelesen und daraus auch gleich ein Baumenü generiert. Ich muss nun noch eine Methode schreiben, die prüft, ob bestimmte Gebäude und Einheiten gebaut werden können. Ob also alle Bedingen im Tech-Tree erfüllt werden. Diese Optionen bekommen die Spieler (KI und Mensch) zu sehen und können sie auch auswählen. Eine weitere Einschränkung ist hier der Einheitenname. Er darf im Spiel nur einmal vorkommen, sonst ist er nicht zuzuordnen. Aber wer will schon 2 Einheiten, die gleich heissen?

Für die Einheitentypen habe ich mir gedacht, das ich verschiedene Projektile brauche. Ansonsten machen verschiedene Einheiten keinen Sinn. Es wird also ein Stein-Schere-Papier-Prinzip eingebaut.

Fur die KI brauche ich noch einen guten Algorithmus damit unüberwacht gelernt werden kann. Denn sonst müsste ich der KI beibringen, wie sie sich in welcher Situation verhalten soll. Und das wäre dann sehr aufwändig und auch unflexibel. Es ist ja grad der Sinn, das sich die KI von allein entwickelt. Also werde ich eine Funktion schreiben, die zu jeder Zeit das Spiel bewerten kann. Dadurch kann die KI ihren Erfolg messen und sich entwickeln.

An der Schriftlichen ausarbeitung habe ich heute auch weitergearbeitet. Die ersten 5 Seiten sind in Rohform erstellt.

Ich habe mich ja dazu entschlossen, das System flexibel zu halten. Damit ich aber dennoch nicht zu viel zu tun habe, baue ich doch gewisse Grenzen ein, damit ich schneller fertig werde. So habe ich das Spielfeld auf 2000 x 2000 Teile begrenzt. Das sind ja immerhin 4 Millionen Positionen für Einheiten. Es geht mehr, aber dann hat man nur noch eine Slideshow und kein flüssiges Spiel...
Einheitentypen habe ich ja nur ein paar (Im Moment 7), das System ist aber Flexibel. Aber auch hier habe ich erstmal eine Grenze eingebaut: Maximal 99 Gebäudetypen, maximal 99 Einheitentypen und maximal 99 Forschungen und Verbesserungen. Ich denke, das diese Grenzen nicht so schnell gesprengt werden. ;-)
Mal sehen auf wie viele Einheiten pro Spieler ich begrenzen muss, damit das Spiel noch läuft. Eine Massenschlacht mit sehr vielen Einheiten wär natürlich toll, hat aber erstmal keine Priorität.
Die Einheitendaten werden schonmal erfolgreich geladen.
Intern läuft das Spiel wie jedes Strategiespiel in festen Runden. Ich habe mich für 10 Runden die Sekunde entschieden und hoffe, damit ein schnelles Spiel machen zu können. Die Spiele sollen nämlich schnell zuende gehen, da die KI von kurzen Spielen besser lernt als von langsamen Spielen.
Da die Steuerung eines Teams flexibel über den lokalen Rechner, über LAN oder durch eine KI zu übernehmen ist, kann ich auch KI gegen KI antreten lassen und sehen, was für Spielestrategien sich entwickeln.

Im Moment arbeite ich an der Spielelogik. Und dort speziell an der Datenhaltung und Datenverarbeitung. Da ich die Einheitenliste gern Data-Driven hätte, muss ich das Datenverzeichnis nach Dateien durchforsten und diese Dateien in eine Liste einsortieren. Dabei müssen auch Abhängigkeiten aufgebaut werden. Die Daten müssen in einem Format gelagert werden, in dem ich möglichst effizient die Einheiten anzeigen kann, die KI diese abfragen kann und die sich gut über das Netzwerk aktualisieren lassen. Desweiteren achte ich auf Erweiterbarkeit, denn es kommen später sicher Dinge auf mich zu, an die ich jetzt noch nicht denke.
Schade an diesem Arbeitsschritt ist, dass ich nichts zeigen kann :-)
Aber zum Vertrösten gibts ein Screenshot vom Zoombaren Screenshot. Vielleicht sieht man am Donnerstag die ersten Einheiten...

Die Ameisen kommen! Naja, zumindest in meinem Testprogramm zu genetischen Algorithmen (GA). Die Idee zum Fortbewegungsmuster der Ameisen habe ich aus 'Mathematische Unterhaltungen II'. Dieser Bewegungsablauf ist der, den ich für die Ressourcensammler ("malloc") in meinem Spiel verwenden werde.

Die Technik der GA lässt sich wohl für die Gebäudeplatzierung verwenden. Ich habe über die Technik noch genauer auf meiner KI-Seite geschrieben: ai.spunkmeyer.de/ga.php
Bis später

So, habe mir nun die ersten Abschnitte zu GA (Genetic Algorithms) durchgelesen und mache mir gerade Gedanken darüber, mit welchen Problemen ich die GAs testen will. Es soll ja etwas sein, das ich im Spiel verwenden kann...

Desweiteren habe ich versucht auf dieser Webseite etwas ausführlicher zu erläutern, was ich hier überhaupt mache, da es manchen Lesern noch nicht deutlich genug war.

Ich habe mich nun dafür entschieden, auf dem Server alles berechnen zu lassen. Die Clients sind sozusagen nur Terminals, welche die Spielewelt beobachten können und Befehle erteilen können. Auf jedem Client soll später einmal die KI und/oder der Spieler spielen können, oder einfach nur das Spiel angezeigt werden (Spectator).
Bis jetzt ist es möglich, dass die Spieler sich mit dem Server verbinden und einen Namen übermitteln. Wenn der Name noch nicht vergeben ist, wird er registriert und der Client wird aufgefordert, seine Farbe zu wählen.
Was noch zu machen ist: Falls der Client eine KI benutzen möchte, muss diese Ebenfalls beim Server registriert werden. Ich denke, das dann der Server einfach einen Namen und eine Farbe zuordnet. Die KI der Einheiten ist am Anfang immer im gleichen Stadium und lernt während des Spiels. Daher müssen keine KI-Parameter zum Server gesendet werden. Die KI, welche selber spielt, sendet genauso wie der Spieler Befehle zum Server, sie braucht also auch nicht übertragen werden.
Der Server bestimmt, wann es losgeht. Alle Clients, die sich bis dahin mit dem Server verbunden haben und die Namen und Farben übermittelt haben, werden in das Spiel einbezogen. Der Server teilt dann den Initial-Status des Spielfelds mit. Das ist auch der nächste Schritt, den ich Programmiere.
Eine weitere nächste Aufgabe ist das Einheitenverhalten. Dazu werde ich meinen Bot-Schwarm (siehe letzten Post) nehmen und ihn in ein Raster integrieren und eine Wegfindung und Hindernisse einbauen.
Ein weiterer nächster Schritt ist die Einarbeitung in das Thema "Evolutionäre Algorithmen".

Ich habe heute eine kleine Schwarmintelligenz programmiert. Naja, von Intelligenz kann man noch nicht so richtig sprechen, aber immerhin finden sich die autonomen Einheiten zu Grüppchen zusammen und laufen sich dabei nicht über den Haufen. Zu sehen bekommt man das auf meiner AI Seite, da es ja nicht Teil des Spiels wird. Obwohl ich natürlich die Technik bei der Einheitenbewegung wohl einsetzen werde. Hier der Link zu dem Mini-Projekt: ai.spunkmeyer.de

Mittlerweile kann ich mich mittels Loopback verbinden. Jetzt muss nur noch eine Datenstruktur her, mit der ich alle Clients auf dem Server gut speichern und synchronisieren kann. Da muss ich mir noch ein geeignetes Modell ausdenken. Ein paar Fehler sind auch noch da: Wenn ich zu einem Rechner verbinden möchte, den es nicht gibt, stürzt das Programm nach erhalt eines Timeout ab. Der Rückgabewert ist 3. Leider weiß ich nicht, warum das Programm dann beendet, normalerweise müsste es weiterlaufen.

So, die erste Verbindung hat funktioniert. Ist zwar noch etwas unbequem, da man bei dem Client die Netzwerkadresse und den Port per Hand eingeben muss, aber immerhin. Der Wrapper ist soweit fertig. Ich kann nun eine Verbindung herstellen. Allerdings mit dem Loopback-Adapter klappt es noch nicht so ganz. Wenn der dann funktioniert, kann ich mit der Spiele-Logik beginnen. Den ersten Screenshot mit der Verbindung habe ich gepostet.

Ich habe den Netzwerkcode fast fertig. Er stellt eine Verbindung her. Es gibt noch keine Lobby, das kommt später einmal. Man muss eine IP-Adresse eingeben, zu der verbunden werden soll. Ich muss mich um die Architektur der Software kümmern, denn es soll ja möglich sein, auch auf dem Server zu spielen, sonst bräuchte man einen Extra-Rechner. Oder eine weitere Anwendung. Mal sehen, wie ich das am besten umsetze. Ich werde desweiteren auch eine genaue Zeitmessung einbauen, welche den Delay zwischen den Rechnern immer misst und damit auch umgehen kann. Denn es soll ja so synchron wie möglich laufen. Ich hoffe das wird nicht zu schwierig. Priorität hat erstmal, das man sich lokal verbinden kann, denn dann kann ich mich schonmal an die Spiellogik machen. Primärziel ist ja die KI, daher will ich micht nicht aufhalten lassen! ^^

Ich habe ja schon einmal ein Computerspiel programmiert (Siehe Homepage). Auch ein zweites ist in Arbeit, aber noch nicht perfekt. Dies ist nun das dritte größere Projekt. Da dieses Spiel allerdings die Demo zu meiner Abschlussarbeit darstellt, hat es Priorität. Ich hoffe, dadurch auch Erfahrungen zu sammeln für meinen späteren Beruf.
Hier möchte ich nun eine Art Tagebuch eines Entwicklers anlegen und allen interessierten schreiben, wie es vorangeht. Auch für mich selbst ist es später sicher interessant, das hier nochmal zu lesen und festzustellen, wie schwer ich es mir gemacht habe. ^^
Was habe ich heute geschafft? Ich habe mich ein wenig in die OpenTNL-Library eingelesen. Ganz schön ungewohnt mit sovielen Makros umzugehen. Aber eine erste Server-Client-Verbindung hatte ich schon hinbekommen. Jetzt baue ich mir um diese Library eine Wrapper-Klasse die ich dann in meine vorhandene 2D-Spieleengine einbringe. Damit auch meine anderen Spiele leicht eine Netzwerkfunktion nachgerüstet bekommen können.
Das Projekt habe ich auch auf developia.de angemeldet und werde dort auch hin und wieder etwas schreiben.