13. Jun 2022
Lesedauer 22 Min.
Ameisen aus Code
Mit AntMe ins Programmieren einsteigen
Serious Games gestalten den Einstieg in das Programmierenlernen leichter und im wahrsten Sinne des Wortes spielerisch.
dotnetpro
Die ersten Schritte in die Welt der Programmierung sind leider oft mühsam. Viele Programmiersprachen, Entwicklungsumgebungen und allgemein viele Ansätze machen es Einsteigern nicht einfach, erste Erfolge mit einem eigenen Programm zu feiern. Schon das Einrichten der Umgebung, die zur Softwareentwicklung nötig ist, erfordert eine erhebliche Menge an Zeit und Aufwand.Gerade für den Bereich der „Programming Education“ bei Kindern und Jugendlichen geht deshalb ein Ansatz dahin, eigene Umgebungen zu nutzen. Dazu gehört alles, was zum Programmieren notwendig ist: eigene Entwicklungsumgebungen, Editoren, Programmiersprachen und auch eigene didaktische Ansätze. Denn Kinder lernen anders: über Beispiele, über Spaß beim Wissenserwerb und sehr stark über den Austausch mit anderen. Teams sind daher wichtig für den Lernerfolg von Kindern.Genau hier setzt AntMe an und erlaubt es, auf spielerische Art und Weise ein Programm zu entwickeln, ohne dass dabei eine eigene Programmierumgebung oder eine eigene Sprache zum Einsatz kommen.
Was ist AntMe?
AntMe ist ein Programmierlernspiel mit dem erklärten Ziel, Anfänger und Anfängerinnen nicht zu überfordern und sie mit schnellen und spaßigen Ergebnissen beim Lernen zu begleiten, sodass sich zügig Lernerfolge einstellen. Ein klassisches Serious Game also (siehe Kasten Was sind Serious Games?), weil der Spielspaß im Vordergrund steht, das Lernziel aber trotzdem berücksichtigt wird. Ein großer Pluspunkt ist, dass C# beziehungsweise VB.NET zum Einsatz kommen – Programmiersprachen, die auch in der Wirtschaft genutzt werden. Als Entwicklungsumgebung dient Visual Studio, für das es auch eine Projektvorlage gibt, bei der schon alle Vorkehrungen getroffen sind, um direkt mit dem Programmieren starten zu können.Was sind Serious Games?
Serious Games lassen sich vereinfacht als „ernsthafte Spiele“ beschreiben. Sie dienen nicht ausschließlich oder primär der Unterhaltung, sondern dem Lernen und gleichzeitig der Anwendung des Gelernten. Die Verknüpfung mit Elementen von klassischen Spielen sorgt dafür, dass es nicht wie Lernen erscheint, was insbesondere bei einer jüngeren Zielgruppe gut ankommt.
Ein Novum von AntMe ist die Art und Weise, wie der Ansatz des Programmierenlernens verpackt wird. Es geht nicht darum, eine einzelne Spielfigur programmierend zu steuern, sondern einen ganzen Schwarm. Ziel ist es nämlich, ein komplettes Ameisenvolk so zu programmieren, dass es in verschiedenen Disziplinen wie dem Sammeln von Ressourcen oder der Verteidigung gegen Angreifer bestehen kann. Aufgabe ist es also, eine Ameise – in Form einer C#-Klasse – so zu implementieren, dass ein darauf basierendes Ameisenvolk optimal zusammenarbeitet. Jede Ameise ist dabei eine Instanz der identischen Klasse. Dass die Implementierung variabel auf Geschehnisse der Umwelt reagieren können muss, macht AntMe so spannend, gerade weil es am Anfang so unmöglich erscheint, ein Ameisenvolk selbst so zu programmieren, dass es in verschiedenen Situationen richtig reagiert. Beim Kennenlernen von AntMe wird dann aber klar, dass es gar nicht so schwierig ist. Die notwendige Technik und Methodik in Form von Methoden und Anweisungen in C# zu beherrschen ist überschaubar. Die Beherrschung der semantischen Ebene ist dagegen deutlich schwieriger und erfordert eine große Portion Vorstellungsvermögen und Planung.
Anforderungen und Installation von AntMe
Der Download startet nach einem Klick auf den gleichnamigen Button unter [1]. Aktuell ist Version 1.7.3.369 verfügbar. Das MSI-Paket erleichtert die Installation, allerdings wurden beim Schreiben dieses Artikels nicht alle Abhängigkeiten mit aufgelöst. Eine mögliche Konsequenz ist, dass die Assembly Microsoft.Xna.Framework nicht gefunden wird. Das Wiki zu AntMe [2] hilft hier weiter und beschreibt, wo das XNA-Framework heruntergeladen werden kann [3]. Zusätzlich ist noch eine Entwicklungsumgebung nötig, etwa Visual Studio in der Community Edition [4].Die Integration mit Visual Studio ist sehr gut, sodass diese Umgebung allen Einsteigern empfohlen wird. Grundsätzlich funktionieren aber auch andere Editoren oder Entwicklungsumgebungen. Mit welcher IDE der C#-Code für das Ameisenvolk kompiliert wird, um es anschließend in AntMe zu öffnen und auszuführen, spielt eine untergeordnete Rolle.AntMe lässt sich durch Plug-ins um zusätzliche Funktionen erweitern. Bild 1 zeigt beispielhaft, welche Plug-ins schon bei der Installation mit an Bord sind und aktiviert werden können. Das „Freie Spiel“ sollte in jedem Fall aktiviert sein.
Die Einstellungender Plug-ins in AntMe(Bild 1)
Autor
Aufbau und Funktionsweise der Spielfläche
Das Spielfeld, siehe Bild 2, ist das zentrale Element von AntMe. Dort befinden sich alle Ameisenvölker mit den Ameisen (schwarz) und den Ameisenhügeln (bräunlich mit Fahne). Auf diesem Spielfeld werden auch die Zuckerberge (weiß), die Äpfel (grün) und die Wanzen (schwarz) platziert. Die Wanzen und Ameisen bewegen sich auf dem Spielfeld. Letztere nur, wenn das auch korrekt von uns implementiert wurde. Die Wanzen werden automatisch von AntMe gesteuert. Zusätzlich gibt es noch die Markierungen, mit denen sich Ameisen untereinander Nachrichten schicken können. Dazu aber später mehr. Zudem ist Nahrung auf dem Spielfeld vorhanden, die von Ameisen eingesammelt werden kann. Für viele Aktionen vergibt das Spiel Punkte, zum Beispiel, um das eigene Ameisenvolk einschätzen zu können, aber auch, um sich mit anderen Völkern zu messen.
Die Spielflächevon AntMe ohne Ameisen oder Ameisen-Aktionen(Bild 2)
Autor
Zucker und Äpfel als Nahrung
Ameisen selbst benötigen zwar keine Nahrung, um zu überleben oder sich zu vermehren. Da Zuckerhügel und Äpfel, die beiden Nahrungsarten im Spiel, aber viele Punkte versprechen, ist es eine gute Idee, diese einzusammeln, wenn ein offener Wettkampf zwischen verschiedenen Ameisenvölkern ansteht. Zuckerhügel enthalten 1000 Einheiten Nahrung und können schnell von einzelnen Ameisen eingesammelt werden, ohne dass ein hohes Risiko besteht, zum Beispiel Wanzen oder gegnerischen Ameisen zu begegnen.Anders bei den Äpfeln: Sie enthalten 250 Einheiten Nahrung und benötigen mehrere Ameisen. Da zudem die Transportgeschwindigkeit geringer ist, besteht ein hohes Risiko, dass ihnen gegnerische Ameisen oder Wanzen in die Quere kommen und das Vorhaben der Nahrungssuche empfindlich stören. Andererseits ist die gesammelte Nahrung auf einen Schlag größer, und bei Zucker sind viele Transportvorgänge zwischen dem Ameisenbau und dem Zuckerhügel notwendig. Bei diesen zahlreichen Transportvorgängen kann insgesamt wiederum viel passieren.An diesen einfachen Überlegungen nur für die Nahrungssuche wird bereits deutlich, wie viele Entscheidungen in das Design und die Implementierung des eigenen Ameisenvolks einfließen müssen. Das macht jede Runde spannend, ermöglicht Adaptionen durch Lernende und viele Ansätze für Wettkämpfe zwischen Ameisenvölkern.Wanzen als Gegner
Die Wanzen als die Gegner von Ameisen sind vom Spiel gesteuert und krabbeln in mehr oder weniger zufälligen Mustern über das Spielfeld. Treffen sie dabei auf eine Ameise, wird diese gefressen. Dabei verliert die Wanze, gemäß der Angriffskraft der Ameise, Leben. Da eine Wanze insgesamt aber 1000 Leben (Energie) hat, sind die Chancen einer einzelnen Ameise sehr überschaubar, diesen Kampf zu gewinnen. Daher ist es essenziell, wie beim Sammeln von Äpfeln eine gewisse Anzahl Ameisen auf einmal zu mobilisieren, wenn eine Wanze besiegt werden soll. Das ist vom Spielprinzip her zwar nicht erforderlich, denn Wanzen können auch ignoriert werden, allerdings kann es sinnvoll sein, Wanzen zu bekämpfen, damit diese keine Zuckerstraßen zerstören oder ganze Gruppen von Ameisen beim Sammeln von Äpfeln fressen. Wieder liegt die Entscheidung beim Lernenden, wenn das Ameisenvolk implementiert wird.Freundliche und feindliche Ameisen
Andere Ameisen werden in AntMe in freundliche und feindliche Ameisen unterschieden. Neben den Ameisen des eigenen Volkes können Ameisen anderer Völker freundlich sein, wenn sie zum eigenen Team gehören (dazu später mehr). Mit freundlichen Ameisen lässt sich über Nachrichten interagieren, um situationsbezogen Gruppen von Ameisen auch über das eigene Volk hinaus zu erstellen und Aufgaben wie das Sammeln von Nahrung oder den Kampf gegen Wanzen als größeres Team gemeinsam zu bewerkstelligen.Bei feindlichen Ameisen stellt sich wie bei den Wanzen die Frage, ob Flucht oder Kampf der bessere Weg ist. Der Kampf zwischen zwei Ameisen verläuft deutlich ausgeglichener als bei Wanzen, auch wenn es bei Ameisen Unterschiede durch die Klassen-Modifizierer gibt, die im Folgenden noch vorgestellt werden.Aufbau und Funktionen von Ameisen
Bei der deutschen Version sind auch die Befehle, die eine Ameise in der Programmierung ausführen kann, in Deutsch gehalten. Das Wiki [2] erklärt alle Befehle sehr gut. Vereinfacht gesagt haben Ameisen die Möglichkeit, sich zu bewegen (gehen), sich zu drehen, mit Nahrung zu interagieren, Markierungen zu versprühen und in einen Kampf verwickelt zu werden – Letzteres gegen Wanzen oder im Team-Spiel gegen andere Ameisen von fremden Völkern.Zusätzlich lassen sich Ameisen in Kasten unterteilen, um ihnen gemäß dieser Kasten verschiedene Eigenschaften zuzuweisen, beispielsweise die maximale Energie, maximale Last, Reichweite, Angriff und weitere. Diese können jeweils angepasst werden, um beispielsweise schnelle oder stärkere Ameisen zu konfigurieren.Das erste Ameisenvolk erschaffen
Am einfachsten lässt sich ein eigenes Ameisenvolk über das AntMe!-Template erzeugen. Dazu klickt man einfach in der AntMe-Oberfläche auf Freies Spiel und wählt einen freien Slot mit der linken Maustaste aus, um in die Auswahl der Spieler zu gelangen (Bild 3). Dort können vorhandene Ameisenvölker ausgewählt oder bereits auf dem Datenträger vorhandene geladen werden.
Die Auswahlvon Ameisenvölkern(Bild 3)
Autor
Über das schwarze Pluszeichen oben im Fenster wird ein neues Ameisenvolk erstellt (siehe Bild 4). In den Einstellungen, die in Bild 4 zu sehen sind, wählt man einen Namen für das Volk, die Sprache, Programmiersprache und das Verzeichnis aus und klickt auf OK. Eine nachfolgende Abfrage möchte wissen, ob die Vorlage direkt mit Visual Studio geöffnet werden soll oder nicht. Wer mit Visual Studio arbeitet, was zu empfehlen ist, kann das Template daher direkt öffnen.
Die Optionenzum Erstellen eines neuen Ameisenvolkes(Bild 4)
Autor
Zuerst ist es sinnvoll, die Spielerinformationen am Anfang der eigenen Ameisen-Klassen mit Leben zu füllen. Diese Informationen tauchen immer dann auf, wenn ein Ameisenvolk geladen und angezeigt wird. Gerade bei späteren Team-Events lassen sich die Ameisenvölker auf diese Weise besser voneinander unterscheiden.Der folgende Code zeigt das Spieler-Attribut über der Klasse und wie es gefüllt sein kann:
[Spieler(
Volkname = "dotnetproAmeisen",
Vorname = "Fabian",
Nachname = "Deitelhoff"
)]
Jetzt können wir uns direkt um die Implementierung dieses frischen Ameisenvolkes kümmern. Das Bild 5 zeigt, wie die Methoden einer Ameisen-Klasse aufgeteilt sind. Zuerst kümmern wir uns um die Fortbewegung.
Die Aufteilungder verschiedenen Methoden der Ameisen-Klassen auf Kategorien, gruppiert über Regionen(Bild 5)
Autor
Die Methode Wartet wird aufgerufen, wenn die Ameise nichts zu tun hat. Wird dort die Methode GeheGeradeaus aufgerufen und AntMe gestartet, geht es auch direkt los: Die Ameisen starten in einer zufälligen Richtung vom Ameisenhügel aus und laufen los. Bald wuseln recht viele Ameisen und Wanzen auf dem Spielfeld hin und her.
public override void Wartet()
{
GeheGeradeaus();
}
Wird die AntMe!-Vorlage genutzt und direkt über AntMe geöffnet, reicht es im Übrigen aus, das Visual-Studio-Projekt mit [F5] zu starten. Nach dem Build-Vorgang startet AntMe automatisch und hat auch gleich das korrekte Ameisenvolk in einem freien Spiel geladen. Dann muss nur noch die Simulation über den Play-Button oben links gestartet werden.Nun sollen die Ameisen auch Zucker sammeln. Sieht eine Ameisen einen Zuckerhügel, wird die Methode Sieht(Zucker zucker) aufgerufen. Auch Anfänger und Anfängerinnen kommen schnell auf die Idee, die Methode mit dem Aufruf GeheZuZiel(zucker) zu füllen, wenn ungefähr bekannt ist, welche Methoden zur Verfügung stehen. Diese Methode befindet sich in der Kategorie Nahrung.
public override void Sieht(Zucker zucker)
{
GeheZuZiel(zucker);
}
Der Erfolg zeigt sich sofort: Sehen die über das Spielfeld wuselnden Ameisen einen Zuckerhügel, begeben sie sich direkt darauf zu. Anschließend passiert bisher allerdings nichts mehr. Die Ameisen bleiben direkt beim Zucker stehen.Die Methode ZielErreicht(Zucker zucker) hilft hier weiter. Ist die Ameise am Zuckerhügel angekommen, wird die Methode aufgerufen, um weitere Aktionen auszulösen:
public override void ZielErreicht(Zucker zucker)
{
Nimm(zucker);
GeheZuBau();
}
Auch das funktioniert. Zumindest zu 50 Prozent. Die Ameisen steuern die Zuckerhügel zwar an und sammeln auch eindeutig Zuckerstückchen, wie Bild 6 zeigt, allerdings passiert danach nichts mehr. Die Ameisen bleiben stur am Zuckerhügel stehen. Das schnelle Erfolgserlebnis wird von einem weiteren Lernerfolg begleitet. Denn die Ameisen arbeiten nach dem Prinzip einer Zustandsmaschine.
Die Ameisengehen zum Zuckerhügel, nehmen Zucker auf und warten dort(Bild 6)
Autor
Wenn der Aufruf GeheZuBau der Methode ZielErreicht aufgerufen wird, möchten die Ameisen dieser Anweisung auch gerne Folge leisten. Allerdings wird, sobald sie sich von den Zuckerhügeln entfernen würden, sofort wieder die Methode Sieht(Zucker zucker) aktiv, was sie dazu veranlasst, zum Zuckerhügel zurückzugehen. Also muss die Methode Sieht noch mit einer Abfrage versehen werden, um dieses Problem zu lösen.Da eine Ameise ein einmal angesteuertes Ziel speichert, lässt sich dieses in einer einfachen Abfrage prüfen:
public override void Sieht(Zucker zucker)
{
if (Ziel == null)
{
GeheZuZiel(zucker);
}
}
Jetzt läuft eine Ameise nur zu einem Zuckerhügel, wenn noch kein Ziel angesteuert wird. Für diesen einfachen Anwendungsfall reicht das auch absolut aus, wie Bild 7 zeigt. Die Ameisen laufen schwer bepackt vom Zuckerhügel Richtung Ameisenhügel.
Ameisen tragen Zuckererfolgreich vom Zuckerhügel weg(Bild 7)
Autor
Damit ist bereits ein Ameisenvolk erstellt, das eine grundlegende Aufgabe übernimmt, nämlich Zucker zu sammeln, um den Punktestand zu erhöhen. Auf diesen Grundlagen lässt sich mit weiteren Aufgaben aufbauen, und zusätzlich lassen sich Funktionen von AntMe erklären.Zum Beispiel wird schnell auffallen, dass es einige Ameisen nicht zurück zum Ameisenbau schaffen. Das liegt nicht immer an Wanzen oder feindlichen Ameisen, sondern daran, dass den eigenen Ameisen die Puste ausgeht. Jede Ameise hat einen gewissen Vorrat an Energie. Ist diese aufgebraucht, stirbt die Ameise, völlig egal, was sie gerade als Aufgabe hat. Sie verschwindet einfach vom Spielfeld. Dazu gibt es die Methode WirdMüde. Die wird dann aufgerufen, wenn die Ameise 1/3 ihrer Energie verbraucht hat. Leider wird die Methode nur genau dann einmal aufgerufen, wenn ebendiese 33 Prozent der Gesamtenergie verbraucht sind. Das ist etwas verschwenderisch, denn die Ameise könnte durchaus noch etwas durchhalten. Das folgende C#-Snippet zeigt eine etwas intelligentere Lösung:
public override void Tick()
{
if (Ziel == null)
{
if (Reichweite / (ZurückgelegteStrecke + 1) < 2)
{
GeheZuBau();
}
}
}
Diese Lösung nutzt die Daten der Eigenschaften Reichweite und ZurückgelegteStrecke. Erstere gibt an, wie weit die Ameise kommt, bevor sie keine Energie mehr hat. Die zweite Eigenschaft gibt die Gesamtanzahl der Schritte zurück, die die Ameise seit dem letzten Besuch beim Ameisenbau absolviert hat.Diese etwas intelligentere Lösung nutzt zudem die Tick-Methode aus der Kategorie Fortbewegung. Diese wird pro Simulationsrunde ohne weitere Bedingungen aufgerufen und noch in späteren Beispielen genutzt. Dadurch wird die Ameise zurück zum Ameisenbau geschickt, wenn sie ungefähr die Hälfte ihrer Reichweite gelaufen ist. Durch das +1 wird eine Division durch 0 vermieden, denn die Eigenschaft ZurückgelegteStrecke wird durch den Besuch beim Ameisenhügel zurückgesetzt.Bereits dieses einfache Beispiel zeigt, wie viele Gedanken sich Lernende machen können, um eine solche Lösung zu implementieren. Das bedeutet zahlreiche didaktische Möglichkeiten beim Einsatz in der Lehre. Wie die Ameisensimulation grob abläuft und welche Schritte dabei durchlaufen werden, beschreibt der Kasten Die Ameisensimulation im Fokus.
Die Ameisensimulation im Fokus
Jede Simulationsrunde folgt einer festgelegten Reihenfolge, wie die Dinge in der Simulation abgearbeitet werden. Generell werden die Kategorien von Objekten einzeln betrachtet und nacheinander abgearbeitet. Zum Beispiel startet alles mit der Verarbeitung der Nahrungsmittel. Leere Zuckerhügel müssen weggeräumt und neue Zuckerhügel erstellt werden, wenn die Mindestanzahl gemäß Einstellungen unterschritten wird. Danach folgt die Bewegung der Wanzen und Ameisen, der Lebenszyklus der Wanzen und zum Abschluss die Bewegungen für Obst und Ameisencluster.
Informationsaustausch zwischen Ameisen
Ähnlich wie bei echten Ameisen, die über Pheromone Informationen austauschen, lassen sich in AntMe über Markierungen Informationen verteilen, die dann von anderen Ameisen aufgenommen und verarbeitet werden können. Die Markierungen breiten sich um die Ameise herum in einer bestimmten Geschwindigkeit aus und verschwinden dann wieder. Je kleiner die Markierung ist, desto länger hält sie an, erreicht dann aber nur eine kleinere Umgebung um den Sprüh-Mittelpunkt. Größere Markierungen reichen weiter und können somit von mehr Ameisen erfasst werden. Da sie aber auch stärker flüchtig sind, kann es sein, dass die Markierung kaum bis gar keinen Effekt hat. Es gilt daher abzuwägen, was mit einer Markierung erreicht werden soll.Zusätzlich ist es nicht immer die beste Idee, so viele Ameisen wie möglich mit einer Markierung zu erreichen. Riecht eine Ameise eine freundliche Markierung, sind viele Entscheidungen zu treffen: Was macht die Ameise gerade? Hat sie bereits ein Ziel? Kämpft sie oder trägt sie Nahrung? All das muss berücksichtigt werden, damit eine Ameise sinnvolle Aufgaben erledigt. Über die folgende Anweisung versprüht eine Ameise eine Markierung:SprüheMarkierung(int information, int größe);
Im ersten Parameter lässt sich eine Information codieren, sodass die empfangene Ameise besser auf die Markierung reagieren kann. Der zweite Parameter bestimmt die Größe der Markierung. Erforderlich ist nur die Größe, wenn gar keine Information mitgegeben werden soll. Wie eine solche Markierung aussieht, zeigt Bild 8.
Eine Markierungauf der Spielfläche, erstellt durch eine Ameise(Bild 8)
Autor
Die Information ist in der Regel sehr wichtig, denn darüber lassen sich beim Empfänger Entscheidungen induzieren. Eine Markierung mit der Information 1 kann Zucker bedeuten, mit 2 einen Apfel in der Nähe und die 3 zum Beispiel eine Wanze. Das sind deutlich andere Ziele, die ein anderes Verhalten bei der Empfänger-Ameise auslösen sollten.Markierungen lassen sich nur von freundlichen Ameisen auswerten. Daher gibt es auch nur eine Methode, um Markierungen zu wittern, nämlich die folgende:
RiechtFreund(Markierung markierung);
Im übergebenen Objekt Markierung ist die Information codiert und lässt sich sehr einfach auswerten:
public override void RiechtFreund(Markierung markierung)
{
if (markierung.Information == 3)
{
// ...
}
}
Der Mechanismus der Markierungen ist ein zentraler Ankerpunkt für das Implementieren verschiedener Ameisenvölker. Wer die Kommunikation zwischen seinen Ameisen ordentlich nutzt, hat definitiv einen Vorteil gegenüber anderen Ameisenvölkern, was sich in Team-Spielen und Wettbewerben stark in der erreichten Punktezahl bemerkbar machen kann.
Zuckerameisen inklusive Transportstraße
Die Markierungen sollen nun direkt zum Einsatz kommen: für eine Transportstraße für ein Volk namens Zuckerameisen. Das Volk heißt so, weil die Ameisen sich ausschließlich auf den Zucker konzentrieren. Zugleich berichten sie über Markierungen anderen Ameisen des Volks vom wohlschmeckenden Zuckerhügel. So soll eine Transportstraße entstehen, um den Zucker mit maximaler Geschwindigkeit einzusammeln.Wenn eine Ameise wartet, wird geprüft, ob sie von der Existenz eines Zuckerhügels weiß. Dazu ist eine Eigenschaft vom Typ Zucker erforderlich, um dort die Referenz auf den Zuckerhügel zu speichern, den die Ameise kennt. Ist das der Fall, geht sie zu diesem Ziel. Ansonsten wandert die Ameise geradeaus, um entweder selbst einen Zuckerhügel zu entdecken oder über eine Markierung davon zu erfahren:public override void Wartet()
{
if (zucker != null)
{
GeheZuZiel(zucker);
}
GeheGeradeaus();
}
Für den Fall, dass die Ameise Zucker sieht, wird die Existenz dieses Zuckerhügels in einer Eigenschaft der eigenen Klasse gespeichert. Diese Referenz auf den Zuckerhügel wurde in der Wartet-Methode bereits genutzt, um sich schnell wieder zum Zuckerhügel zu bewegen, wenn dieser bereits bekannt ist und die Ameise wartet. Denn die Ameise wartet auch, wenn etwas Zucker von diesem Hügel beim Bau abgeliefert wurde. Dann geht die Ameise wieder in den Wartezustand und kann sich direkt erneut zum Zuckerhügel bewegen:
public override void Sieht(Zucker zucker)
{
this.zucker = zucker;
var richtung = Koordinate.BestimmeRichtung(
this, zucker);
SprüheMarkierung(3, richtung);
if (AktuelleLast == 0 && this.zucker != null)
{
GeheZuZiel(zucker);
}
}
Abgefragt wird zudem, ob die Ameise überhaupt noch Last tragen kann, also noch nicht beschäftigt ist. Überprüft wird auch, ob die Zucker-Referenz null ist.Diese Implementierung führt unter anderem auch dazu, dass sich eine Ameise auf einen zuvor erkannten Zuckerhügel zubewegt und dieser mitten auf dem Weg verschwindet, weil die anderen Ameisen den gesamten Zucker aufgesammelt haben. Das könnte durch eine weitere Markierung mit einer anderen Information korrigiert werden, wird aber in diesem Beispiel nicht berücksichtigt. Der wichtige Part in dieser Methode ist die Richtungsbestimmung zum Zuckerhügel und die Markierung mit dieser Information. Diese Daten werden dann von anderen Ameisen aufgenommen und genutzt, um sich in Richtung Zuckerhügel zu drehen.Wenn der Zuckerhügel erreicht ist, wird wie üblich der Zucker aufgesammelt und der Heimweg zurück zum Bau angetreten:
public override void ZielErreicht(Zucker zucker)
{
Nimm(zucker);
GeheZuBau();
}
Wenn eine befreundete Ameise die Markierung eines anderen Freundes aufnimmt, lässt sich die Information nutzen, um sich in die Richtung des Zuckerhügels zu drehen. Wir erinnern uns: Die Richtung wurde in der Markierung codiert. Die RiechtFreund-Methode kümmert sich genau darum:
public override void RiechtFreund(Markierung markierung)
{
if (Ziel == null)
{
DreheInRichtung(markierung.Information);
GeheGeradeaus();
}
}
Für eine Ameisenstraße zwischen dem Ameisenbau und dem Zuckerhügel fehlt aber noch eine wichtige Zutat. Bisher wird die Markierung nur dann gesprüht, wenn der Zuckerhügel im Sichtfeld einer Ameise erscheint. Dadurch wird der Zuckerhügel rundherum mit Markierungen eingesprüht, aber das ist noch nicht das, was gewünscht ist. Die Lösung liegt in der Tick-Methode. Wie bereits beschrieben, wird diese in jeder Simulationsrunde aufgerufen, ohne zusätzliche Bedingungen zu berücksichtigen. Dort lassen sich also gut Aktionen unterbringen, die Bedingungen abdecken, die von anderen Methoden nicht behandelt werden. Der Code für die Tick-Methode dieses Beispiels sieht wie folgt aus:
public override void Tick()
{
if (zucker != null)
{
var richtung = Koordinate.BestimmeRichtung(
this, zucker);
SprüheMarkierung(richtung);
}
}
Mit dieser Implementierung entstehen über die Zeit eindeutige Zuckerstraßen, die Ameisen nutzen, um vom Ameisenbau zum Zuckerhügel zu kommen. Der Rückweg ist kein Problem, denn das übernimmt die GeheZuBau-Methode. Ist der Zucker abgeliefert, wird die Referenz auf den Zuckerhügel genutzt, um wieder zum Zuckerhügel zurückzufinden. Die Markierungen werden in diesem Beispiel also dafür verwendet, um andere Ameisen auf den Zucker aufmerksam zu machen. Das Bild 9 zeigt einen Screenshot, um zu zeigen, wie die Ameisenstraße aussieht.
Eine funktionierende Zuckerstraßezwischen Ameisenbau und Zuckerhügel(Bild 9)
Autor
Kampfameisen
Das zuvor beschriebene Ameisenvolk kümmert sich mittels Markierungen um das Sammeln von Zucker. Das funktioniert auch bei Obst sowie bei gegnerischen Ameisen beziehungsweise Wanzen. Letzteres wird kurz skizziert, denn das Vorgehen ist recht ähnlich. Eine Umsetzungsart nutzt erneut Markierungen, um andere Ameisen davon in Kenntnis zu setzen, dass sich ein Gegner in der Nähe befindet.Im Warte-Modus, in der Wartet-Methode, läuft die Ameise in diesem Volk stur geradeaus. In der Methode RiechtFreund, wenn eine befreundete Markierung erkannt wird, lässt sich die Information der Markierung nutzen, um mit GeheZuZiel dorthin zu gehen. Das ist tatsächlich so einfach, wie es klingt:public override void RiechtFreund(Markierung markierung)
{
GeheZuZiel(markierung);
}
Jetzt fehlt nur noch die Implementierung der Aktion, die ausgeführt wird, wenn ein Feind in Sichtweite ist. Das übernimmt zum Beispiel die Methode SiehtFeind(Wanze wanze) oder – alternativ – für feindliche Ameisen. Den darin enthaltenen Code zeigt das folgende Snippet:
public override void SiehtFeind(Wanze wanze)
{
SprüheMarkierung(1, 150);
GreifeAn(wanze);
}
Die Markierung hat eine Information, um den entsprechenden Fall in der RiechtFreund-Methode zu prüfen. Die Größe ist hier frei wählbar und hat die üblichen Auswirkungen von großen beziehungsweise kleinen Markierungen.Diese Implementierung reicht bereits aus, um Ameisen in der Umgebung darüber zu informieren, ob Feinde in der Nähe sind oder nicht. Diese werden dann gemeinsam angegriffen. Eine weitere Logik dahinter gibt es aber nicht. Es wird weder darauf geachtet, ob eine Ameise noch kämpfen sollte oder nicht, noch darauf, ob zum Beispiel genügend Ameisen in der Nähe sind, um eine Wanze zu besiegen. Das kann im Zweifelsfall sehr viele eigene Ameisen den digitalen Tod kosten, da Wanzen sehr stark sind und nur gemeinsam angegriffen werden sollten.Darüber hinaus gibt es das Problem, dass die Ameisen, die kämpfen, nicht mehr für andere Aufgaben zur Verfügung stehen. Wenn eine Ameise bei Kontakt mit der oben beschriebenen Markierung sofort anfängt zu kämpfen, dann machen das sehr schnell sehr viele Ameisen. Das wirkt sich generell negativ auf das eigene Ameisenvolk aus.
Modifikatoren für mehr Fähigkeiten
Um die Möglichkeiten und Diversität von Ameisen weiter zu fördern, besitzt jede Ameise eine vordefinierte Anzahl an Modifikatoren, mit denen grundlegende Eigenschaften steuerbar sind: Geschwindigkeit, Drehgeschwindigkeit, Last, Sichtweite, Energie und Angriff.Jeder Modifikator kann die Werte -1, 0, 1 oder 2 annehmen, um eine Einstellung zu verändern und einer Ameise verschiedene Fähigkeiten zu geben. Im Standard sind diese Modifikatoren alle auf 0, sodass alle Ameisen identisch sind. Die Summe aller Eigenschaften muss immer 0 sein. Kleiner als 0 ist zwar möglich, aber das bedeutet einen Punkteverlust und damit den Verlust von Fähigkeiten, ohne dass im Gegenzug etwas verbessert wird. Also keine gute Idee. Da die Summe von 0 angestrebt wird, sind daher wichtige Entscheidungen zu treffen. Soll die Ameise stärker sein, dafür vielleicht langsamer? Soll sie mehr tragen können, dafür eine geringere Reichweite (Schritte) haben? Das alles ist mit dem Modifikatoren für die Fähigkeiten möglich. Tabelle 1 zeigt die Fähigkeiten und was sich bei den einzelnen Werten ändert.Tabelle 1: Die Modifikatoren und deren Auswirkungen auf eine Ameise
|
Das Kastensystem für noch mehr Möglichkeiten
Unter Kasten werden bei AntMe die verschiedenen Berufsgruppen der Ameisen verstanden. Alle Ameisen besitzen die im vorherigen Abschnitt beschriebenen Fähigkeiten, wie Lebenspunkte oder die Stärke des Angriffs. Diese Eigenschaften lassen sich in Form einer Kaste verändern, um so eine Gruppe von Fähigkeitseinstellungen zu erstellen. Die Kasten bei AntMe sind im C#-Code folgendermaßen aufgebaut:[Kaste(
Name = "Standard",
// Name der Berufsgruppe
AngriffModifikator = 0,
// Angriffsstärke einer Ameise
DrehgeschwindigkeitModifikator = 0,
// Drehgeschwindigkeit einer Ameise
EnergieModifikator = 0,
// Lebensenergie einer Ameise
GeschwindigkeitModifikator = 0,
// Laufgeschwindigkeit einer Ameise
LastModifikator = 0,
// Tragkraft einer Ameise
ReichweiteModifikator = 0,
// Ausdauer einer Ameise
SichtweiteModifikator = 0
// Sichtweite einer Ameise
)]
Diese oben gezeigte Kaste hat den Namen Standard. Um mehrere Kasten zu erstellen, wird der gesamte Code kopiert. Der Name der Kaste ist dann allerdings zu verändern. Einen Ausschnitt zeigt der folgende Code:
[Kaste(
Name = "Standard", // Name der Berufsgruppe
...
)]
[Kaste(
Name = "AndereKaste", // Name der Berufsgruppe
...
)]
Durch diese Unterscheidung gibt es bereits zwei verschiedene Kasten, also zwei verschiedene Berufsgruppen. Aber diese Berufsgruppen werden durch die Simulation von AntMe noch nicht erzeugt. Das Erzeugen ist ebenfalls selbst zu implementieren, wie der nachfolgende Code ausschnittsweise zeigt:
if (anzahl["Standard"] < 30)
{
return "Standard";
}
else
{
return "AndereKaste";
}
Diese Abfrage prüft, ob es aktuell weniger als 30 Ameisen von der Kaste, also der Berufsgruppe mit Namen Standard gibt. Wenn ja, wird eine Standard-Kaste durch Rückgabe des Namens Standard erstellt. Wenn es bereits 30 Ameisen von der Berufsgruppe Standard gibt, werden die restlichen Ameisen von der Kaste AndereKaste erzeugt. Dieser Code befindet sich in der Methode BestimmeKaste:
public override string BestimmeKaste(
Dictionary<string, int> anzahl)
{
// ...
}
Auf diese Weise lässt sich steuern, wie viele Ameisen von welcher Kaste gerade aktiv sind. Zum Beispiel, um ein paar Kampfameisen zu erstellen, einige Späher-Ameisen und die restlichen als Sammlerameisen.Angesichts all dieser Fähigkeiten über Modifikatoren und Kasten ist es immer zweckmäßig, vorher genau zu überlegen, was damit erreicht werden soll. Die Komplexität von AntMe ist auch ohne das Kastensystem bereits recht hoch, weil zum Beispiel die Dynamik des Spielfelds dabei noch gar nicht berücksichtigt ist. Je mehr Kasten es gibt, die alle unterschiedliche Fähigkeiten haben, desto höher ist deshalb auch die Wahrscheinlichkeit, dass alles nicht so funktioniert wie beabsichtigt.
Team-Wettbewerbe als Motivation
AntMe lässt sich problemlos allein spielen. Richtig interessant wird es aber erst, wenn Team-Wettbewerbe stattfinden – entweder in der Form alle gegen alle oder tatsächlich auf Teams aufgeteilt (vergleiche Bild 10). Einstellmöglichkeiten wie zum Beispiel die Dauer eine Runde, eingestellt über Simulations-Ticks, gibt es on top.
Die Team-Einstellungenfür ein „Freies Spiel“(Bild 10)
Autor
Wenn sich Ameisen-Entwickler und -Entwicklerinnen koordinieren müssen, weil die jeweiligen Ameisenvölker nicht unbedingt das Gleiche machen oder identische Ziele verfolgen sollen, dann wird es nicht nur bei Kindern und Jugendlichen spannend, sondern auch bei Erwachsenen. Die möglichen Ansätze sind dabei grundverschieden.Ameisenvölker lassen sich von der Implementierung her in drei völlig unterschiedliche Kategorien unterteilen: Bei Völkern ohne Nutzung statischer Informationen wird der Klasse für eine Ameise keine statische Klassen-Eigenschaft mitgegeben. Das ist in AntMe nicht prinzipiell verboten und ermöglicht es, ein Ameisenvolk zu erstellen, das sich über die statischen Eigenschaften globale Informationen zukommen lässt.Eine sehr fortgeschrittene Nutzung davon ist eine Art Ticket-System für Ameisen: Eine statische Eigenschaft wird mit einer eigenen Ticket-Manager-Klasse ausgestattet, um darüber die Ameisen zu koordinieren. So lässt sich beispielsweise prüfen, welche Ameisen gerade sammeln, welche angegriffen werden, wo Nahrung entdeckt wird und so weiter. Das bedeutet einen deutlichen Vorteil gegenüber Ameisenvölkern, die sich nur über Markierungen verständigen. In Wettbewerben wird diese Unterteilung in Völker mit und ohne statische Informationen gerne vorgenommen, um die Chancen für alle fair zu halten.Die dritte Kategorie bilden Ameisenvölker, die Machine Learning oder ähnliche Ansätze nutzen, um Ameisenvölker „lernend“ zu gestalten. Laut Tom Wendel, einem der Entwickler von AntMe, sind diese Ansätze aber bisher grandios gescheitert (siehe Interview). Sie waren demnach nicht besser als konventionelle Ansätze.
Fazit
AntMe ist ein sehr gutes Beispiel dafür, Kindern und Jugendlichen die Welt der Programmierung und Softwareentwicklung mit Spaß und Neugierde beim Lernen näherzubringen.Die didaktischen Möglichkeiten von AntMe sind vielfältig. Insbesondere im technischen Bereich lassen sich nahezu unbegrenzt viele Szenarien finden, die sich mit den Ameisen abbilden lassen. Ganz besonders, wenn es in Richtung Optimierung geht. Die Ameisen noch intelligenter, noch vorausschauender und noch effizienter bei der Nahrungsbeschaffung zu machen sind die beliebtesten Themen, wenn die Teilnehmer und Teilnehmerinnen die ersten Erfahrungen mit AntMe und C# gesammelt haben.Ein weiterer großer Vorteil ist, dass es sich nicht um eine abgespeckte Sprache handelt, sondern um reines C#, mit dem auch später noch viel Nützliches erreicht werden kann.Ich persönlich setze AntMe gerne ein, um nicht nur Kinder in die Welt der Softwareentwicklung einzuführen. Daher bekommt AntMe von mir eine absolute Empfehlung aufgrund der Kombination von C#/VB.NET und einer kindgerechten Einführung.Interview mit Tom Wendel, Entwickler von AntMe
<em>Stelle dich bitte kurz vor.</em><br/><b>Tom Wendel:</b> Parallel zu einer Fachinformatiker-Ausbildung <br/>und dem anschließenden Informatikstudium habe ich als Tontechniker im Theater gejobbt. Beruflich hat es mich schon früh zu Microsoft gezogen, wo ich als Evangelist eine Weile durch Entwicklerkonferenzen getourt bin. Heute, mit 40, bin ich selbstständig, aber seit der Geburt meiner Tochter begnüge ich mich mit ein paar festen Kunden und aktuell wenig Reiserei.<br/><br/><em>Wie hat deine Arbeit an AntMe begonnen?</em><br/><b>Wendel:</b> Sowohl die Grundidee als auch die Spielidee stammen von Wolfgang Gallo. Er sollte als Microsoft Student Partner ein spannendes Softwareprojekt für die Games Convention 2008 (damals in Leipzig) erstellen und hat mich mit ins Boot geholt. <br/><em><br/>Warum gerade ein Serious Game mit Ameisen?</em><br/><b>Wendel:</b> Auch das war Wolfgangs Idee. Angelehnt an den Coder-Klassiker Core Wars geht es darum, viele relativ dumme Einheiten zu programmieren, um am Ende ein intelligentes Kollektiv zu erhalten. Spieler vergleichen das oft mit der Schwarmintelligenz, aber das greift ein wenig zu kurz. Um das Szenario nicht mit wenig sexy anmutenden abstrakten Einheiten zu gestalten, haben wir uns an der Natur orientiert. Unsere Wahl fiel auf die Ameisen – durchaus ein Glückstreffer. Die Spieler identifizieren sich sehr schnell mit unserer knuffigen Visualisierung.<br/><em><br/>Wie kam es zum Projektnamen?</em><br/><b>Wendel:</b> Das war ein Gedankenblitz meiner damaligen Freundin, einer Mediengestalterin. Sie meinte, dass man im Spiel ja sozusagen etwas zur Ameise macht. Daraus ist „Ameise mich!“ beziehungsweise „AntMe!“ entstanden.<br/><em><br/>Wie ist das Spielprinzip mit dem Lerneffekt verknüpft?</em><br/><b>Wendel:</b> Der Schlüssel des Spiels scheint tatsächlich der schnelle Erfolg zu sein. Mit wenigen Zeilen Code können die Ameisen schon ordentlich Zucker sammeln. Aber bald läuft man in die Komplexität von verteilten und autonomen Systemen. Das zeigt sich im Spiel durch Ameisen, die einfach nicht tun, was man ihnen sagt. Gerade das aber stellt auf emotionaler Ebene eine Verbindung her, die den Spieler erst mal nicht loslässt. Dass das Konzept so aufgeht, war nie geplant. Die Leute hatten einfach Spaß, und wir haben bei unseren Vorträgen erst nach und nach bemerkt, dass man gewisse Umstände und Programmierparadigmen sehr gut anhand der Ameisen erklären kann – Deadlocks beispielsweise. Es ist also eher so, dass das pädagogische Konzept im Nachgang entstand, nicht vorher. <br/><em><br/>Welche Ameisenvölker findest du besonders bemerkenswert?</em><br/><b>Wendel:</b> Die spannendste Erkenntnis in all der Zeit war sicher, dass jeglicher Ansatz selbstlernender Ameisen mit Pauken und Trompeten gescheitert ist. Zumindest habe ich bislang keine Implementierung spielen sehen, die es mit trivialen Ameisenvölkern aufnehmen konnte. Steigende Komplexität versaut das Volk.
Fussnoten
- Download von AntMe, http://www.antme.net/de
- Wiki zu AntMe, http://wiki.antme.net/de/Hauptseite
- Download des Microsoft-XNA-Frameworks, http://www.dotnetpro.de/SL2207AntMe1
- Download der Visual Studio Community-Edition, http://www.dotnetpro.de/SL2207AntMe2
