2. Von objektorientierten Ameisen

2. Von objektorientierten Ameisen
Die Idee
Was das Kapitel OOP im Unterricht oft unerfreulich macht, ist die Tatsache, dass
man mit wenig attraktiven Beispielen (die zudem auch ohne OO viel schneller
programmiert worden wären!) und mit einer Unmenge abstrakter Begriffe selbst
interessierte Schülerinnen und Schüler jeglichen Spass raubt. Das einführende, aber
unvermeidliche Kapitel 5.1 war ja schon an der Grenze der Zumutbarkeit!
Was kann man dagegen tun?
Man bräuchte ein interessantes Programm, dass in den wesentlichen Teilen schon
fertig geschrieben ist, im zu ergänzenden Teil aber die „volle Objektorientiertheit“
fordert. Die Lernenden sollten sich nahezu ausschließlich auf die OOP konzentrieren
können und dabei eigenes Experimentieren ermöglichen.
Hier wird man fündig: http://antme.net/
Der im Bild unten gezeigte Screenshot des Simulationsspiels AntMe! (frei übersetzt
etwa: Mach mir die Ameise!) zeigt den Ameisenbau der „aTomKampfameisen“ ganz
zu Beginn der Spielrunde. Weiß sind die Zuckerhaufen, grün die Obststücke, die den
Ameisen als Nahrung dienen. Die etwas größeren blauen Punkte sind böse Käfer,
die die Ameisen fressen wollen.
Zugegeben, - die Grafik wirft einen nicht gerade um! Aber darauf kommt es hier auch
gar nicht an. Sie sollen mit OOP möglichst intelligente Ameisen erschaffen
Das AntMe!-Programm ist kostenlos und hat alle oben genannten erwünschten
Eigenschaften. Wir werden in diesem Kapitel, eine eigene Klasse Powerameise
16

