Nahrung

In diesem Tutorial lernst du, wie du deinen Ameisen beibringst, sich zu bewegen und Nahrung zu sammeln.

Diese Vorgaben geben wir in der Entwicklungsumgebung ein – wir programmieren die Ameisen, das auszuführen, was wir ihnen vorgeben.

Unsere frisch erstellte Ameisenkolonie im Sandkasten ist in der Programmierung eine sogenannte Klasse. Darunter versteht man einen Plan, der festlegt, wie sich mehrere ähnliche Objekte verhalten sollen. Dieser Plan beschreibt Attribute (Eigenschaften) und Methoden (Verhaltensweisen) der Objekte.

Bei AntMe! sind Objekte die Ameisen. Indem wir ihre Klasse bearbeiten, legen wir ihre Verhaltensweisen fest. Zunächst wollen wir sie dazu bringen, sich zu bewegen. Suche dazu auf der rechten Seite im Solution Explorer die Zeile AlphaClass.cs und klicke sie.

Damit öffnest du im Code Editor in der Bildschirmmitte die programmierbare Klasse unserer Kolonie „Alpha“. Im unteren Teil siehst du die fünf Blöcke Kasten, Fortbewegung, Nahrung, Kommunikation und Kampf. Einen solchen Block nennt man „Methode“. Als Methoden bezeichnet man Unterprogramme, die das Verhalten von Objekten beschreiben. Indem man einem einzelnen Objekt vorgibt, wie er sich verhalten soll, können Objekte untereinander in Verbindung treten. Genau das sollen unsere Ameisen jetzt leisten, sie sollen ausschwärmen und nach Nahrung suchen.

Fortbewegung gibt den Ameisen vor, wie sie sich bewegen sollen. Klicke nun auf das kleine Pluszeichen links von Fortbewegung und schreibe den folgenden Programmbefehl bei „Wartet ( )“ in die Zeile zwischen die { }:

public override void Wartet()
{
    GeheGeradeaus();
}

Das sieht dann im Editor insgesamt so aus:

Klicke nun auf die grüne „Play“-Taste in der Entwicklungsumgebung, um die AntMe!-3D-Ansicht zu starten. Jetzt wirkt sich dein Programmierbefehl „gehe gerade aus“ in der Spielwelt aus. Schon schwärmen die Ameisen aus dem Nest und verteilen sich im Sandkasten.

Im Moment rennen unsere Ameisen ziellos durch die Gegend. Dies änderst du, indem du sie auf Nahrungssuche schickst.

public override void Sieht(Zucker zucker)
{

}

Ändere die Methode nun wie folgt ab:

public override void Sieht(Zucker zucker)
{
    if(AktuelleLast == 0)
    {
        GeheZuZiel(zucker);
    }
}

Damit gibst du deinen Ameisen vor, dass sie sich zu einem Zuckerhaufen bewegen sollen, sobald sie ihn sehen. Dies tun sie aber nur unter der Bedingung, wenn („if“) ihre aktuelle Last = 0 ist, also wenn sie noch keine Last tragen.

Suche dir nun die Methode „Sieht“, die für das Obst zuständig ist. Ändere sie genau so ab wie auf dem letzten Bild beschrieben, außer dass du in die Klammern (obst) anstelle von (zucker) setzt.

public override void Sieht(Obst obst)
{
    if(AktuelleLast == 0)
    {
        GeheZuZiel(obst);
    }
}

Der Unterschied besteht darin, dass die Ameisen jetzt zu einem Obststück laufen anstelle eines Zuckerhaufens. Auch das passiert unter der Voraussetzung, dass sie noch keine Last geladen haben.

Im Editor schaut es so aus:

Jetzt laufen deine Ameisen zu einem Zuckerhaufen oder einem Obststück, sobald sie es sehen. Sobald deine Ameisen an einer Nahrungsquelle angelangt sind, passiert aber noch nichts. Wir sollten jetzt den Ameisen mitteilen, was sie tun sollen, wenn sie an einer Nahrungsquelle angekommen sind.

Suche die Methode „ZielErreicht“, die für den Zucker zuständig ist. Füge ihr anschließend die folgenden Zeilen hinzu:

public override void ZielErreicht(Zucker zucker)
{
    Nimm(zucker);
    GeheZuBau();
}

Suche anschließend die Methode „ZielErreicht“, die für das Obst zuständig ist. Ändere sie ebenfalls ab, indem du in die Klammern (obst) einsetzt anstatt (zucker).

public override void ZielErreicht(Obst zucker)
{
    Nimm(obst);
    GeheZuBau();
}

Im Editor sieht es wie folgt aus:

Jetzt suchen deine Ameisen nach Nahrung ( Zucker und Obst) und laufen dorthin, sobald sie sie sehen. Wenn sie dort angekommen sind, nehmen sie Nahrung auf und tragen sie zurück in den Bau.

Dafür hast du acht Zeilen an Quelltext (auch Quellcode genannt) geschrieben.

Quelltext nennt man den in einer Programmiersprache geschriebenen Text eines Computerprogramms, das in Maschinensprache übersetzt werden kann. Diese Übersetzung gibt dem Computer vor, was er ausführen soll.

Einen solchen Übersetzer nennt man Compiler (lat. für compilare = anhäufen). Ein Compiler ist also eine Computeranwendung, die ein anderes Programm, das in einer bestimmten Programmiersprache geschrieben ist, so übersetzt, dass ein Computer sie ausführen kann.

Wenn du dem Spiel genau zusiehst, wirst du bemerken, dass immer neue Ameisen zu einem Obststück hinlaufen, auch wenn schon sehr viele Ameisen es tragen. Dieses Verhalten kannst du noch verbessern.

Suche die Methode „Sieht“ für Obst. Ändere die Zeile so ab, dass sie so aussieht:

public override void Sieht(Obst obst)
{
    if(AktuelleLast == 0 && BrauchtNochTräger(obst))
    {
        GeheZuZiel(obst);
    }
}

public override void ZielErreicht(Obst obst)
{
    if(BrauchtNochTräger(obst))
    {
        Nimm(obst);
        GeheZuBau();
    }
}

In der „Sieht“ Methode haben wir überprüft, ob das Obststück noch Ameisen zum Tragen benötigt. In der „ZielErreicht“ Methode überprüfen wir das noch einmal mit „if-BrauchtNochTräger“. Der Grund für diese Doppelung: es kann sein, dass das Obststück noch einen Träger benötigt, wenn die Ameise es sieht. Wenn die Ameise am Obststück etwas später ankommt, kann aber schon eine andere Ameise an ihrer Stelle hinzugekommen sein und hilft beim Tragen.

Damit hast du deinen Ameisen beigebracht, wie sie sich Nahrung in Form von Obst und Zucker besorgen und in ihren Bau tragen können. Für jede zum Bau transportierte Zuckereinheit erhältst du übrigens 1 Punkt und für jeden Apfel als Obststück 250 Punkte.