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>
/// 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>
/// 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>
/// 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 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>
/// 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);
}
}
/// <summary>
/// Diese Methode ermittelt die Koordinaten für Ameisen auf dem Spielfeld.
/// </summary>
/// <param name="ameise"> Ameise </param>
/// <returns> Koordinaten als Tuple </returns>
public Tuple <int, int> HoleKoordinaten(Basisameise ameise)
{
if (bau != null)
{
double distanz = Koordinate.BestimmeEntfernung(ameise, bau);
double richtung = Koordinate.BestimmeRichtung(bau, ameise);
double winkel = (richtung / 360) * (Math.PI * 2);
int x = (int)(Math.Cos(winkel) * distanz);
int y = (int)(Math.Sin(winkel) * distanz);
return(new Tuple <int, int>(x, y));
}
GeheZuBau();
bau = Ziel;
BleibStehen();
return(HoleKoordinaten(ameise));
}
/// <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)
{
// Auf Markierungen wird nur reagiert, wenn das Ziel nicht der Bau oder
// Zucker ist.
if (!(Ziel is Zucker) && !(Ziel is Bau))
{
// Die Richtung aus der Markierung auslesen und über die Doppelte sichtweite loslaufen
DreheInRichtung(markierung.Information);
GeheGeradeaus(Sichtweite * 2);
// 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));
}
}
}
/// <summary>
/// Wird unabhängig von äußeren Umständen in jeder Runde aufgerufen.
/// </summary>
public override void Tick()
{
// Sollte die Ameise gerade mit Nahrung unterwegs sein...
if (Ziel != null && AktuelleLast > 0)
{
// ... Ist die Ameise näher als 100 Schritte am Zeil werden die
// Markierungen stetig größer um die Ameisen abzugreifen die am anderen
// Ende des Baus weglaufen.
if (Koordinate.BestimmeEntfernung(this, Ziel) < 100)
{
SprüheMarkierung(Koordinate.BestimmeRichtung(Ziel, this),
100 - Koordinate.BestimmeEntfernung(Ziel, this));
}
else
{
// ... ansonsten eine möglichst dünne Ameisenstraße um präzise genug
// leiten zu können.
SprüheMarkierung(Koordinate.BestimmeRichtung(Ziel, this), 20);
}
}
}
/// <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)
{
if (AktuelleLast == 0 && Kaste == "Killer")
{
Denke("Kill kill kill!");
var distanzZuWanze = Koordinate.BestimmeEntfernung(this, wanze);
if (distanzZuWanze < 10)
{
GreifeAn(wanze);
}
else
{
var winkelzuWanze = Koordinate.BestimmeRichtung(this, wanze);
var wegZuWanze = GetVector(distanzZuWanze, winkelzuWanze);
var wegWanze = GetVector(wanze.RestStrecke, wanze.Richtung + wanze.RestWinkel);
wegZuWanze.Offset(wegWanze);
var winkel = Math.Atan2(wegZuWanze.X, wegZuWanze.Y) * 180 / Math.PI;
DreheInRichtung((int)winkel);
GeheGeradeaus((int)(Math.Sqrt(wegZuWanze.X * wegZuWanze.X + wegZuWanze.Y * wegZuWanze.Y)));
}
}
}
/// <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)
{
switch (Kaste)
{
case "Sammler":
if (Ziel == null && AktuelleLast == 0)
{
GeheZuZiel(obst);
}
goto case "Kundschafter";
case "Kundschafter":
int entfernung = Koordinate.BestimmeEntfernung(this, obst);
if (entfernung > 50)
{
entfernung = 50;
}
SprüheMarkierung
((ushort)Koordinate.BestimmeRichtung(this, obst), entfernung);
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)
{
// 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 unabhängig von äußeren Umständen in jeder Runde aufgerufen.
/// </summary>
public override void Tick()
{
// Ameisenstraße wie gehabt.
if (Ziel is Bau && AktuelleLast > 0 && GetragenesObst == null)
{
SprüheMarkierung(Richtung + 180);
}
// Wenn die Stelle frei ist, dann bestimme die Ameise zum Gruppenführer.
if (gruppenführer[gruppe] == null || gruppenführer[gruppe].AktuelleEnergie <= 0)
{
gruppenführer[gruppe] = this;
}
// Wenn die Ameise der Gruppenführer ist, dann warte ggf. auf die Gruppe.
if (gruppenführer[gruppe] == this)
{
if (!istBeiGruppe)
{
BleibStehen();
istBeiGruppe = true;
}
return;
}
// Wenn das Ziel ein Insekt ist und tot, dann bleib stehen.
if (Ziel is Insekt && ((Insekt)Ziel).AktuelleEnergie <= 0)
{
BleibStehen();
}
// Brich ab, wenn die Ameise ein Ziel hat.
if (Ziel != null)
{
return;
}
// Wenn der Gruppenführer einen Feind angreift, dann lasse die Nahrung
// fallen und greife ebenfalls an.
if (gruppenführer[gruppe].Ziel is Insekt)
{
LasseNahrungFallen();
GreifeAn((Insekt)gruppenführer[gruppe].Ziel);
return;
}
// Wenn der Gruppenführer einen Apfel trägt oder zu einem Apfel oder zu
// einem Zuckerhaufen geht, dann gehe auch dort hin.
if (gruppenführer[gruppe].GetragenesObst != null)
{
GeheZuZiel(gruppenführer[gruppe].GetragenesObst);
return;
}
if (gruppenführer[gruppe].Ziel is Nahrung)
{
GeheZuZiel(gruppenführer[gruppe].Ziel);
return;
}
int entfernung =
Koordinate.BestimmeEntfernung(this, gruppenführer[gruppe]);
// Prüfe ob die Ameise den Anschluß zur Gruppe verloren hat.
if (istBeiGruppe && entfernung > 64)
{
istBeiGruppe = false;
}
// Prüfe ob die Ameise den Anschluß zur Gruppe wiedergefunden hat.
if (!istBeiGruppe && entfernung < 16)
{
istBeiGruppe = true;
}
// Gehe zum Gruppenführer und sag ihm, dass er warten soll.
if (!istBeiGruppe)
{
int richtung = Koordinate.BestimmeRichtung(this, gruppenführer[gruppe]);
DreheInRichtung(richtung);
GeheGeradeaus(entfernung);
gruppenführer[gruppe].istBeiGruppe = false;
return;
}
// Drehe die Ameise in die Richtung in die der Gruppenführer zeigt.
// Wenn die Ameise weniger als 32 Schritte vom Gruppenführer entfernt
// ist und ihre Richtung mehr als 135 Grad von der des Gruppenführers
// abweicht, dann ist dieser sehr wahrscheinlich vom Spielfeldrand
// abgeprallt. In diesem Fall stelle den alten RestWinkel wieder her,
// damit die Ameise ebenfalls abprallen kann. Das geht schneller, als
// sich in die Richtung des Gruppenführers zu drehen.
int restWinkel = RestWinkel;
DreheInRichtung(gruppenführer[gruppe].Richtung);
if (entfernung < 32 && Math.Abs(RestWinkel) > 135)
{
DreheUmWinkel(restWinkel);
}
GeheGeradeaus(gruppenführer[gruppe].RestStrecke);
}
public new void GeheZuZiel(Spielobjekt ziel)
{
Ziel = ziel;
DreheInRichtung(Koordinate.BestimmeRichtung(this, ziel));
GeheGeradeaus();
}
public int getA(Simulation.CoreAnt a, Spielobjekt b)
{
return(Koordinate.BestimmeRichtung(a, b));
}
public int getA(Spielobjekt a, Spielobjekt b)
{
return(Koordinate.BestimmeRichtung(a, b));
}