aus der schon fertigen Klasse Ameise ableiten. Die daraus gebildeten Objekte
sollen möglichst intelligent sein, so dass sie in der Simulation AntMe! auch gegen
schon fertige Ameisen-Objekte eine Chance haben. (Künstliche Intelligenz ist hier
das passende Stichwort!)
Holen Sie sich den Ordner AntMe11 aus dem Tauschverzeichnis. Im Ordner
befinden sich zwei weitere Ordner und einige Hilfedateien. Wir benötigen den Ordner
AntMeEinsteiger. Öffnen Sie mit Visual C# 2008 die Projektdatei Spieler.sln.
(Ärgerlich, aber typisch für die Kurzlebigkeit von Software: Eine Woche nach Fertigstellung dieses
Skripts kam die neue Version AntMe! 1.6 herraus. Prinzipiell können alle Erkenntnisse aus AntMe! 1.1
eins zu eins auf Version 1.6 übertragen werden. Die Bezeichnungen und die Gewinn-Punkte haben
sich zwar teilweise geändert, das Spielkonzept ist aber gleich geblieben. Es steht jedem frei, die hier
dargestellten Vorgehensweisen auf die neue Version zu übertragen. Allerdings sind die erreichten
Punkte dann nicht mehr vergleichbar!)
Ein erster Versuch
Damit Sie gleich mit einer eigenen Ameisenart loslegen können, sind einige
Kleinigkeiten noch zu erledigen.
Der Proketmappen-Explorer zeigt am Anfang nur
eine eine cs-Datei: Vorlage.cs. Da diese Datei
unseren eigenen Quellcode enthalten soll, ist es
sinnvoll, gleich eine Kopie der Datei zu erstellen.
Wir nennen sie Spieler.cs.
In der Datei sind schon viele, bisher noch leere
Methoden vorbereitet.
Der Namespace AntMe.Spieler ist ebenfalls schon
vorbereitet. Wir müssen nur einen eindeutigen
Namen für den Spieler wählen. (Vorname und
Nachname können auch leer gelassen werden.)
namespace AntMe.Spieler {
[Spieler(
Name = "PowerAmeisen",
Vorname = "Otto",
Nachname = "Ameise"
)]
Im Folgenden ist dunkelblaue Schrift immer ein Zeichen dafür, dass die passende
OOP-Theorie zum gerade behandelten konkreten Beispiel erklärt wird.
Theoretisch hätte man den namespace Spieler auch innerhalb des namespace
AntMe seperat deklarieren können:
namespace AntMe
{
…...
17

}
namespace Spieler
{
…....
}
Die erste Definition ist aber etwas übersichtlicher: Erst kommt der übergeordnete
namespace, dann ein Punkt und danach der untergeordnete namespace.
In unserer Spieler.cs-Datei könnte man sogar nur
namespace Spieler
schreiben. Das liegt daran, dass im using-Abschnitt bereits der namespace AntMe
eingetragen ist. So kann der Compiler die Namensergänzung vornehmen. Besonders
übersichtlich ist diese Methode aber nicht!
Wenn Sie das Spiel jetzt starten, bekommen Sie eine Fehlermeldung:
Das wird Sie vermutlich erstaunen, denn so sehr Sie das Dokument auch
durchsuchen: Eine Klasse innerhalb des namespace AntMe.Spieler mit Namen
MeineAmeise können Sie nicht entdecken.
Hier spätestens müssen Sie wissen, dass die Definition von namespaces sich auch
über mehrere Dokumente verteilen kann.
Diskutieren wir nicht lange mit dem Compiler und wählen einfach einen anderen
Klassennamen: MeinePowerAmeise.
public class MeinePowerAmeise : Ameise
MeinePowerAmeise erbt, wie Sie wissen, alles von der bereits Definierten Klasse
Ameise. Dass dies nicht sehr viel ist, können Sie sofort testen:
Wenn man mit Strg+F5 startet, dann läuft der „Zeit-Ticker“ gleich mit an. Stoppen Sie
den Vorgang, indem Sie auf das kleine grüne Quadrat oben links klicken. Nun
können Sie über den Tab lokales Spiel eine Ameisenklasse auswählen:
18

Klicken Sie auf Ihre Powerameise und starten Sie die Simulation mit dem kleinen
grünen Button oben links. Wenn Sie den Haken bei konstante Bildrate rausnehmen,
läuft die Simulation in maximalem Tempo.
Große Enttäuschung: Ihre Powerameisen bleiben einfach im Bau und werden eine
nach der anderen von den Käfern gefressen.
(Im Bild rechts unten sieht man gerade noch ihre Fühler!)
Ein Blick auf die Datei Spieler.cs hilft weiter. Dort sind die Gerüste vieler Methoden
eingetragen. Wir müssen sie nur noch mit sinnvollen Anweisungen füllen.
In Kapitel 2 haben Sie bestimmte Ereignismethoden von Steuerelementen in .NET
kennengelernt. Zu einem Button ist zum Beispiel ein Click-Ereignis definiert. Hierzu
gehört eine Methode, die beschreibt, was passieren soll, wenn der Benutzer auf den
Button klickt. Der Benutzer selbst ist hier der Auslöser für das Click-Ereignis.
In der AntMe!-Simulation greift der Benutzer (=der Spieler) nicht ein. Er kann sie
höchstens starten oder beenden. Dennoch gibt es in der Ameisenklasse zum
Beispiel eine Wartet()-Methode. Diese Ereignismethode wird ausgeführt, wenn eine
Ameise inaktiv ist. In der Simulation läuft ein „Ticker“ mit: In jeder Sekunde werden
eine bestimmte Anzahl von Runden durchgeführt. Bei jeder neuen Runde werden
alle definierten Ereignismethoden überprüft und gegebenenfalls durchgeführt.
Wir müssen einer wartenden Ameise daher mitteilen, was sie zu tun hat:
public override void Wartet()
{
GeheGeradeaus();
}
Was public bedeutet sollten Sie noch wissen: Von überall kann auf diese Methode
zugegriffen werden.
Mit override wird die Wartet()-Methode überschrieben. Sie ist also bereits von der
Ameisenklasse geerbt.
Das dritte Wort void signalisiert, dass die Methode Wartet() keinen Wert zurückgibt.
Die Methoden, die dem Ameisenkonstrukteur zur Verfügung stehen, sind in der
Spieler.cs-Datei zu finden. Damit etwas sinnvolles passiert, müssen sie
überschrieben werden, - so wie die Waretet()-Methode oben. Daher steht
vorsorglich schon immer override dabei.
Die möglichen Befehle finden Sie in der dem AntME11-Ordner beiliegenden
Befehlsliste.pdf – Datei. Hier ein Ausschnitt:
19

Aufgabe 1
Testen Sie, ob sich durch die obige Code-Änderung die Situation der PowerAmeisen
verbessert hat. Welche Befehle und Methoden lassen sich denn noch sinnvoll
kombinieren?
public override void Sieht(Zucker zucker)
{
}
Überschreiben was nicht passt
Da die Ameisen hungrig sind, müssen wir die obige Methode überschreiben. Die
Sieht()-Methode hat hier im Gegensatz zur Wartet()-Methode einen Parameter
mitgebracht. Es handelt sich um ein Objekt names zucker der Klasse Zucker.
Die Ereignismethode tritt also nur ein, wenn das von der Ameise gesehen Objekt ein
zucker-Objekt ist.
(Üblicherweise werden in .NET Objekte klein und Klassen groß geschrieben).
Ergänzung:
Zwischen den Klammern einer Methode dürfen auch mehrere Parameter stehen.
Sie werden dann per Komma getrennt. Z.B.: Schnarchen(Int Lautstaerke, Int Dauer)
Da die aufrufende Sieht()-Methode gleich auch als Parameter ein konkretes zucker-
Objekt mitbringt, liegt der folgende Befehl nah:
public override void Sieht(Zucker zucker)
{
GeheZuZiel(zucker);
}
Wenn die Ameise schon beladen ist, dann soll sie den Befehl ignorieren. Das
erledigen wir mit einer Verzweigung. Die Befehlsliste hilft, ein hier relevante Feld
(vom Typ bool) zu finden: AktuelleLast. Die IntelliSens zeigt, dass wir auf dem
richtigen Weg sind:
20

public override void Sieht(Zucker zucker)
{
if (AktuelleLast==0)
{
GeheZuZiel(zucker);
}
}
Beim Testen stellen wir fest, dass nun alle Ameisen, die einen Zuckerhaufen
gefunden haben, an diesem gebannt stehenbleiben. Sehr zur Freude der Käfer!
Also müssen wir nach einer Methode suchen, die den Ameisen vorschreibt, was sie
zu tun haben, wenn sie das Zucker-Ziel erreicht haben. Hier ist sie:
public override void ZielErreicht(Zucker zucker)
{
}
Danach sehen Sie in die Befehlsliste und entscheiden, welche Befehle hier sinnvoll
sein könnten.
Zunächst muss die Ameise den Zucker erst einmal aufnehmen. Hier passt der Befehl
nimm(). Wenn man den Befehl eintippt, erkennt man, dass nimm() offensichtlich zwei
verschiedene Parametertypen zulässt:
Die erste Möglichkeit wäre (Obst obst) gewesen. Klar, - die Ameisen können sich
von den rumliegenden (grünen) Obststücken ebenso ernähren, wie von Zucker.
Wenn sie einen solchen Apfel nachhause bringen, bekommen sie 250 Punkte
gutgeschrieben. Für Zuckerstücke gibt es nur 5 Punkte. Allerdings können sie einen
Apfel nicht alleine tragen. Das macht die Sache komplizierter!
21

Überladen ist bequem
In Kapitel 5.1 haben wir „überladene“ Methoden behandelt. Hier an diesem Beispiel
können Sie Ihre Kenntnisse darüber vertiefen.
In Programmiersprachen, wie PHP, muss man darüber kein Wort verlieren. Diese
Sprachen sind bequem zu handhaben, weil sie nicht typensicher sind. Definiert
man dort eine Methode NimmMal(Int a, Int b), die das Produkt der Parameter a und
b berechnen soll, so meckert der Interpreter nicht, wenn man die Methode mit
double-Variablen füttert. Das klingt sinnvoll. Allerdings meckert er ebensowenig,
wenn man für a den String „123“ und für b die Integerzahl 2 wählt, also „123“ * 2. Das
Ergebnis wird die Integerzahl 246 sein.
Wenn man auch dies noch für sinnvoll hält, dann stutzt man mit Sicherheit, wenn
NimmMal(hallo, nasowas!) ein Ergebnis, wie 0 ausgibt. Spätestens jetzt wird klar,
dass Typensicherheit eine sehr wichtige Eigenschaft der Programmiersprachen ist.
Der Compiler von C# lässt nicht einmal zu, wenn man für die Variablen double-
Größen verwendet und bewahrt uns dadurch vor schwer zu entdeckenden Fehlern.
Trotzdem kann man auch in C# und .NET Methoden für verschiedene Parameter fit
machen. Man verwendet den gleichen Methodennamen Nimm() innerhalb der
Klasse MeinePowerAmeise für verschiedene Methoden. Dieser Vorgang wird, wie
Sie wissen, überschreiben von Methoden genannt.
(Eigentlich werden ja nicht die Methoden Nimm() und ZielErreicht() überschrieben, sondern deren
Bezeichner Nimm und ZielErreicht.…)
Aufgrund der verschiedenarten Parameter kann der Compiler, trotz Gleichheit der
Bezeichner, die richtige Methode zuordnen.
Noch etwas ist an der Angabe der Intellisens
interessant: Die Klasse Ameise hat die
Nimm()-Methode offensichtlich von der Basisklasse Insekt geerbt. In der Klasse
MeinePowerAmeise wird die Methode jetzt überschrieben. Woran erkennt man das?
Zurück zur Simulation.
Eine Ameise am Zucker soll den Zucker aufnehmen (Nimm(zucker)) und sich dann in
Richtun Bau aufmachen:
public override void ZielErreicht(Zucker zucker)
{
Nimm(zucker);
GeheZuBau();
}
Aufgabe 2
Testen Sie nun die Änderungen.
Erfreulich, dass das
Nahrungskonto durch den
gesammelten Zucker wächst, und
somit das Punktekonto
wenigstens bescheiden wächst.
Verbessern Sie die Fähigkeit
22

Ihres Volkes, indem Sie nun auch Obst einsammeln und in den Bau bringen lassen.
Wie könnte man den Obsttransport verbessern? Wenn schon genügend Ameisen für
den Transport abgestellt sind, dann bringt eine weitere Helferin keinen Vorteil!
(Eine mögliche Lösung am Ende des Kapitels!)
Den Zugriff auf die Dateien Insekt.cs oder Ameise.cs hat man nur in der Profiversion
des Programms (Tauschverzeichnis). Hier kann man auf alle Klassen zugreifen und
das Spiel in jeder gewünschten Weise verändern. Da wir noch keinen Profi-Status
erreicht haben, schauen wir uns nur kurz einen kleinen Ausschnitt der Insekt.cs
Datei an:
public void GeheGeradeaus()
{
if (!NimmBefehleEntgegen)
return;
restStreckeI = int.MaxValue;
}
public void GeheGeradeaus(int entfernung)
{
if (!NimmBefehleEntgegen)
return;
restStreckeI = entfernung * Spiel.SPIELFELD_EINHEIT;
}
Man erkennt, dass es sich um die Definition der (überladenen) Methode
GeheGeradeaus() handelt. Wie Sie durch die IntelliSens vielleicht schon entdeckt
haben, kann man die Methode auch mit einem Parameter aufrufen, also etwa:
GeheGeradeaus(schritte). Wichtig ist dabei, dass die Variable schritte vom Typ her
passt, - also eine Integervariable darstellt.
Nehmen wir an, Sie haben irgendwo im Progamm festgelegt, dass schritte = 100 sein
soll. Dann wird beim Aufruf der Methode GeheGeradeaus(schritte) eine Kopie der
Variablen schritte in die lokale Variable entfernung geschrieben. Selbst wenn die
Methode eine Änderung von entfernung vornehmen sollte, - auf die Variable schritte
hat dies keinen Einfluss.
Von außen kann man die lokale Variable entfernung nie direkt verändern, da die
Klasse Insekt, wie alle Klassen ihre Methoden kapselt. In der AntMe!-Einsteiger
Fassung haben die Programmier ganze Arbeit gemacht: Man kann die Basisklassen
nicht einmal anschauen! Und das ist der Normalfall: Man muss wissen was die
Methode tut, es ist aber nicht nötig, zu wissen, wie sie es tut!
Obwohl die von uns erstellte Klasse MeinePowerAmeise ja von der Klasse Insekt
abgeleitet ist, kann man von dort aus die Variable entferung ebenfalls ausschließlich
durch Aufruf der public-Methode GeheGeradeaus() beeinflussen.
Bisher haben wir die bösen Käfer außer Acht gelassen. Gut, dass sie langsamer als
die Ameisen laufen, sofern letztere keine Last zu tragen haben. Trotzdem ist der
Verlust an Ameisen nicht unerheblich, denn sie reagieren bisher überhaupt nicht,
wenn sie einen Käfer in Sichweite haben.
Wenn man die Befehlsliste ansieht, so wird klar, dass, wie im richtigen Leben auch,
Flucht oder Angriff zur Wahl stehen. Ein Angriff ist aber nur sinnvoll, wenn
mindestens 4 andere Ameisen bei der Überwältigung des Käfers mithelfen. Ein toter
Käfer ist durchaus lukrativ: Er bringt 150 Punkte für die PowerAmeisen!
23

Aufgabe 3
Schreiben Sie sinnvolle Anweisungen für die Methode Sieht(Käfer käfer).
Verwenden Sie: AktuelleLast, AnzahlInSichtweite, GreifeAn(käfer),
LasseNahrungFallen(), GeheWegVon(käfer). (Mögliche Lösung am Kapitelende)
Variable, Felder und Eigenschaften
An dieser Stelle müssen wir klären, was der Unterschied zwischen Variablen,
Feldern und Eigenschaften ist.
• Variable-Felder:
Beide sind im RAM repräsentiert, - allerdings dürfen Felder grundsätzlich nur
außerhalb von Methoden definiert werden. Sie sind in der ganzen Klasse
verwendbar.
Man kann bei der Definition von Feldern durch Zugriffsspezifizierer, wie public
oder privat, regeln, ob sie außerhalb der Klasse sichtbar sind oder nicht.
Felder werden im Gegensatz zu Variablen automatisch initialisiert.
Numerische Felder bekommen dabei eine 0, Strings eine leere Zeichenkette ““
• Felder-Eigenschaften:
Wer lange genug für .NET programmiert hat, vergisst möglicherweise, dass es
einen Unterschied zwischen den beiden Begriffen gibt. Und das kommt nicht
von ungefähr. Fragt man beispielsweise durch
aL = PowerAmeise.AktuelleLast
einen aktuellen „Zustand“ unserer Ameise ab, so liegt einem auch der Begriff
„Eigenschaft“ der Ameise auf der Zunge. Die Tatsache aber, dass
AktuelleLast groß geschrieben ist, deutet darauf hin, dass AktuelleLast eine
Methode und kein Feld ist. Und eben diese spezielle Methode wird
Eigenschaft genannt. Verwirrend? Nicht, wenn Sie sich den folgenden
Abschnitt ansehen!
Was ist AktuelleLast oder AnzahlInSichtweite? Ein Feld?
Schauen wir doch einfach mal in der Profiversion nach der Datei Insekt.cs.
Dort gibt es aktuelleLast (kleingeschrieben) und AktuelleLast (großgeschrieben):
private int aktuelleLast = 0;
public int AktuelleLast
{
get { return aktuelleLast; }
internal set{ aktuelleLast = value;}
}
Hier wird klar, dass es sich bei aktuelleLast um ein Feld handelt. Die Initialisierung
mit dem Wert 0 ist nur deshalb vonnöten, weil in einem vorhergehenden Aufruf der
Methode AktuelleLast ein von 0 verschiedener Wert gesetzt sein könnte.
24

Wozu dieser Umstand?
Das Feld aktuelleLast ist private und kann und soll daher nur in dieser Klasse
angesprochen werden (Kapselung!). Um dieses Feld von außen lesen zu können,
gibt es die public Methode AktuelleLast und in dieser die get-Methode. Die
Namensgleichheit ist Absicht. Durch die dann mögliche Schreibweise
Hermine.AktuelleLast (hermine ist eine Powerameise) hat man den Eindruck, das
Feld direkt auszulesen, was ja, wie Sie wissen, wegen des private-Charakters von
aktuelleLast nicht möglich ist.
Zum Schreiben bietet die Methode AktuelleLast die set-Methode an. Durch den
Zugriffsqualifizierer internal aber kann von außen aktuelleLast nicht verändert
werden. (In Wirklichkeit ist die set-Methode in Insekt.cs noch komplizierter. Dies ist
aber für das Verständins nicht weiter von Bedeutung).
Halten wir fest: Obwohl die Methode AktuelleLast public ist, kann das Feld
aktuelleLast von außen lediglich gelesen, nicht aber gesetzt werden.
Aufgabe 4
Suchen Sie in der Datei Insekt.cs nach weiteren Methoden/Eigenschaft-Paaren.
(Beispiel: anzahlInSichtweite und AnzahlInSichtweite).
Wir haben oben die Sieht(Käfer käfer)-Methode implementiert. Weil die Ameisen
alleine gegen die Käfer hoffnungslos unterlegen sind, ließen wir einen Angriff nur zu,
wenn mehr als 5 andere Ameisen in Sichtweite sind.
Wer genau hinschaut stellt fest, dass trotz dieser Bedingung nicht alle Ameisen, die
in der Nähe des Käfers sind, angreifen. Einige machen sich aus dem Staub und
überlassen die anderen angreifenden Ameisen ihrem Schicksal.
Woran liegt das? Ganz einfach: Nicht alle Ameisen, welche Ameise Helga sieht,
werden auch von den anderen gesehen. Wenn Ameise Hubert ziemlich weit rechts
von Helga steht, Ameise Gundi aber recht weit links von ihr, dann sieht Hubert
Gundi vielleicht nicht und ergreift die Flucht.
Markierungen: Call by reference oder Call by value?
Spätestens an dieser Stelle sollten wir eine Möglichkeit (Methode) unserer Ameisen
ins Auge fassen, die hier sehr nützlich sein kann: SprüheMarkierung(). Eine
durchaus realistische Methode, denn in Wirklichkeit benutzen die Ameisen
tatsächlich Duftstoffe um anderen aus ihrem Stamm den richtigen Weg zu weisen.
Aus der Befehlsliste entnimmt man, dass die Methode zwei Parameter hat. Der erste
Parameter (Int32, also von -2.147.483.648 bis 2.147.483.647) dient der Information
anderer Ameisen und kann über markierung.Information ausgelesen werden. Dies
ist zwar ein sehr großer Bereich, - allerdings bräuchte man, sofern man mit
kartesichen Koordinaten rechnet, zwei Paramter allein für die Information, wo genau
sich ein bestimmtes Objekt befindet. Wir müssen die zwei Informationen auf
25

geschickte Art in die eine Zahl stecken. Wie genau das funktionieren soll, werden wir
uns später ansehen.
Der zweite Parameter bestimmt die Reichweite der Duftmarke. Je weiter desto
kurzlebiger!
Welche Orientierung haben denn die Ameisen (ohne unsere Hilfe) mitbekommen?
Die Koordinaten-Klasse hat, entnimmt man der Befehlsliste, zwei Methoden:
Koordinate.BestimmeRichung() und Koordinate.BestimmeEntfernung().
Zu Koordinate.BestimmeRichung():
Schaut eine Ameise genau nach Osten und sieht dort beispielsweise einen
Zuckerberg, dann würde sich der Wert 0 (Grad) ergeben. Im Uhrzeigersinn geht es
dann weiter: Süden: 90 (Grad), Westen: 180 (Grad), Norden: 270 (Grad).
Zu Koordinate.BestimmeEntfernung():
Die Längeneinheit ist „ein Schritt“. In einer Spielrunde bewegt sich eine Ameise vier
Schritte weit. Das Spielfeld selbst hat das Maß 1200 x 900 Schritte.
„Sieht“ eine Ameise ein Stück Obst, so kann sie über die beiden genannten
Methoden lediglich die Richtung, die sie selbst einnehmen muss und ihre eigene
Entfernung auslesen. Leider sind das nur „relative“ Daten, - also Daten, die in dieser
Form anderen Ameisen nicht viel weiterhelfen.
Man muss offensichtlich dafür sorgen, dass aus den relativen Daten absolute Daten
werden. Stichwort: Kartesische Koordinaten! Und diese gilt es in einer Int32-Zahl auf
eindeutige Art unterzubringen.
Bevor wir uns an die Arbeit machen, ist leider noch etwas Theorie unumgänglich.
Wenn eine Ameise Zucker von einem Haufen wegnimmt, so muss das Feld menge,
durch die Eigenschaft Menge(Zucker zucker1) verändert werden, denn der Vorrat
nimmt ja ab.
Kommt eine weitere Ameise (theoretisch könnte es auch ein Zucker-fressender Käfer
sein) zu diesem Objekt, so muss er die vorhin veränderte menge vorfinden. Dies wird
dadurch realisiert, dass die Methode Menge als Parameter das (von der Klasse
Zucker abgeleitete) Objekt zucker1 geliefert bekommt. In diesem Fall spricht man
von einem call-by-reference:
Anstatt die Daten zu kopieren werden Referenzen auf die Daten übergeben. Man
kann sich das als Adress-Zeiger vorstellen: Beim Aufrufer zeigt eine Variable auf ein
bestimmtes Datum. An anderer Stelle zeigt eine nächste Variable auf dasselbe
Datum.
Methodenaufrufe an einem so übergebenen Objekt arbeiten also auf demselben
Objekt, das auch außerhalb sichtbar ist. Objekte landen speichertechnisch auf dem
bevorzugten Heap des RAM. Bevorzugt deshalb, weil im Gegensatz zum Stack die
Speicherfreiverwaltung von .NET für die notwendige „Buchhaltung“ und Lebensdauer
sorgt.
Den Stack hingegen arbeitet der Prozessor von „oben nach unten“ ab. Dort werden
auch Werte abgelegt, die bei einem Aufruf lediglich kopiert werden. Einen derartigen
Aufruf nennt man call-by-value:
Bei der Methode Sieht(Käfer käfer) beispielsweise gibt es das Feld
26

anzahlInSichweite, das durch die gleichnamige Methode ausgelesen wird:
AnzahlInSichtweite(). Sehen Sie sich folgenden Ausschnitt eines Programmcodes
an:
Metthode AnzahlInSichtweite aus Basisklasse Insekt:
public int AnzahlInSichtweite
{get { return anzahlInSichtweite; } }
Aufruf außerhalb:
int feinde = roxane.AnzahlInSichtweite; // 1.Zeile ; roxane ist eine Powerameise
feinde = 2*feinde; // 2.Zeile
Durch Zeile 1 bekommt das Feld feinde den gleichen Wert (durch kopieren), wie
anzahlInSichweite.
In Zeile 2 wird die Anzahl der feinde verdoppelt, - anzahlInSichweite bleibt davon
aber unbeindruckt!
Domit bekommt der Fachausdruck Werteparameter für int, double, Int64 etc. einen
Sinn: Ihr Aufruf ist ein call-by-value und ihr Platz ist im Stack!
Struct und static
Mit diesem Wissen ausgerüstet schaut man verunsichert auf die Methode
Koordinate.BestimmeEntfernung(). Aus den bisherigen Erfahrungen halten wir
Koordinate für ein Objekt und BestimmeEntfernung für eine Methoden seiner
Klasse. Glauben Sie wirklich, dass es sinnvoll ist, Koordinaten mehrfach zu
instantiieren? Es gibt duch nur eine Sorte Koordinaten, wenn man sich einmal
festgelegt hat.
Gut, - dann ist Koordinate also eine Klasse. Aber man kann Methoden der Klasse
doch nur über Objekte aufrufen?!
Schauen wir in der Profi-Version nach:
public struct Koordinate
{
…
public static int BestimmeEntfernung(IKoordinate o1, IKoordinate o2)
{
return BestimmeEntfernungI(o1.Koordinate, o2.Koordinate)
/ Spiel.SPIELFELD_EINHEIT;
}
…
}
Koordinate ist tatsächlich keine Klasse (class) sondern eine Struktur (struct)!
Der Hauptunterschied zwischen class und struct: Ist ein Parameter eine Struktur, so
ist der Aufruf ein call-by-value! Na, also! Und damit „arbeiten“ nicht alle Ameisen an
einem einzigen Feld herum. Entfernung zu einem anderen Objekt ist doch eine
27

individuelle Größe und sollte daher auch einen eigenen Speicher für jede Ameise
bekommen.
Der Zusatz static vor der Methode BestimmeEntferung besagt, dass es sich hier um
eine Klassenmethode handelt, die keine Realisierung in einem Objekt haben kann.
Dadurch kann man direkt Koordinate.BestimmeRichtung() aufrufen, ohne durch
new ein Objekt instantiiert zu haben. Man verwendet static-Methoden immer dann,
wenn es um globale Aufgaben geht. Und in der Tat ist es ja vollkommen egal, um
welche Objekte o1 und o2 es sich handelt. Es kommt nur darauf an wo sie stehen.
Natürlich arbeitet die struct Koordinate intern auch mit kartesischen Koordinaten, um
etwa die Entfernung zwischen zwei Objekten zu bestimmen: k1.x , k1.y und k2.x ,
k2y werden sie hier genannt:
internal static int BestimmeEntfernungI(Koordinate k1, Koordinate k2)
{
double deltaX = k1.x - k2.x;
double deltaY = k1.y - k2.y;
int entfernung =
(int)Math.Round(Math.Sqrt(deltaX * deltaX + deltaY * deltaY));
entfernung = entfernung - k1.radius - k2.radius;
if (entfernung < 0)
return 0;
return entfernung;
}
Da sie aber alle ausschließlich unter internal-Methoden zu finden sind, gibt es in der
Einsteigerfassung von AntMe! keine Möglichkeit an sie ranzukommen.
Müssen wir also selbst Hand anlegen!
Zuvor aber der Versuch, mit dem auszukommen, was da ist:
Koordinate.BestimmeEnfernung() und Koordinate.BestimmeRichtung():
Den Methoden müssen zwei Paramter übergeben werden: Objekt 1 und Objekt 2.
Versuchen wir es zunächst mit Koordinate.BestimmeRichtung().
Objekt 1 ist die Ameise. Als ausrufende wird sie schlicht this genannt.
Diese Richtungs-Information kann man in der Methode SprüheMarkierung()
übermitteln.
Im folgenden Versuch die Erzeugung einer Markierung für den Fall, dass die Ameise
Obst sieht:
public override void Sieht(Obst obst)
{
SprüheMarkierung(Koordinate.BestimmeRichtung(this, obst), 80);
if (AktuelleLast == 0 && BrauchtNochTräger(obst))
GeheZuZiel(obst);
}
Reaktion auf die Wahrnehmung der Markierung:
28

public override void Sieht(Markierung markierung)
{
if (AktuelleLast==0)
{
DreheInRichtung(markierung.Information);
GeheGeradeaus(50);
}
}
Am Radius 80 der Markierung und an der Zahl der Schritte in die (vermeintliche)
Zielrichtung, 50, kann noch gefeilt werden.
Die Begeisterung, mit der unsere Ameisen nun das Fallobst in den Bau bringen, ist
deutlich zu erkennen. Leider kommen die Käfer auf diese Weise fast ungeschoren
davon.
Außerdem gehen die von einer Markierung beeinflussten Ameisen weg vom Obst,
wenn sie auf der „falschen“ Seite stehen.
Werden die Ameisen von zwei verschiedenen Markierungen erreicht, bleiben sie
einfach stehen.
Trotzdem: Mit den obigen Werten kommt man, mit einigem Glück, auf über 5000
Punkte!
Das muss doch besser gehen!
Zunächst sollten unsere Ameisen auch bei der Sichtung eines Zuckerberges eine
Markierung vornehmen. Je näher sie an das Ziel kommt, desto kleiner (und damit
langlebiger) sollten die Radien der Markierung sein. Wenn man den Radius
gleichgroß, wie die Entfernung wählt, dann gibt es keine Markierung auf der anderen
Seite. So kann man vielleicht das Weglaufen einschränken:
public override void Sieht(Zucker zucker)
{
if (Koordinate.BestimmeEntfernung(this,zucker)

Auch in Sieht(Markierung markierung) kann man noch optimieren: Wenn die Ameise
schon ein Ziel hat, dann soll sie sich nicht beirren lassen:
if (AktuelleLast==0 && Ziel==null)
Versuchen Sie es: 6000 Punkte sollten drin sein!
Jetzt wollen wir die Ameisen auch Markierungen sprühen lassen, wenn sie außerhalb
der Sichtweite des Zuckers ihre wertvolle Last in den Bau tragen:
public override void Tick()
{
if (AktuelleLast>0 && Ziel is Bau)
{
SprüheMarkierung(Koordinate.BestimmeRichtung(Ziel, this), 20);
}
}
Das kann man schon fast eine Ameisenstraße nennen! Ergebnis:
Natürlich spielt auch der Zufall eine Rolle. Daher können es durchaus
auch mal 6500 Punkte werden…
Die hier erzeugte Spezies werden wir SammlerPlus taufen. (Das Plus,
weil es keine reine Sammler sind. )
Typen
Vermutlich ist Ihnen schon aufgefallen,
dass im Tab „lokales Spiel“ auch eine
andere Ameisen-Spezies ausgesucht
werden kann.
Neben einer möglicherweise anderen
Strategie wurde hier auch der Typ der
Ameise verändert. Das können Sie auch!
Es gibt sieben Felder:
Angriff, Energie, Last, etc.
Im unveränderten Zustand sind alle auf 0
gestellt. Möchte man einem Attribut den
Vorzug geben, so kann man dessen Punktezahl maximal um 2 Punkte erhöhen.
Gleichzeitig müssen aber ebensoviele Punkte an anderer Stelle abgezogen werden.
Wichtig: Man kann als minimalen Wert nur -1 einstellen.
So sieht der Programmcode dann zum Beispiel (Spieler.cs) aus:
30

[Typ(
Name = "Kämpfer",
GeschwindigkeitModifikator = -1,
DrehgeschwindigkeitModifikator = -1,
LastModifikator = -1,
ReichweiteModifikator = -1,
SichtweiteModifikator = 0,
EnergieModifikator = 2,
AngriffModifikator = 2
)]
Aufgabe 5
Verändern Sie den Code in den Methoden und im Typ so,
• dass eine reine Sammlerkolonie entsteht.
• dass eine reine Kämpferkolonie entsteht.
Welche Variante bringt mehr Punkte?
Tipps:
• Wenn Sie einen Typ, beispielsweise „Kämpfer“ erzeugen, dann dürfen Sie
nicht vergessen, in der „Erzeugungsabteilung“ den gewünschten Typ
anzugeben:
public static string BestimmeTyp(Dictionary anzahl)
{
return "Kämpfer";
}
• Je nach Art der Spezies sollte man beim Tick-Ereignis Optimierungen
vornehmen. Für die Kämpfer etwa, die ja von alleine nicht zum Bau zurückgehen,
muss festgelegt werden, dass sie im richtigen Moment den
Heimweg antreten, um Energie aufzutanken:
public override void Tick()
{
if (Reichweite - ZurückgelegteStrecke - 100 < EntfernungZuBau)
GeheZuBau();
if (AktuelleEnergie < MaximaleEnergie * 2 / 3)
GeheZuBau()
}
• Weitere Anregungen erhalten Sie, wenn Sie die Demospieler-cs-Dateien
studieren. (Tauschverzeichnis)
31

Man kann auch zwei oder
mehr Typen von Ameisen
erzeugen. Mit dieser äußerst
aggressiven Art (30 Arbeiter,
70 Kämpfer) kommt man
den 7000 Punkten schon
recht nah: 6762 Punkte!
Versuchen Sie noch weiter
zu spezialisieren, indem Sie
beispielsweise auf Obst bzw
auf Zucker optimierte
Ameisen schaffen.
Quelltext (in Auszügen) zum
Ameisen-Stamm rechts:
[Typ(
)]
Name = "Arbeiter",
GeschwindigkeitModifikator = 2,
DrehgeschwindigkeitModifikator = -1,
LastModifikator = 1,
ReichweiteModifikator = 0,
SichtweiteModifikator = 0,
EnergieModifikator = -1,
AngriffModifikator = -1
[Typ(
Name = "Kämpfer",
GeschwindigkeitModifikator = -1,
DrehgeschwindigkeitModifikator = -1,
LastModifikator = -1,
ReichweiteModifikator = -1,
SichtweiteModifikator = 0,
EnergieModifikator = 2,
AngriffModifikator = 2
)]
public static string BestimmeTyp(Dictionary anzahl)
{
if (anzahl["Arbeiter"] < 40)
return "Arbeiter";
else return "Kämpfer";
}
public MeinePowerAmeise(Volk volk, int typIndex) : base(volk, typIndex) {
}
32

public override void Wartet()
{
GeheGeradeaus(50);
DreheUmWinkel(Zufall.Zahl(-6, 6));
}
public override void WirdMüde() {
}
public override void Sieht(Zucker zucker)
{
if (Koordinate.BestimmeEntfernung(this,zucker) 0) LasseNahrungFallen();
SprüheMarkierung(-1, 200);//Nur die Kämpfer-Ameisen sollen reagieren
if (AnzahlInSichtweite > 5)
{
GreifeAn(käfer);
}
else GeheWegVon(käfer, 80);
}
public override void Sieht(Markierung markierung)
{
if (AktuelleLast==0 && Ziel==null)
{
if (markierung.Information == -1 && Typ == "Kämpfer")
{
33

}
}
}
}
GeheZuZiel(markierung);
}
if (markierung.Information != -1 && Typ == "Arbeiter")
{
DreheInRichtung(markierung.Information);
GeheGeradeaus(50);
}
public override void WirdAngegriffen(Käfer käfer)
{
if (Typ=="Kämpfer")
GreifeAn(käfer);
else GeheWegVon(käfer, 80);
}
public override void ZielErreicht(Zucker zucker)
{
Nimm(zucker);
GeheZuBau();
}
public override void ZielErreicht(Obst obst)
{
Nimm(obst);
GeheZuBau();
}
public override void Tick()
{
if (AktuelleLast > 0 && Ziel is Bau && Typ == "Arbeiter")
{
SprüheMarkierung(Koordinate.BestimmeRichtung(Ziel, this), 20);
}
if (Typ=="Kämpfer")
{
if (Reichweite - ZurückgelegteStrecke - 100 < EntfernungZuBau)
GeheZuBau();
if (AktuelleEnergie < MaximaleEnergie * 2 / 3)
GeheZuBau();
}
}
Möglicherweise kommen Einige durch ausgeklügelte Kombinationen von Ameisen-
Spezialisten und einer noch geschicktere Strategie auf 7000 - 7500 Punkte. Man
merkt jedoch, dass für ein wirklicher Fortschritt neue Ideen gefragt sind. Zu denen
kommen wir jetzt!
34

Lokales Gedächtnis
Praktisch wäre, wenn sich die Arbeiter-Ameisen einen einmal gefundenen
Zuckerberg merken könnten.
Ob Insekten tatsächlich ein Gedächtnis haben, können Sie übrigens hier nachlesen:
http://www.br-online.de/wissen/wespen-insekten-gedaechtnis-ID1222248824405.xml
Eine derartige Speicherfunktion zu integrieren, ist mit Hilfe der OOP ein Kinderspiel!
Hier eine Möglichkeit (Code in Auschnitten):
public class MeinePowerAmeise : Ameise {
//Gedächtnis Speicher
private Zucker zumerkenderZucker;
.………………………………………………………………………………………………
public override void Sieht(Zucker zucker)
{
.…………………………………………………………………………………..
if (AktuelleLast == 0 && Typ == "Arbeiter")
{
zumerkenderZucker = zucker;//Hier wird der Zucker gespeichert
GeheZuZiel(zucker);
}
}
.…………………………………………………………………………
public override void Tick()
{
.……………………………………………………………………………………
//Wenn ein Zuckerberg leer ist, muss er aus dem Gedächtnis gelöscht werden
if (AktuelleLast==0 && zumerkenderZucker != null && Typ == "Arbeiter")
{
if (zumerkenderZucker.Menge

Um vergleichbare Ergebnisse zu bekommen, gilt in der AntMe!-Community ein
ehernes Gesetzt: Die public-Methoden und Felder, die man in der Profi-Version ja
verändern könnte, sind Tabu! Mehr noch: Es gilt als unfair, wenn man in diesen
class-Dateien Änderungen vornimmt. Das trifft sich gut, denn genau dies ist auch das
eiserne Gesetz der OOP: Was gekapselt ist, geht einen nichts an!
Allerdings gibt es selbst unter strengster Auslegung dieser Gesetze durchaus
Möglichkeiten, die Ameisen deutlich klüger zu machen, als es die Entwickler anfangs
vorgesehen hatten. Das Stichwort dazu heißt static.
Globales Gedächtnis und ArrayList
Im letzten Programmentwurf hatte jede einzelne Ameise ein Gedächtnis. In der
Sprache der Objektorientierung: Die Daten, die im Heap für die einzelnen Objekte
gespeichert sind, könnnen von den anderen Objekten (Ameisen) nicht gelesen
werden.
Weiter oben haben Sie bereits eine static-Methoden verwendet:
public static int BestimmeEntfernung(IKoordinate o1, IKoordinate o2)
Hier ging es darum, dass die Methode BestimmeEnfernung nicht etwa auf eine
Adresse im Heap zeigen soll, sondern dass der entsprechende Wert (value) im Stack
abgelegt wird. Obwohl prinzipiell möglich, wird dieser Wert nach seiner Nutzung nicht
weiter gespeichert. Der Garbage-Collector sorgt für eine schnelle Entsorgung.
Was wäre aber, wenn man die von einem Ameisen-Objekt gefundenen Orte für Käfer
oder Obst in einem public-static-Feld abspeichert? Dann können alle anderen
Ameisen die Daten dort lesen und gegebenenfalls auch korrigieren! Auf die Realität
übertragen würde dies bedeuten, dass die Ameisen über ein sofort verfügbares
globales Gedächtnis verfügen, etwa so wie ein großer Teil Menschheit durch das
Internet. Biologisch sinnvoll oder nicht (man kann sich ja vorstellen, dass die
Ameisen auch über gewisse Distanzen kommunizieren können), - wir werden diese
Technik nutzen. Unsere Einschränkung, dass Gedächtnis nur maximal 500 Spieltakte
bestehen zu lassen, ist nicht ganz uneigennützig: Käfer und Obst bleibt ja nicht an
einem Ort stehen. So würde das globale Gedächtnis, dass von allen Ameisen
gefüttert wird, sehr schnell so groß, dass seine Verwaltung auf dem RAM auch
schnelle Rechner an den Rande der Leistungsfähigkeit bringen würde.
In einem ersten Versuch soll eine „Killerameisen“-Population erschaffen werden: Die
Ameisen konzentrieren sich ausschließlich aufs Töten von Käfern. Ein toter Käfer
bringt 150 Punkte. Daher ist mit der globalen Gedächtnis-Methode ein respektables
Ergebnis zu erwarten. Als Speicher soll uns eine ArrayList dienen.
Interface
In der .NET -Hilfe bekommt man zu ArrayList die Information, dass es sich dabei um
eine Klasse handelt, die das IList-Interface unter Verwendung eines dynamischen
Arrays implementiert. Alles klar?!? Vermutlich nicht. Daher zunächst die Frage:
36

Was ist ein Interface (auch Schnittstelle genannt)?
Am besten stellen Sie sich ein Interface als eine Klasse ohne Felder und ohne
Implementierungen vor. Vermutlich denken Sie dabei an die abstrakten Klassen
(1.Kapitel). Das dies nicht korrekt ist, wird Ihnen klar, wenn Sie sich daran erinnern,
dass abstrakte Klassen sehr wohl Implementierungen von Eigenschaften und
Methoden enthalten können. Weitere spezifischen Eigenheiten eines Interface (im
Vergleich mit abstrakten Klassen):
• In Interfaces sind immer alle Eigenschaften und Methoden abstract und
public. In abstrakten Klassen kann es beispielsweise auch private geben.
• In Interfaces kann es, wie schon gesagt, keine Felder geben. In
abstrakten Klassen ist dies nicht der Fall.
• Damit eine Klasse von einer abstrakten Klasse erben kann, muss sie die
abstrakte Klasse irgendwo als Vorfahr haben (also davon abgeleitet sein).
Im Gegensatz dazu kann man viele verschiedene Interfaces in einer
Klasse impelementieren.
Ein Beispiel zum letzten Punkt:
In AntMe! gibt es die Klasse Nahrung und die Klasse Insekt. Sie sind nicht
voneinander abgeleitet. So verschieden die beiden Klassen auch sein mögen, -
beide haben das Interface IKoordinate implementiert, weil beide Klassen in den
erzeugten Objekten Orts-Koordinaten benötigen.
Es gibt also bei den Interfaces Eigenschaften und Methoden, - diesen fehlt aber der
Anweisungsblock, bzw. der set- und get-Teil der Eigenschaften. Der Zweck eines
Interface besteht offensichtlich darin, dass es von mehreren nicht voneinander
abgeleiteten Klassen implementiert wird. Betrachten wir als Beispiel das Interface
IKoordinate aus AntMe!
public interface IKoordinate ///Deklaration des Interface
{
/// Liest die Koordinate eines Objekts auf dem Spielfeld aus.
Koordinate Koordinate { get; }
}
public struct Koordinate ///Hier beginnt die Klassendefinition
{
private int radius;
private int richtung;
private int x;
private int y;
.……………....………………………………………………………………….
internal Koordinate(int x, int y, int radius, int richtung)
{
this.x = x * Spiel.SPIELFELD_EINHEIT;
this.y = y * Spiel.SPIELFELD_EINHEIT;
37

In diesem Konstruktor werden alle Werte der Struktur initialisiert
// im Anschluß gleich wieder überschrieben:
this.radius = 0;
this.richtung = 0;
Radius = radius * Spiel.SPIELFELD_EINHEIT;
Richtung = richtung;
}
.…………………………………………………………………………………….
Das war die Deklaration. Wie wird IKoordinate implementiert? Hier am Beispiel der
Klasse Nahrung Nahrung (also den Zucker und das Obst). Sie verwendet
IKoordinate. Ein Auszug aus der Klasse:
:
public abstract class Nahrung : IKoordinate ///Implementierung des Interface
{
/// Die Position der Nahrung auf dem Spielfeld.
protected Koordinate koordinate;
}
/// Eigenschaft dazu:
public Koordinate Koordinate
{
get { return koordinate; }
internal set { koordinate = value; }
}
// Zuckerhaufen
public sealed class Zucker : Nahrung
{
/// Zucker Konstruktor.
internal Zucker(Koordinate koordinate, int menge)
: base(koordinate, menge) {}
.}………………………………………………………………………………………..
(Der Zugriffsmodifizierer sealed bedeutet, dass von dieser Klasse nicht geerbt
werden kann).
Halten wir fest: Die Schnittstellen werden durch das Schlüsselwort interface
implementiert, gefolgt vom Namen der Schnittstelle, der mit einem I beginnen sollte.
Wie Sie sehen können, muss die implementierende Klasse (z.B. Nahrung) selbst für
die Definionen der Methoden und Eigenschaften sorgen.
Der Vorteil: Wenn man weiß, dass eine Klasse ein bestimmtes Interface
implementiert, dann weiß man sofort, dass sie die Methoden und Eigenschaften aus
dem Interface zur Verfügung stellt!
38

An die Koordinaten der Nahrung kommt man nicht direkt. (Sie sind private definiert).
Nahrung wie Zucker oder Obst haben aber das Interface IKoordinate implementiert,
also kann man zumindest eine Referenz auf die Ortskoordinaten bekommen. Man
muss, wie Sie bald sehen werden, die absoluten Zahlen für den Ort überhaupt nicht
kennen. Man muss nicht einmal wissen, ob kartesische oder Polarkoordinaten
verwendet werden.
Jetzt verstehen Sie den weiter oben schon zitierten Programm-Code aus der Klasse
Koordinaten besser:
public static int BestimmeEntfernung(IKoordinate o1, IKoordinate o2)
{
return BestimmeEntfernung(o1.Koordinate, o2.Koordinate);
}
Hier wird mittels des Interface IKoordinate die Methode BestimmeEnfernung
implementiert. So kann jede Klasse, die IKoordinate verwendet, die Entfernung
zwischen zwei konkreten Objekten bestimmen. Dabei spielt es keine Rolle, ob die
Objekte o1 und o2 aus der gleichen Klasse stammen. Denkbar wäre zum Beispiel,
dass o1 die Ameise Frida und o2 der Käfer Willibald ist.
Zurück zu unserem Ausgangsproblem:
ArrayList ist also eine Klasse mit dem Interface IList. Damit hat man in der ArrayList
alle Eigenschaften und Methoden von IList, wie beispielsweise die Sort()-Methode.
Ein dynamischer Array ist einfach eine Liste von Daten, deren Länge nicht von
vornherein festgelegt ist.
ArrayList testen
Damit Sie dies alles auch gut nachvollziehen können, programmieren wir nun eine
Oberfläche zur Speicherung, Sortierung, Ausgabe und Löschung von Strings.
So soll sie aussehen:
39

Zunächst erzeugen wir eine Klasse namens ListeArrayList.cs, die man auch
String-Speicher Liste hätte nennen können.
class ListeArrayList
{
private static ArrayList stringListe = new ArrayList();
public static ArrayList StringListe //Eigenschaft
{
get { return stringListe;}
}
public static void StringSpeichern(string zeichenfolge)
{
stringListe.Add(zeichenfolge);
}
public static void StringLoeschen(string zeichenfolge)
{
stringListe.Remove(zeichenfolge);
}
public static string GibString(int nummer)
{
if (nummer

Aufgabe 6
Erstellen Sie die Oberfläche der ArrayList-Studie (siehe oben). Schreiben Sie mit
Hilfe der ListeArrayList für anderen Buttons die Click-Ereignisse.
Testen Sie das Programm ausführlich, so dass Sie in der Lage sind, folgende Fragen
zu beantworten:
• Welchen Index hat das erste Listenelement?
• Wie werden die Strings beim Drücken auf den entsprechenden Button
sortiert?
• Kann man auch leere Strings speichern? Wenn ja, was zeigt dann das
Textfeld an, wenn man den leeren String wieder ausgibt?
• Entspricht ein nicht belegter Speicherplatz einem leeren String?
• Weshalb ist die if-Abfrage in der GibString-Methode von ListeArrayList nötig?
• Wenn beispielsweise der 10-te String in der Liste gelöscht wird, was passiert
dann mit dem vormals 11-ten?
(Eine mögliche Lösung finden Sie am Kapitelende)
Einen wesentlichen Unterschied zur Ortsspeicher-Klasse in AntMe! gibt es hier
allerdings: In der ListeArrayList werden Strings auf den Speicherplätzen abgelegt.
In der Ortsspeicher-Klasse werden wir Käfer-Objekte (und später Obst- und Zucker-
Objekte) platzieren. Das bedeutet, dass auf den jeweiligen Plätzen der ArrayList nur
Referenzen zu den Objekten im Heap gespeichert werden. Zeigt eine Referenz ins
Leere, so bekommt man hier das Ergebnis null zurück.
(Streng genommen werden auch bei den Strings nur Referenzen abgespeichert. Würde man eine
Liste bestehend aus Integer erzeugen, so werden diese dann tatsächlich als Wert in den einzelnen
Listenelementen abgelegt. String: Call by reference, Integer; Call by value)
41

Die Klasse Ortsspeicher
Nun wollen wir endlich zu unseren Killer-Ameisen kommen. Wie oben wird zunächst
eine Klasse erzeugt, die das globale Gedächtnis speichern soll. Wir werden sie
Ortsspeicher nennen:
using System.Collections;
namespace AntMe.Spieler
{
class Ortsspeicher
{
private static ArrayList käferOrt = new ArrayList();
} }
private static ArrayList geloeschterOrt = new ArrayList();
public static ArrayList KäferOrt // Eigenschaft
{
get { return käferOrt; }
}
public static int Schleifenzaehler = 0;
public static ArrayList GeloeschterOrt // Eigenschaft
{
get { return geloeschterOrt; }
}
public static void OrtSpeichern(IKoordinate ort) // Eigenschaft
{
if (ort != null)
{
if (! käferOrt.Contains(ort) && ! geloeschterOrt.Contains(ort))
KäferOrt.Add(ort);
}
}
public static void OrtLoeschen(IKoordinate ort) // Eigenschaft
{ käferOrt.Remove(ort); geloeschterOrt.Add(ort);}
public static Käfer LiesKäfer(int i) // Eigenschaft
{
if (käferOrt.Count >= i+1)
{
IKoordinate ort = (IKoordinate) käferOrt[i] ; //unboxing
return (ort as Käfer);
}
return null;
}
42

Einige Kommentare zu diesem Code:
• Wir benötigen zwei ListArrays, kaeferOrt, geloeschterOrt, weil die vernichteten
Käfer in der ersten Liste gestrichen und in der zweiten Liste hinzugenommen
werden. Damit kann eine Ameise, die auf dem Weg zu einem nicht mehr
existierenden Käfer in der geloeschterOrt-Liste feststellen kann, dass sie sich
neuen Aufgaben widmen kann.
• Die public static Integer-Variable Schleifenzaehler soll später zum Zählen der
Spielrunden verwendet werden. (4500 Runden dauert ein Spiel).
• Die Eigenschaft Ortspeichern nimmt eine Variable ort entgegen, die
IKoordinate kennt. Natürlich soll sie nur dann gespeichert werden, wenn sie
weder in der kaeferOrt-Liste bereits steht, noch in der geloeschterOrt-Liste
eingetragen ist. Frage: Woher kennt käferOrt eigentlich Remove() bzw Add() ?
• Die LiesKäfer-Eigenschaft soll im folgenden Theorieteil etwas genauer unter
die Lupe genommen werden.
Boxing und unboxing
Betrachten Sie folgenden Code:
int i = 25; // ein value type
object o = i; // boxing (implizit)
int j = (int)o; // unboxing
In der ersten Zeile wird eine Integerzahl (Typ value)
auf den Stack gelegt. In der zweiten Zeile wird durch
eine Technik, die man boxing nennt, eine Kopie
dieser Zahl unter dem Namen o in den Heap
befördert (Typ reference). Dort fristet das neue Objekt
sein Dasein in stetiger Erwartung auf den Garbage-
Collector. Und dieser kommt besonders schnell, wenn
das Objet o durch unboxing unter dem Namen j in
den Stack gelegt wird. Das Ganze ist auch durch den
Begriff Typenkonvertierung hinreichend erklärt. Das
Bild rechts stammt von der msdn-Hilfeseite:
In der Zeile return (ort as Käfer); findet durch as ebenfalls eine Typenkonvertierung
statt. ort ist ja zunächst nur ein Objekt, das IKoordinate kennt. Durch diese Zeile wird
der Typ festgelegt. (Es gibt übrigens noch Ameisen-, Obst- und Zucker-Objekte!)
Zurück zum Spiel. Bisher haben wir lediglich dafür gesorgt, dass alle Ameisen auf
das globale Gedächtnis zugreifen können. Sie haben dort Lese- und Schreibrechte.
Alle Ameisen zu Kämpfern zu machen, ist sicher nicht günstig, denn man kann die
Eigenschaften der Ameisen ja immer nur in bestimmten Bereichen verbessern, um
sie in anderen zu verschlechtern. Was unsere Kampf-Ameisen auf jeden Fall
benötigen, ist ein maximaler Angriffsmodifikator (2) und möglichst etwas mehr als
durchschnittliche Energie(1). Ein Vorschlag für die Kämpfer:
43

Kämpferameisen mit globalem Gedächtnis
Name = "Kämpfer",
GeschwindigkeitModifikator = 0,
DrehgeschwindigkeitModifikator = -1,
LastModifikator = -1,
ReichweiteModifikator = -1,
SichtweiteModifikator = 0,
EnergieModifikator = 1,
AngriffModifikator = 2
Die Sichtweite kann man nicht auch noch erhöhen, - dabei ist gerade sie wichtig, um
möglichst schnell viele Käfer in den globalen Speicher schreiben zu können.
Deshalb werden wir eine zweite Art erzeugen, da reichen sicher 6 – 10 Exemplare,
die Spione. Sie haben einzig und allein die Aufgabe, Käfer zu finden und zu
speichern:
Name = "Spion",
GeschwindigkeitModifikator = 1,
DrehgeschwindigkeitModifikator = 0,
LastModifikator = -1,
ReichweiteModifikator = 0,
SichtweiteModifikator = 2,
EnergieModifikator = -1,
AngriffModifikator = -1
Damit ist es nicht getan! Schließlich sollte eine Ameise die Spielrunden zählen. Dabei
sollte sie aber möglichst nicht von Käfern gefressen werden. Eine Ameise dieser Art
reicht. Wir nennen sie Chronos:
Name = "Chronos",
GeschwindigkeitModifikator = 2,
DrehgeschwindigkeitModifikator = 0,
LastModifikator = 0,
ReichweiteModifikator = 0,
SichtweiteModifikator = -1,
EnergieModifikator = 0,
AngriffModifikator = -1
Die angegebenen Werte sollten Sie nicht als Dogma sehen. Es kann lohnend sein,
damit zu experimentieren.
So erzeugen wir jetzt die Ameisen:
public static string BestimmeTyp(Dictionary anzahl)
{
if (anzahl["Chronos"] < 1) { return "Chronos"; }
if (anzahl["Spion"] < 6) { return "Spion"; }
else { return "Kämpfer"; }
}
Auch hier sollten Sie mit der Anzahl der Spione experimentieren.
Die Methoden Sieht(Käfer käfer) und WirdAngegriffen(Käfer käfer) können gleich
gestaltet werden. Ein Vorschlag:
44

switch (Typ)
{
case "Spion":
{
Ortsspeicher.OrtSpeichern(käfer);
GeheWegVon(käfer);
}
break;
case "Kämpfer":
{
Ortsspeicher.OrtSpeichern(käfer);
GreifeAn(käfer);
}
break;
}
case "Chronos":
{
GeheWegVon(käfer); //Falls ein böser Käfer in den Bau kommt!
}
break;
Sie erinneren sich: In jeder Spielrunde wird das Tick-Ereignis aufgerufen. Hier
erreichen wir die Ameisen immer und können ihnen daher sehr genau mitteilen, wie
sie sich zu verhalten haben. Wie oben unterscheiden wir die Typen durch einen
switch-case-Block.
Beginnen wir mit den Spionen:
case "Spion":
{
if (Reichweite - ZurückgelegteStrecke - 150 < EntfernungZuBau)
GeheZuBau();
if (AktuelleEnergie < MaximaleEnergie * 2 / 3)
GeheZuBau();
}
break;
Auf diese Weise sorgen wir dafür, dass uns diese wertvolle Spezies nicht dezimiert
wird.
Zu Chronos:
case "Chronos":
{
Ortsspeicher.Schleifenzaehler++;
if (Ortsspeicher.Schleifenzaehler % 500 == 0)//Gedächtnis hält 500 Runden!
{ Ortsspeicher.KäferOrt.Clear(); Ortsspeicher.GeloeschterOrt.Clear(); }
if (EntfernungZuBau > 32) { GeheZuBau(); }
else { BleibStehen(); }
BleibStehen();
}
break;
Der Ameisenbau hat einen Radius von 32 Einheiten. Daher kann Chronos innerhalb
dieses Radius ruhig stehen bleiben.
45

Schließlich und endlich zu den Kämpfern. Wir wollen verhindern, dass eine Ameise,
die auf der anderen Seite des Spielfeldes steht, einen Angriff auf den viel zu weit
entfernten Käfer startet. Mehr noch: Die Kämpfer-Ameisen sollen alle vorhandenen
Käfer in der Liste prüfen, und zu dem laufen, der am nächsten ist:
case "Kämpfer":
{
if (Ziel == null && Ortsspeicher.KäferOrt.Count > 1)
//Ameise hat kein Ziel und die "Gedächtnisdatenbank" ist nicht leer
{
int entfernung = 2000; int entfernungVariabel = 2000;
int indexMin = 0;
for (int i = 0; i < 60; i++)
{
Käfer käfer0 = Ortsspeicher.LiesKäfer(i);
Aufgabe 7
}
}
if (käfer0 == null) //Käfer0 existiert nicht oder ist zwischenzeitlich gestorben!
Ortsspeicher.OrtLoeschen(käfer0);
else
{
entfernungVariabel = Koordinate.BestimmeEntfernung(this, käfer0);
if (entfernung > entfernungVariabel)
{
entfernung = entfernungVariabel;
indexMin = i;
}
}
käfer0 = null;
Käfer käfer1 = Ortsspeicher.LiesKäfer(indexMin);
if ((!(käfer1 == null)) && (!Ortsspeicher.GeloeschterOrt.Contains(käfer1)) &&
(Koordinate.BestimmeEntfernung(this, käfer1) < 700))
{ GeheZuZiel(käfer1); }
//Letzte Bedingung: Ameise sollte nicht zu weit weg vom Käfer sein.
GeheGeradeaus(50);//sonst bleiben sie nach der Jagd stehen!
if (Reichweite - ZurückgelegteStrecke - 100 < EntfernungZuBau)
GeheZuBau();
if (AktuelleEnergie < MaximaleEnergie * 2 / 3)
GeheZuBau();
}
break;
• Versuchen Sie, die Tick()-Anweisungen für die drei Ameisen-Typen
nachzuvollziehen. Wo könnten andere Werte getestet werden. Sehen Sie
weitere Möglichkeiten der Optimierung?
• Vervollständigen Sie mit den obigen Vorgaben die Vorlage.cs , die Sie in
Kämpfer.cs umtaufen.
46

• Testen Sie die Kämpferameisen!
Da können einem die Käfer
schon fast leid tun!!!
Bis zu 45-46 erledigte Käfer
sind so zu erreichen, das
heißt, man kommt auf fast
7000 Punkte! Und das ohne
Nahrung zu sammeln….
(Interessantes Detail am
Rande: Wenn man die
Simulation in Zeitraffer
ablaufen lässt, dann erkennt
man, dass immer dann,
wenn die Ameisen ein
Käfer-Ziel ansteuern, die
Geschwindigkeit deutlich
höher ist, als wenn sie
gerade ziellos umherlaufen.
Haben Sie eine Idee, woran
das liegen könnte?)
Kämpfer und Arbeiter mit globalem Gedächtnis
Ganz ohne Nahrungssammler kann ein Ameisenvolk nicht überleben. Man kann sich
vorstellen, dass das Volk nur überlebt, wenn mindestens 10 000 Punkte erreicht
werden. Also müssen wir mehr als diese 10 000 Punkte erreichen.
Ein erster Schritt wird sein, Chronos das Löschen des Gedächtnisses zu verbieten.
Dies war ja eine freiwillige Einschränkung.
Dann erzeugen wir eine neue Sorte für das Sammeln von Nahrung: Die Arbeiter!
[Typ(
Name = "Kämpfer",
GeschwindigkeitModifikator = 0,
DrehgeschwindigkeitModifikator = -1,
LastModifikator = -1,
ReichweiteModifikator = -1,
SichtweiteModifikator = -1,
EnergieModifikator = 2,
AngriffModifikator = 2
)]
47

[Typ(
Name = "Spion",
GeschwindigkeitModifikator = 1,
DrehgeschwindigkeitModifikator = 0,
LastModifikator = -1,
ReichweiteModifikator = 0,
SichtweiteModifikator = 1,
EnergieModifikator = 0,
AngriffModifikator = -1
)]
[Typ(
Name = "Chronos",
GeschwindigkeitModifikator = 2,
DrehgeschwindigkeitModifikator = 0,
LastModifikator = 0,
ReichweiteModifikator = 0,
SichtweiteModifikator = -1,
EnergieModifikator = 0,
AngriffModifikator = -1
)]
[Typ(
Name = "Arbeiter",
GeschwindigkeitModifikator = 2,
DrehgeschwindigkeitModifikator = -1,
LastModifikator = 2,
ReichweiteModifikator = -1,
SichtweiteModifikator = 0,
EnergieModifikator = -1,
AngriffModifikator = -1
)]
Die Arbeiter müssen schnell sein und viel tragen können. Wieviele Arbeiter und
wieviele Kämpfer man erzeugen soll, muss man ausprobieren. Hier ein Vorschlag:
public static string BestimmeTyp(Dictionary anzahl)
{
if (anzahl["Chronos"] < 1) { return "Chronos"; }
if (anzahl["Spion"] < 5) { return "Spion"; }
if (anzahl["Arbeiter"] < 60) { return "Arbeiter"; }
if (anzahl["Kämpfer"] < 34) { return "Kämpfer"; }
else { return "Arbeiter";
}
Damit der Code gut lesbar wird, erzeugen wir für jeden Ameisentyp eine eigene
Klasse. Das spezifische Wartet()- und Tick()-Ereignis kann man dann dort
unterbringen.
Beginnen wir mit der Chronos Klasse:
48

class Chronos
{
public static void Wartet(Ameise ameise)
{
if (Ortsspeicher.daheim == null)
{
ameise.GeheZuBau();
Ortsspeicher.daheim = ameise.Ziel;
ameise.BleibStehen();
}
}
}
Der Wartet()-Abschnitt muss erklärt werden:
Wir wollen die Arbeiter später immer den Zuckerhaufen oder das Obst auswählen
lassen, dass die geringste Entfernung zum Bau hat. So ohne Weiteres verrät das
Interface IKoordinate diesen Ort aber nicht. Daher fügen wir in der Klasse
Ortsspeicher eine IKoordinate daheim an.
public static IKoordinate daheim;
Aus den weiter oben schon erläuterten Gründen muss daheim public und static sein.
Wenn Chronos wartet und daheim noch unbekannt ist, dann lässt man sie mit
ameise.GeheZuBau() zum Bau laufen. Auch wenn sie schon dort ist, kann man jetzt
das Ziel (den Bau) abgreifen und eine Kopie davon, die sich mit daheim aufrufen
lässt, für die weitere Verwendung in den Heap legen.
In der allgemeinen Klasse Allgemein_GedächtnisWahl muss der Wertet()-Abschnitt
dann nur auf die zugehörige Klasse verweisen:
public override void Wartet()
{
switch (Typ)
{
case "Spion":
{
Spion.Wartet(this);
}
break;
case "Kämpfer":
{
Kämpfer.Wartet(this);
}
break;
case "Chronos":
{
Chronos.Wartet(this);
49

}
}
break;
case "Arbeiter":
{
Arbeiter.Wartet(this);
}
break;
}
(Auch wenn dort kein Code für das Wartet()-Ereignis ausgeführt wäre, führt der obige
Aufruf zu keiner Fehlermeldung.)
Und so wartet die Spion-Klasse:
public static void Wartet(Ameise ameise)
{
ameise.GeheGeradeaus(100);
ameise.DreheUmWinkel(Zufall.Zahl(-20, 20));
}
Die konkreten Zahlen (100 und 20) sind ziemlich willkürlich und sollten unbedingt
optimiert werden!
Das Warten()-Ereignis der Arbeiter:
public static void Wartet(Ameise ameise)
{
if (ameise.EntfernungZuBau > 400) //außerhalb gibt es keine Nahrung!
{
ameise.GeheZuBau();
}
}
Aufgabe 8
Schreiben Sie in die allgemeine Klasse Allgemein_GedächtnisWahl die Ereignisse
mit Parameter Sieht(Zucker zucker) , Sieht(Obst obst) und Sieht(Käfer käfer).
Gleichgültig welcher Ameisentyp etwas sieht, immer sollen die Koordinaten des
gesehenen Objekts in der Liste gespeichert werden.
Bei Sieht(Käfer, käfer) muss man bedenken, dass Chronos- und Spionameisen
möglichst schnell fliehen sollten. Die Kämpferameisen hingegen greifen sofort an.
(Eine mögliche Teil-Lösung am Ende des Kapitels)
In der gleichen Klasse sollten noch zwei Ereignisse, die in der reinen Kämpferkolonie
unnötig waren, festgelegt werden:
public override void ZielErreicht(Zucker zucker)
{
50

}
Nimm(zucker);
GeheZuBau();
Entsprechend muss man dies auch beim Obst so festlegen.
Kommen wir zu den Tick()-Ereignissen der verschiedenen Klassen:
Bei Chronos, Spion und Kämpfer wurde nichts Wesentliches verändert, sieht man
einmal davon ab, dass Chronos jetzt erst nach 2000 Spielzügen den Käfer-Speicher
löscht. Obst- und Zucker-ArrayList löschen wir hier nicht während eines Spiels.
Bei Arbeiter-Ameisen allerdings müssen wir doch etwas mehr nachdenken, damit
genügend Obst und Zucker in den Bau getragen wird:
• Diejenigen Zuckerhaufen und Obststücke, die näher am Bau liegen als
andere, sollen zuerst abgetragen werden.
• Mehr als fünf Ameisen sollten nicht als Träger für ein Obststück abgeordnet
werden. Die Arbeit wird durch mehr als fünf Träger nämlich nicht schneller
erledigt.
Hier eine Möglichkeit dies zu realisieren:
public static void Tick(Ameise ameise)
{
if (ameise.Reichweite - ameise.ZurückgelegteStrecke - 50 < ameise.EntfernungZuBau)
ameise.GeheZuBau();
if (ameise.AktuelleEnergie < ameise.MaximaleEnergie * 2 / 3)
ameise.GeheZuBau();
if (ameise.Ziel == null)
{
int entfernungZumBau = 2000; int entfernungZumBauVariabel = 2000;
int indexMin = 0;
if (Ortsspeicher.ZuckerOrt.Count > -1)
{
for (int i = 0; i < 20; i++)
{
Zucker zucker0 = Ortsspeicher.LiesZucker(i);
if ((zucker0 == null) || (zucker0.Menge < 15))
{
Ortsspeicher.OrtLoeschen(zucker0);
}
else
{
entfernungZumBauVariabel = Koordinate.BestimmeEntfernung(Ortsspeicher.daheim, zucker0);
if (entfernungZumBau > entfernungZumBauVariabel)
{
entfernungZumBau = entfernungZumBauVariabel;
51

}
}
}
}
}
indexMin = i;
zucker0 = null;
Zucker zucker1 = Ortsspeicher.LiesZucker(indexMin);
if ((ameise.AktuelleLast == 0) && (zucker1 != null))
{
ameise.GeheZuZiel(zucker1);
}
if (Ortsspeicher.ObstOrt.Count > -1)
{
for (int i = 0; i < 20; i++)
{
Obst obst0 = Ortsspeicher.LiesObst(i);
if ((obst0 == null) || (!ameise.BrauchtNochTräger(obst0)))
{
Ortsspeicher.OrtLoeschen(obst0);
}
else
{
entfernungZumBauVariabel = Koordinate.BestimmeEntfernung(Ortsspeicher.daheim, obst0);
if (entfernungZumBau > entfernungZumBauVariabel)
{
entfernungZumBau = entfernungZumBauVariabel;
indexMin = i;
}
}
obst0 = null;
}
Obst obst1 = Ortsspeicher.LiesObst(indexMin);
if ((ameise.AktuelleLast == 0) && (obst1 != null) )
{ ameise.GeheZuZiel(obst1);
Ortsspeicher.n[indexMin] = Ortsspeicher.n[indexMin] + 1;
}
if (Ortsspeicher.n[indexMin] > 4)
{
Ortsspeicher.OrtLoeschen(obst1);
Ortsspeicher.n[indexMin] = Ortsspeicher.n[indexMin+1] ;
Ortsspeicher.n[indexMin + 1] = Ortsspeicher.n[indexMin + 2];
Ortsspeicher.n[indexMin + 2] = Ortsspeicher.n[indexMin + 3];
Ortsspeicher.n[indexMin + 3] = Ortsspeicher.n[indexMin + 4];
Ortsspeicher.n[indexMin + 4] = Ortsspeicher.n[indexMin + 5];
}
}
}
52

Aufgabe 9
• Welche Aufgabe hat daheim, wozu dient int[ ] n ?
public static IKoordinate daheim;
public static int[ ] n = new int[ ] { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,.….
• In welchen Fällen werden die ListArrays von Zuckerort, Obstort und Käferort
gelöscht?
• Versuchen Sie den obigen Programmcode nachzuvollziehen.
• Experimentieren Sie mit den Vorgaben. Vielleicht erreichen Sie ja dann mehr
als 15960 Punkte!
Was man noch tun könnte…
Hier endet Kapitel 5.02. Das heißt aber nicht, dass es nichts mehr zu tun gäbe! Wenn
Sie weitermachen wollen, hier einige Vorschläge:
• Die eigenen Ameisen auf AntMe! Version 1.6 umschreiben. Dort gibt es außer
Käfern noch Wanzen, die den armen Ameisen zusetzten. Auch die Punktevergabe
setzt etwas andere Akzente.
• Ein eigenes Plugin schreiben.
• Die Netzversion verwenden, um Ihre Ameisen auch gegen Konkurenten fit zu
machen.
Ideen und Anregungen bekommt man auf der Seite von AntMe! : http://antme.net/
53

Lösungen
Lösung von Aufgabe 2:
public override void Sieht(Obst obst)
{
if (AktuelleLast == 0 && BrauchtNochTräger(obst))
{
GeheZuZiel(obst);
}
}
public override void ZielErreicht(Obst obst)
{
Nimm(obst);
GeheZuBau();
}
Lösung von Aufgabe 3:
public override void Sieht(Käfer käfer)
{
if (AktuelleLast > 0) LasseNahrungFallen();
if (AnzahlInSichtweite > 5) GreifeAn(käfer);
else GeheWegVon(käfer, 80);
}
Lösung von Aufgabe 6:
private void loeschen_button_Click(object sender, EventArgs e)
{
string Zeichenfolge = textBox2.Text;
ListeArrayList.StringLoeschen(Zeichenfolge);
}
private void ausgabe_button_Click(object sender, EventArgs e)
{
int n = Convert.ToInt32(textBox3.Text);
string Zeichenfolge = ListeArrayList.GibString(n);
textBox4.Text = Zeichenfolge;
}
private void button4_Click(object sender, EventArgs e)
{
ListeArrayList.StringListe.Clear();
}
54

private void sortieren_button_Click(object sender, EventArgs e)
{
ListeArrayList.StringListe.Sort();
}
private void anzahl_button_Click(object sender, EventArgs e)
{
int n = ListeArrayList.StringListe.Count;
textBox3.Text = Convert.ToString(n);
}
Teillösung von Aufgabe 8:
public override void Sieht(Zucker zucker)
{
switch (Typ)
{
case "Spion":
{
Ortsspeicher.OrtSpeichern(zucker);
}
break;
}
}
case "Kämpfer":
{
Ortsspeicher.OrtSpeichern(zucker);
}
break;
case "Arbeiter":
{
Ortsspeicher.OrtSpeichern(zucker);
}
break;
55