/// <summary>
/// Diese Methode wird in jeder Simulationsrunde aufgerufen - ungeachtet von zusätzlichen
/// Bedingungen. Dies eignet sich für Aktionen, die unter Bedingungen ausgeführt werden
/// sollen, die von den anderen Methoden nicht behandelt werden.
/// Weitere Infos unter http://wiki.antme.net/de/API1:Tick
/// </summary>
public override void Tick()
{
if (this.Reichweite - this.ZurückgelegteStrecke - 9 < this.EntfernungZuBau)
{
//Die Anzahl an Ameisenschritten, die die Ameise noch zurücklegen kann - 9, ist kleiner als die Entfernung zum Bau
//Also gehen wir zum Bau, damit die Ameise nicht verhungert
this.GeheZuBauOptimized();
}
if (zielOptimized != null)
{
int distance = Koordinate.BestimmeEntfernung(this, zielOptimized);
if (distance < Sichtweite)
{
//Das Ziel befindet sich in Sichtweite. Nun wird von GeheZuZielOptimized wieder die GeheZuZiel-Methode gewechselt.
GeheZuZiel(zielOptimized);
//Hat unsere Ameise nur noch ein Ziel und das zielOptimized wird verworfen
zielOptimized = null;
}
else
{
//Das Ziel befindet sich noch nicht in Sichtweite. Erneut GeheZuZielOptimized aufrufen, damit sich die Ameise erneut auf das Ziel ausrichtet.
//Wenn unsere Ameise einen Apfel trägt und eine gegnerische Ameise ebenfalls an diesem Apfel zieht, kommen wir von unserem Weg ab
//und laufen gegen den Rand des Spielfeldes
GeheZuZielOptimized(zielOptimized);
}
}
}
/// <summary>
/// Wird einmal aufgerufen, wenn die Ameise eine Markierung des selben
/// Volkes riecht. Einmal gerochene Markierungen werden nicht erneut
/// gerochen.
/// </summary>
/// <param name="markierung">Die nächste neue Markierung.</param>
public override void RiechtFreund(Markierung markierung)
{
// Sollte die Ameise nicht schon Obst im Auge haben oder auf dem Weg zum
// Bau sein soll sie, wenn die angeforderte Menge Ameisen die Ameisenmenge
// der gerade in Sichtweite befindlichen Ameisen übersteigt, zum
// Markierungsmittelpunkt gehen um dort hoffentlich den Apfel zu sehen.
if (!(Ziel is Obst) &&
!(Ziel is Bau) &&
AnzahlAmeisenInSichtweite < markierung.Information)
{
GeheZuZiel(markierung);
// Sollte die Entfernung mehr als 50 schritte zum Mittelpunkt betragen,
// soll eine Folgemarkierung gesprüht werden um denn Effektradius zu
// erhöhen.
if (Koordinate.BestimmeEntfernung(this, markierung) > 50)
{
SprüheMarkierung(
Koordinate.BestimmeRichtung(this, markierung),
Koordinate.BestimmeEntfernung(this, markierung));
}
}
else
{
// In allen anderen Fällen soll sie kurz stehen bleiben um zu
// verhindern, dass die Ameise dem Apfel ewig hinterher läuft.
BleibStehen();
}
}
/// <summary>
/// Markierungen, die von anderen Ameisen platziert werden, können von befreundeten Ameisen
/// gewittert werden. Diese Methode wird aufgerufen, wenn eine Ameise zum ersten Mal eine
/// befreundete Markierung riecht.
/// </summary>
/// <param name="markierung">Die gerochene Markierung</param>
public override void RiechtFreund(Markierung markierung)
{
if (Kaste == "Attacker")
{
// Die Ameise soll, sofern sie nicht schon ein Ziel wie "Käfer", "Markierung" oder "Bau" hat auf direktem Weg zum laufen von wo aus man hoffentlich weitere Markierungen oder direkt den Käfer sieht.
if (Ziel == null)
{
GeheZuZiel(markierung);
}
}
if (Kaste == "Appler")
{
// Sollte die Ameise nicht schon Obst im Auge haben oder auf dem Weg zum Bau sein soll sie, wenn die angeforderte Menge Ameisen die Ameisenmenge der gerade in Sichtweite befindlichen Ameisen übersteigt, zum Markierungsmittelpunkt gehen um dort hoffentlich den Apfel zu sehen.
if (!(Ziel is Obst) &&
!(Ziel is Bau) &&
AnzahlAmeisenInSichtweite < markierung.Information)
{
GeheZuZiel(markierung);
// Sollte die Entfernung mehr als 50 schritte zum Mittelpunkt betragen, soll eine Folgemarkierung gesprüht werden um denn Effektradius zu erhöhen.
if (Koordinate.BestimmeEntfernung(this, markierung) > 50)
{
SprüheMarkierung(
Koordinate.BestimmeRichtung(this, markierung),
Koordinate.BestimmeEntfernung(this, markierung));
}
}
else
{
// In allen anderen Fällen soll sie kurz stehen bleiben um zu verhindern, dass die Ameise dem Apfel ewig hinterher läuft.
BleibStehen();
}
}
}
/// <summary>
/// Wird unabhängig von äußeren Umständen in jeder Runde aufgerufen.
/// </summary>
public override void Tick()
{
if (gemerkterZucker != null)
{
if (Ziel is Insekt)
{
int entfernung = Koordinate.BestimmeEntfernung(this, Ziel);
if (entfernung > Sichtweite * 3)
{
BleibStehen();
}
}
if (Kaste == "Wächter")
{
SprüheMarkierung
(Koordinate.BestimmeRichtung(this, gemerkterZucker),
Math.Min(Sichtweite, Koordinate.BestimmeEntfernung(this, gemerkterZucker)));
}
if (gemerkterZucker.Menge <= 0)
{
gemerkterZucker = null;
if (Kaste == "Wächter")
{
imKreisGehen = false;
aufEntfernungGehen = false;
}
}
}
}
private void btnDodajKoordinate_Click(object sender, EventArgs e)
{
KoordinateBasic k = new KoordinateBasic();
k.X_lin = Double.Parse(txtX.Text);
k.Y_lin = Double.Parse(txtY.Text);
DTOManager.dodajKoordinatu(k);
KoordinateBasic kb = DTOManager.vratiKoordinate(k.X_lin, k.Y_lin);
Koordinate ne = new Koordinate();
ne.Id = kb.Id;
ne.X_lin = kb.X_lin;
ne.Y_lin = kb.Y_lin;
lin.ListaKoordinata.Add(ne);
ListViewItem item = new ListViewItem(new string[]
{
k.X_lin.ToString(),
k.Y_lin.ToString(),
});
listViewKoordinate.Items.Add(item);
listViewKoordinate.Refresh();
}
/// <summary>
/// Wird unabhängig von äußeren Umständen in jeder Runde aufgerufen.
/// </summary>
public override void Tick()
{
// Markierungshandling.
if (Ziel is Bau &&
AktuelleLast > 0 &&
GetragenesObst == null &&
Kaste == "Sammler")
{
// Sammler, die mit Nahrung auf dem Rücken richtung Bau laufen sollen
// fortwährend Markierungen sprühen um eine Ameisenstrasse zu erzeugen.
if (Koordinate.BestimmeEntfernung(this, Ziel) < 100)
{
SprüheMarkierung(
Koordinate.BestimmeRichtung(Ziel, this),
100 - Koordinate.BestimmeEntfernung(Ziel, this));
}
else
{
SprüheMarkierung(
Koordinate.BestimmeRichtung(Ziel, this),
20);
}
}
// Sollten Kämpfer einen Käfer über größere Strecken verfolgen muss der
// Kampf iregendwann auch abgebrochen werden. Dies geschieht, wenn weniger
// als 3 Ameisen in der Nähe sind. Das sollte der Fall sein, wenn sich der
// Käfer nicht mehr in der Nähe einer Ameisenstrasse befindet.
if (Ziel is Wanze && AnzahlAmeisenInSichtweite < 3)
{
BleibStehen();
}
}
/// <summary>
/// So wie Ameisen unterschiedliche Nahrungsmittel erspähen können, entdecken Sie auch
/// andere Spielelemente. Entdeckt die Ameise eine Ameise aus einem feindlichen Volk,
/// so wird diese Methode aufgerufen.
/// Weitere Infos unter "http://wiki.antme.net/de/API1:SiehtFeind(Ameise)"
/// </summary>
/// <param name="ameise">Erspähte feindliche Ameise</param>
public override void SiehtFeind(Ameise ameise)
{
// ist die gegnerische Ameise voll beladen, wird sie verfolgt.
if (ameise.AktuelleLast == ameise.MaximaleLast)
{
if (ziel == null && GenaueBauKoordinaten == null)
{
ziel = ameise;
GeheZuKoordinate(HoleKoordinaten(ameise));
}
// Alle Sammler des Gegners werden von Spähern verfolgt
if (Kaste == "Späher")
{
if (ameise.AktuelleLast > 0)
{
GeheZuKoordinate(HoleKoordinaten(ameise));
}
}
// Wenn keiner Ameise zu helfen ist oder sie maximal 30 weg ist, greifen wir an
else if (Kaste == "Krieger" && (kriegerziel == null || (kriegerziel != null && Koordinate.BestimmeEntfernung(this, kriegerziel) < 30)))
{
if (ameise.AktuelleGeschwindigkeit < this.MaximaleGeschwindigkeit || ameise.AktuelleLast > 0)
{
this.Denke("Hasta la vista");
// dabei versuchen wir Laufwege zu kreuzen
FangeAb(ameise);
if (Koordinate.BestimmeEntfernung(ameise, this) < 20)
{
GreifeAn(ameise);
}
}
}
}
}
// Zuckerhaufen erneuerung
public static void zucker_sort()
{
// Leere löschen
for (int i = 0; i < zucker_list.Count() - 1; i++)
{
if (zucker_list[i].Menge <= 0)
{
zucker_list.Remove(zucker_list[i]);
}
}
int count = zucker_list.Count();
Zucker zucker_alt;
for (int runde = 0; runde < count; runde++)
{
for (int i = 0; i < count - 1; i++)
{
if (Koordinate.BestimmeEntfernung(bau, zucker_list[i]) > Koordinate.BestimmeEntfernung(bau, zucker_list[i + 1]))
{
// tauschen
zucker_alt = zucker_list[i];
zucker_list[i] = zucker_list[i + 1];
zucker_list[i + 1] = zucker_alt;
}
}
}
// aktuellen leeren falls leer
if (akt_zucker.Menge == 0)
{
akt_zucker = null;
}
}
/// <summary>
/// Wird wiederholt aufgerufen, wenn die Ameise mindestens einen
/// Zuckerhaufen sieht.
/// </summary>
/// <param name="zucker">Der nächstgelegene Zuckerhaufen.</param>
public override void Sieht(Zucker zucker)
{
switch (Kaste)
{
case "Kundschafter":
GeheZuZiel(zucker);
break;
case "Sammler":
if (Ziel == null)
{
GeheZuZiel(zucker);
}
break;
case "Krieger":
if (!verteidigen)
{
verteidigen = true;
int richtung = Koordinate.BestimmeRichtung(this, zucker);
entfernung = Koordinate.BestimmeEntfernung(this, zucker) * 3;
// Der Winkel führt dazu, daß die Krieger sternförmig um den Zucker
// patroullieren.
winkel = Zufall.Zahl(180, 215);
DreheInRichtung(richtung);
GeheGeradeaus(entfernung);
}
break;
}
}
/// <summary>
/// Wird einmal aufgerufen, wenn die Ameise eine Markierung des selben
/// Volkes riecht. Einmal gerochene Markierungen werden nicht erneut
/// gerochen.
/// </summary>
/// <param name="markierung">Die nächste neue Markierung.</param>
public override void RiechtFreund(Markierung markierung)
{
switch (Kaste)
{
case "Sammler":
if (markierung.Information != -1 && Ziel == null)
{
DreheInRichtung(markierung.Information);
GeheGeradeaus(20);
}
break;
case "Krieger":
if (markierung.Information == -1 && Ziel == null)
{
int entfernung = Koordinate.BestimmeEntfernung(this, markierung);
if (entfernung > 50)
{
entfernung = 50;
}
SprüheMarkierung(-1, entfernung);
GeheZuZiel(markierung);
}
break;
}
}
/// <summary>
/// Wird wiederholt aufgerufen, wenn die Ameise mindestens einen Käfer
/// sieht.
/// </summary>
/// <param name="wanze">Der nächstgelegene Käfer.</param>
public override void SiehtFeind(Wanze wanze)
{
if (Kaste == "Sammler")
{
// Bei Käfersicht wird ermittelt ob die Sammlerameise evtl. kollidiert,
// wenn sie geradeaus weitergeht.
int relativeRichtung =
Koordinate.BestimmeRichtung(this, wanze) - Richtung;
if (relativeRichtung > -15 && relativeRichtung < 15)
{
LasseNahrungFallen();
if (relativeRichtung < 0)
{
DreheUmWinkel(20 + relativeRichtung);
}
else
{
DreheUmWinkel(-20 - relativeRichtung);
}
GeheGeradeaus(100);
}
}
else
{
// Kämpfer greifen sofort an.
LasseNahrungFallen();
GreifeAn(wanze);
}
}
/// <summary>
/// So wie Ameisen unterschiedliche Nahrungsmittel erspähen können, entdecken Sie auch
/// andere Spielelemente. Entdeckt die Ameise eine Wanze, so wird diese Methode aufgerufen.
/// </summary>
/// <param name="wanze">Erspähte Wanze</param>
public override void SiehtFeind(Wanze wanze)
{
if (Kaste == "Attacker")
{
// Wenn ein Käfer gesehen wird muss eine angemessen große Markierung gesprüht werden. Ist diese Markierung zu klein kommt zu wenig Hilfe, ist sie zu groß haben die weit entfernten Ameisen eine zu große Strecke und kommen erst nach dem Kampf an.
SprüheMarkierung(0, 150);
GreifeAn(wanze);
}
if (Kaste == "Appler")
{
// Bei Käfersicht wird ermittelt ob die Ameise evtl. kollidiert, wenn sie geradeaus weitergeht.
int relativeRichtung =
Koordinate.BestimmeRichtung(this, wanze) - Richtung;
if (relativeRichtung > -15 && relativeRichtung < 15)
{
// Wenn ja, soll sie erstmal die Nahrung fallen lassen um schneller zu laufen und dann, je nachdem auf welcher Seite der Käfer ist, in einem 20 Grad-Winkel in die andere Richtung weggehen.
LasseNahrungFallen();
if (relativeRichtung < 0)
{
DreheUmWinkel(20 + relativeRichtung);
}
else
{
DreheUmWinkel(-20 - relativeRichtung);
}
GeheGeradeaus(100);
}
}
}
/// <summary>
/// Wird wiederholt aufgerufen, wenn die Ameise mindestens einen
/// Zuckerhaufen sieht.
/// </summary>
/// <param name="zucker">Der nächstgelegene Zuckerhaufen.</param>
public override void Sieht(Zucker zucker)
{
SprüheMarkierung
(Koordinate.BestimmeRichtung(this, zucker),
Koordinate.BestimmeEntfernung(this, zucker));
if (Kaste == "Wächter")
{
if (gemerkterZucker == null)
{
// Dieser Aufruf ist nötig, damit in der nächsten Runde Wartet()
// aufgerufen wird.
BleibStehen();
gemerkterZucker = zucker;
aufEntfernungGehen = true;
}
}
else
{
if (gemerkterZucker == null)
{
gemerkterZucker = zucker;
}
if (Ziel == null)
{
GeheZuZiel(zucker);
}
}
}
public override void SiehtFeind(Wanze wanze)
{
if (EntfernungZuBau < 300)
{
Speicher.akt_wanze = wanze;
}
// Wanzen umgehen ################### wenig effect
if (Kaste == "Sammler" && ZielOptimized == Speicher.bau)
{
int ziel_angle = Koordinate.BestimmeRichtung(this, ZielOptimized);
int wanz_angle = Koordinate.BestimmeRichtung(this, wanze);
int diff = ziel_angle - wanz_angle;
// rechtsrum
if (0 <= diff && diff < 4)
{
DreheUmWinkel(-6);
GeheGeradeaus();
}
else
if (4 <= diff && diff < 7)
{
DreheUmWinkel(-4);
GeheGeradeaus();
}
else
// linksrum
if (0 > diff && diff > -5)
{
DreheUmWinkel(6);
GeheGeradeaus();
}
else
if (-5 > diff && diff > -8)
{
DreheUmWinkel(4);
GeheGeradeaus();
}
else
{
GeheZuZielOptimized(ZielOptimized);
}
}
if (Kaste == "Kämpfer" && AnzahlAmeisenDerSelbenKasteInSichtweite >= 2)
{
if (Koordinate.BestimmeEntfernung(this, wanze) < 10)
{
GreifeAn(wanze);
}
else
{
GeheZuZielOptimized(wanze);
}
}
}
private void GeheZuZielOptimized(Spielobjekt spielobjekt)
{
int distance = Koordinate.BestimmeEntfernung(this, spielobjekt);
//int angle = Koordinate.BestimmeRichtung(this, spielobjekt);
DreheZuZiel(spielobjekt);
GeheGeradeaus(distance);
}
protected int BestimmeY(CoreAnt spielobjekt)
{
int richtung = Koordinate.BestimmeRichtung(Speicher.bau, this);
int distance = Koordinate.BestimmeEntfernung(Speicher.bau, this) + 32;
float angle = ((float)richtung / 360) * ((float)Math.PI * 2);
return((int)(Math.Sin(angle) * distance));
}
/// <summary>
/// So wie Ameisen unterschiedliche Nahrungsmittel erspähen können, entdecken Sie auch
/// andere Spielelemente. Entdeckt die Ameise eine Ameise aus dem eigenen Volk, so
/// wird diese Methode aufgerufen.
/// Weitere Infos unter "http://wiki.antme.net/de/API1:SiehtFreund(Ameise)"
/// </summary>
/// <param name="ameise">Erspähte befreundete Ameise</param>
public override void SiehtFreund(Ameise ameise)
{
if ((this.Kaste == "Kämpfer") &&
(this.AnzahlAmeisenDerSelbenKasteInSichtweite > 2) &&
(ameise.Richtung == this.Richtung))
{
DreheInRichtung(Koordinate.BestimmeRichtung(this, ameise));
GeheGeradeaus();
}
}
/// <summary>
/// Wird wiederholt aufgerufen, wenn der die Ameise nicht weiss wo sie
/// hingehen soll.
/// </summary>
public override void Wartet()
{
if (Kaste == "Wächter")
{
if (gemerkterZucker != null && aufEntfernungGehen)
{
// Bestimme die Entfernung zu der Kreisbahn.
int entfernung =
Koordinate.BestimmeEntfernung(this, gemerkterZucker) - umkreisRadius;
// Gehe in Richtung Zucker bzw. vom Zucker weg auf die Kreisbahn.
if (entfernung > 0)
{
DreheZuZiel(gemerkterZucker);
GeheGeradeaus(entfernung);
}
else
{
DreheInRichtung
(Koordinate.BestimmeRichtung(this, gemerkterZucker) + 180);
GeheGeradeaus(-entfernung);
}
aufEntfernungGehen = false;
imKreisGehen = true;
}
else if (gemerkterZucker != null && imKreisGehen)
{
// Bestimme die Richtung zum Zucker und zähle den halben Innenwinkel
// dazu. Das ergibt die Gehrichtung.
int richtung = Koordinate.BestimmeRichtung(this, gemerkterZucker)
+ rückwärtsFaktor * innenWinkel / 2;
DreheInRichtung(richtung);
GeheGeradeaus(seitenLänge);
}
else
{
GeheGeradeaus();
}
}
else if (AktuelleLast > 0)
{
GeheZuBau();
}
else if (gemerkterZucker != null)
{
GeheZuZiel(gemerkterZucker);
}
else
{
GeheGeradeaus();
}
}
protected void GeheZuZielOptimized(Spielobjekt spielobjekt)
{
if (spielobjekt != null)
{
int angle = Koordinate.BestimmeRichtung(this, spielobjekt);
int distance = Koordinate.BestimmeEntfernung(this, spielobjekt);
DreheInRichtung(angle);
GeheGeradeaus(distance);
ZielOptimized = spielobjekt;
}
}
/// <summary>
/// Wird wiederholt aufgerufen, wenn die Ameise mindestens einen
/// Zuckerhaufen sieht.
/// </summary>
/// <param name="zucker">Der nächstgelegene Zuckerhaufen.</param>
public override void Sieht(Zucker zucker)
{
if (!laufeWeg)
{
int entfernung = Koordinate.BestimmeEntfernung(this, zucker);
SprüheMarkierung(Koordinate.BestimmeRichtung(this, zucker), entfernung);
if (Ziel == null && AktuelleLast < MaximaleLast)
{
GeheZuZiel(zucker);
}
}
}
/// <summary>
/// Sobald eine Ameise innerhalb ihres Sichtradius einen Apfel erspäht wird
/// diese Methode aufgerufen. Als Parameter kommt das betroffene Stück Obst.
/// Weitere Infos unter "http://wiki.antme.net/de/API1:Sieht(Obst)"
/// </summary>
/// <param name="obst">Das gesichtete Stück Obst</param>
public override void Sieht(Obst obst)
{
if (!(Ziel is Wanze) && Kaste == "Sammler")
{
if (AktuelleLast == 0 && BrauchtNochTräger(obst))
{
GeheZuZiel(obst);
int entfernung, richtung;
entfernung = Koordinate.BestimmeEntfernung(this, obst);
richtung = Koordinate.BestimmeRichtung(this, obst);
SprüheMarkierung(richtung, entfernung);
}
}
}
/// <summary>
/// Wird wiederholt aufgerufen, wenn die Ameise mindstens ein
/// Obststück sieht.
/// </summary>
/// <param name="obst">Das nächstgelegene Obststück.</param>
public override void Sieht(Obst obst)
{
// Eine Markierung darf jede Ameise sprühen.
int richtung = Koordinate.BestimmeRichtung(this, obst);
int entfernung = Koordinate.BestimmeEntfernung(this, obst);
SprüheMarkierung(richtung, entfernung);
// Ein Ziel darf nur der Gruppenführer vorgeben.
if (gruppenführer[gruppe] == this && (Ziel == null || Ziel is Insekt))
{
GeheZuZiel(obst);
}
}
/// <summary>
/// Sobald eine Ameise innerhalb ihres Sichtradius einen Zuckerhügel erspäht wird
/// diese Methode aufgerufen. Als Parameter kommt der betroffene Zuckerghügel.
/// Weitere Infos unter "http://wiki.antme.net/de/API1:Sieht(Zucker)"
/// </summary>
/// <param name="zucker">Der gesichtete Zuckerhügel</param>
public override void Sieht(Zucker zucker)
{
if (!(Ziel is Wanze) && Kaste == "Sammler")
{
if (AktuelleLast == 0)
{
GeheZuZiel(zucker);
int entfernung, richtung;
entfernung = Koordinate.BestimmeEntfernung(this, zucker);
richtung = Koordinate.BestimmeRichtung(this, zucker);
SprüheMarkierung(richtung, entfernung);
}
}
}
/// <summary>
/// Diese Methode wird in jeder Simulationsrunde aufgerufen - ungeachtet von zusätzlichen
/// Bedingungen. Dies eignet sich für Aktionen, die unter Bedingungen ausgeführt werden
/// sollen, die von den anderen Methoden nicht behandelt werden.
/// Weitere Infos unter http://wiki.antme.net/de/API1:Tick
/// </summary>
public override void Tick()
{
// Wenn 2 Gegner in der Nähe des Störers ist, ruft sie um Hilfe, damit die Gegner beseitigt werden und sie den Apfel wegziehen kann.
if (Kaste == "Störer" && AktuelleLast > 0 && AnzahlFremderAmeisenInSichtweite > 2 && Hilferufe < 1)
{
Hilferuf.Add(this);
Hilferufe++;
}
// Und wenn der Apfel weit genug weg ist, wird der Apfel wieder fallen gelassen.
if (Kaste == "Störer" && AktuelleLast > 0 && (int)(Math.Sqrt(Math.Pow(GenaueBauKoordinaten.Item1 - HoleKoordinaten(this).Item1, 2) + Math.Pow(GenaueBauKoordinaten.Item2 - HoleKoordinaten(this).Item2, 2))) > 205)
{
LasseNahrungFallen();
zielapfel = false;
Hilferufe = 0;
}
// Krieger soll zu unserem Störer hingehen
if (kriegerziel != null)
{
if (Koordinate.BestimmeEntfernung(this, kriegerziel) < 20 && AnzahlFremderAmeisenInSichtweite == 0)
{
kriegerziel = null;
}
}
// Sind Äpfel weg, werden sie auch aus der Liste entfernt
for (int i = Äpfel.Count - 1; i >= 0; i--)
{
if (Äpfel.ElementAt(i).Item1.Menge == 0)
{
Äpfel.Remove(Äpfel.ElementAt(i));
}
}
// Positionsbestimmung von unserem Bau
if (bau == null)
{
GeheZuBau();
bau = Ziel;
BleibStehen();
}
// Hat die feindliche Ameise ihre Last noch nicht abgelegt, soll sie solange verfolgt werden, bis sie es tut und in dem Moment werden ihre Koordinaten als gegnerischer Bau gespeichert
if (ziel != null && GenaueBauKoordinaten == null)
{
if (ziel.AktuelleLast == 0)
{
GenaueBauKoordinaten = HoleKoordinaten(ziel);
}
GeheZuKoordinate(HoleKoordinaten(ziel));
}
}
private void calcParameters()
{
enemyDistance = Koordinate.BestimmeEntfernung(ego, Hindernis);
enemySpeed = Hindernis.MaximaleGeschwindigkeit;
enemyAngle = direction(ego.Richtung, Koordinate.BestimmeRichtung(ego, Hindernis));
ownSpeed = ego.MaximaleGeschwindigkeit;
if (enemyDistance > enemySpeed)
{
escTurns = (int)Math.Ceiling(10 * enemySpeed / (double)ownSpeed);
escAngle = ((enemyDistance / enemySpeed - escTurns) * 6) * enemyAngle;
escDistance = escTurns * ownSpeed;
}
}
/// <summary>
/// Wird wiederholt aufgerufen, wenn die Ameise mindstens ein
/// Obststück sieht.
/// </summary>
/// <param name="obst">Das nächstgelegene Obststück.</param>
public override void Sieht(Obst obst)
{
if (BrauchtNochTräger(obst))
{
SprüheMarkierung
(Koordinate.BestimmeRichtung(this, obst),
Koordinate.BestimmeEntfernung(this, obst));
if (Kaste.Substring(0, 7) == "Sammler" && Ziel == null)
{
GeheZuZiel(obst);
}
}
}
/// <summary>
/// Wird wiederholt aufgerufen, wenn die Ameise mindestens einen
/// Zuckerhaufen sieht.
/// </summary>
/// <param name="zucker">Der nächstgelegene Zuckerhaufen.</param>
public override void Sieht(Zucker zucker)
{
// Wenn Zucker in der Nähe ist soll eine Markierung gesprüht werden. Der
// Radius dieser Markierung richtet sich nach der Entfernung der Ameise
// zum Zucker damit die Markierung nicht über den Zucker hinaus zeigt.
SprüheMarkierung(
Koordinate.BestimmeRichtung(this, zucker),
Koordinate.BestimmeEntfernung(this, zucker));
// Wenn die Ameise nichts trägt soll sie zum Zucker hin.
if (AktuelleLast == 0)
{
GeheZuZiel(zucker);
}
}
/// <summary>
/// Alternative zur Funktion namens GeheZuZiel, mit der die Ameise optimiert zum Ziel geht, also ohne Zick-Zack-Lauf
/// </summary>
/// <param name="zielOptimized">Das Ziel zu dem optimiert gelaufen werden soll</param>
private void GeheZuZielOptimized(Spielobjekt zielOptimized)
{
//Entfernung zwischen der Ameise und dem übergebenen Ziel
int distance = Koordinate.BestimmeEntfernung(this, zielOptimized);
//Winkel zwischen mir und dem Ziel
int angle = Koordinate.BestimmeRichtung(this, zielOptimized);
//In Richtung des übergebenen Ziels drehen
DreheInRichtung(angle);
//Um die soeben berechnete Entfernung geradeaus gehen, um zum übergebenen Ziel zu gehen.
GeheGeradeaus(distance);
//Das zielOptimized der Ameise auf das übergebene Ziel setzen.
this.zielOptimized = zielOptimized;
}
/// <summary>
/// Diese Methode wird in jeder Simulationsrunde aufgerufen - ungeachtet von zusätzlichen
/// Bedingungen. Dies eignet sich für Aktionen, die unter Bedingungen ausgeführt werden
/// sollen, die von den anderen Methoden nicht behandelt werden.
/// Weitere Infos unter http://wiki.antme.net/de/API1:Tick
/// </summary>
public override void Tick()
{
//Schickt erschöpfte Ameisen zurück
/*if (Reichweite - ZurückgelegteStrecke -20 < EntfernungZuBau)
* {
* GeheZuBau();
* }*/
//Wenn die Ameise Last hat, dann soll sie zum Bau gehen
if (AktuelleLast != 0)
{
GeheZuBauOptimized(bau);
}
//Schaue wie gro
if (ankunftsort != null)
{
int distance = Koordinate.BestimmeEntfernung(this, ankunftsort);
if (distance < Sichtweite / 2)
{
GeheZuBau();
ankunftsort = null;
}
}
//Findet heraus, ob der Zuckerberg noch existiert, wenn du dein Zucker schon abgeliefert hast
if (zuckers != null && AktuelleLast == 0)
{
if (zuckers.Menge <= 0)
{
zuckers = null;
BleibStehen();
}
}
//Ermöglicht anderen Ameisen zu wissen, wo Zucker ist
/*
* if (AktuelleLast > 0)
* {
* if (GetragenesObst == null)
* {
* SprüheMarkierung(Richtung + 180, 100);
* }
* }
*/
}
/// <summary>
/// So wie Ameisen unterschiedliche Nahrungsmittel erspähen können, entdecken Sie auch
/// andere Spielelemente. Entdeckt die Ameise eine Wanze, so wird diese Methode aufgerufen.
/// Weitere Infos unter "http://wiki.antme.net/de/API1:SiehtFeind(Wanze)"
/// </summary>
/// <param name="wanze">Erspähte Wanze</param>
public override void SiehtFeind(Wanze wanze)
{
LasseNahrungFallen();
if (AnzahlAmeisenInSichtweite >= 4 && Kaste == "Kämpfer")
{
GreifeAn(wanze);
int entfernung, richtung;
entfernung = Koordinate.BestimmeEntfernung(this, wanze);
richtung = Koordinate.BestimmeRichtung(this, wanze);
SprüheMarkierung(richtung, entfernung);
}
else
{
GeheWegVon(wanze);
}
}
