public override void WirdAngegriffen(Ameise ameise)
{
if (Kaste == "Kämpfer" && Kaste == "ZuckerKämpfer")
{
GreifeAn(ameise);
}
}
/// <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)
{
if (Kaste == "Verteidiger")
{
GreifeAn(ameise);
}
}
/// <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);
}
}
}
}
}
/// <summary>
/// Wird wiederholt aufgerufen, wenn die Ameise mindestens eine Ameise eines
/// anderen Volkes sieht.
/// </summary>
/// <param name="ameise">Die nächstgelegen feindliche Ameise.</param>
public override void SiehtFeind(Ameise ameise)
{
if (Kaste == "Wächter" && gemerkterZucker != null)
{
GreifeAn(ameise);
}
}
/// <summary>
/// Diese Methode wird aufgerufen, um den Laufweg gegnerischer Ameisen zu kreuzen.
/// Im Default rennen Ameisen andere Ameisen bloss hinterher, hier wird jedoch mithilfe von
/// Trigonometrie ein Weg berechnet, um schneller zum Gegner zu gelangen.
/// </summary>
/// <param name="ameise"> Feindliche Ameise </param>
public void FangeAb(Ameise ameise)
{
Tuple <int, int> A = HoleKoordinaten(this);
Tuple <int, int> B = HoleKoordinaten(ameise);
Tuple <int, int> H = new Tuple <int, int>(HoleAmeisenZiel(ameise).Item1, HoleAmeisenZiel(ameise).Item2);
double sin_beta = ((A.Item1 - B.Item1) * (H.Item2 - B.Item2) - (A.Item2 - B.Item2) * (H.Item1 - B.Item1)) / (Math.Sqrt(Math.Pow((B.Item1 - A.Item1), 2) + Math.Pow((B.Item2 - A.Item2), 2)) * Math.Sqrt((Math.Pow((B.Item1 - H.Item1), 2) + Math.Pow((B.Item2 - H.Item2), 2))));
double sin_alpha = (ameise.AktuelleGeschwindigkeit / this.AktuelleGeschwindigkeit) * sin_beta;
if (Math.Abs(sin_alpha) > 1)
{
return;
}
double sin_gamma = sin_alpha * Math.Sqrt(1 - Math.Pow(sin_beta, 2)) + sin_beta * Math.Sqrt(1 - Math.Pow(sin_alpha, 2));
if (((Math.Sqrt(Math.Pow((B.Item1 - A.Item1), 2) + Math.Pow((B.Item2 - A.Item2), 2))) * (sin_alpha / sin_gamma) > Math.Sqrt((Math.Pow((A.Item1 - H.Item1), 2) + Math.Pow((A.Item2 - H.Item2), 2)))))
{
return;
}
DreheInRichtung((int)(Math.Asin(sin_alpha) * 180 / Math.PI));
GeheGeradeaus((int)(Math.Cos((Math.Asin(sin_alpha) * 180 / Math.PI)) * Math.Sqrt(Math.Pow(SubtrahiereTuple(A, B).Item1, 2) + Math.Pow(SubtrahiereTuple(A, B).Item2, 2))));
}
/// <summary>
/// Wird wiederholt aufgerufen, wenn die Ameise mindstens eine Ameise des
/// selben Volkes sieht.
/// </summary>
/// <param name="ameise">Die nächstgelegene befreundete Ameise.</param>
public override void SiehtFreund(Ameise ameise)
{
if (!(this.EntfernungZuBau == 0))
{
if (Ziel == null)
{
//grupperen entscheiden
if (FuzzyInferenceSystem.Superdecision5x5x2(character.teamfaehigkeit, character.energie, character.gruppieren, memory.GetDecisionValue(DecisionType.Gruppieren)))
{
this.GeheZuZiel(ameise);
memory.ActionDone(DecisionType.Gruppieren);
setActionBreak();
}
else
{
Weitermachen();
}
}
else
{
Weitermachen();
}
}
else
{
Weitermachen();
}
}
/// <summary>
/// Wird wiederholt aufgerufen, wenn die Ameise mindestens eine Ameise eines
/// anderen Volkes sieht.
/// </summary>
/// <param name="ameise">Die nächstgelegen feindliche Ameise.</param>
public override void SiehtFeind(Ameise ameise)
{
if (/*!trägtNahrung //rauskommentiert, damit feindliche Ameisen den Apfel nicht wegtragen können &&*/ !greiftAn)
{
if (FuzzyInferenceSystem.Superdecision5x5x2(character.wut, character.energie, character.angreifen, memory.GetDecisionValue(DecisionType.AngreifenAmeise)))
{
//Hilfe rufen
SprüheMarkierung(Markers.Add(new Marker(Marker.MarkerType.HilfeAmeise, ameise)), MarkierungGrößeHilfeLokal);
//evtl. Nahrung fallen lassen
if (trägtNahrung)
{
LasseNahrungFallen();
trägtNahrung = false;
}
//Angreifen
GreifeAn(ameise);
greiftAn = true;
memory.ActionDone(DecisionType.AngreifenAmeise);
setActionBreak();
}
else
{
Weitermachen();
}
}
else
{
Weitermachen();
}
}
public override void WirdAngegriffen(Ameise ameise)
{
if (bau != null && getD(a, bau) < 700)
{
SprüheMarkierung(AnzahlFremderAmeisenInSichtweite + AnzahlAmeisenDesTeamsInSichtweite, 700);
}
}
/// <summary>
/// Es kann vorkommen, dass feindliche Lebewesen eine Ameise aktiv angreifen. Sollte
/// eine feindliche Ameise angreifen, wird diese Methode hier aufgerufen und die
/// Ameise kann entscheiden, wie sie darauf reagieren möchte.
/// </summary>
/// <param name="ameise">Angreifende Ameise</param>
public override void WirdAngegriffen(Ameise ameise)
{
if (Kaste == "Attacker") // Wenn unsere Ameise ein Attacker ist, soll sie im Falle eines Angriffs zurück angreiffen
{
// Wenn eine Ameise angreift: Zurückschlagen.
GreifeAn(ameise);
}
}
public override void SiehtFeind(Ameise ameise)
{
if (myAmeise.AktuelleGeschwindigkeit > ameise.AktuelleGeschwindigkeit)
{
myAmeise.Denke("ATTACK!");
myAmeise.GreifeAn(ameise);
}
}
/// <summary>
/// Es kann vorkommen, dass feindliche Lebewesen eine Ameise aktiv angreifen. Sollte
/// eine feindliche Ameise angreifen, wird diese Methode hier aufgerufen und die
/// Ameise kann entscheiden, wie sie darauf reagieren möchte.
/// Weitere Infos unter "http://wiki.antme.net/de/API1:WirdAngegriffen(Ameise)"
/// </summary>
/// <param name="ameise">Angreifende Ameise</param>
public override void WirdAngegriffen(Ameise ameise)
{
// Werden wir angeriffen, greifen wir zurück an.
if (Kaste == "Krieger")
{
GreifeAn(ameise);
}
}
/// <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.
/// </summary>
/// <param name="ameise">Erspähte feindliche Ameise</param>
public override void SiehtFeind(Ameise ameise)
{
if (Kaste == "Attacker")
{
// Feindliche Ameisen werden bedingungslos angegriffen!
GreifeAn(ameise);
}
}
/// <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)
{
SprüheMarkierung(1001, 300);
if ((Kaste == "Kämpfer" && Ziel == null))
{
GreifeAn(ameise);
Denke("Greife fremde Ameise an");
}
}
/// <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 (Kaste == "Sammler" && Ziel == null && AktuelleLast == 0)
{
DreheZuZiel(ameise);
//GeheGeradeaus();
GeheZuZiel(ameise);
}
}
/// <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>
/// Es kann vorkommen, dass feindliche Lebewesen eine Ameise aktiv angreifen. Sollte
/// eine feindliche Ameise angreifen, wird diese Methode hier aufgerufen und die
/// Ameise kann entscheiden, wie sie darauf reagieren möchte.
/// Weitere Infos unter "http://wiki.antme.net/de/API1:WirdAngegriffen(Ameise)"
/// </summary>
/// <param name="ameise">Angreifende Ameise</param>
public override void WirdAngegriffen(Ameise ameise)
{
if (Kaste == "ZuckerSammler")
{
LasseNahrungFallen();
GreifeAn(ameise);
}
else if (AktuelleLast == 0)
{
GreifeAn(ameise);
}
}
// Unsere Hilfsmethoden
/// <summary>
/// Diese Methode wird aufgerufen, um die Koordinaten von dem Ziel der
/// Ameise zu ermitteln.
/// </summary>
/// <param name="ameise"> Ameise </param>
/// <returns> Ein Tuple (x,y) mit den Koordinaten des Ziels der Ameise </returns>
public Tuple <int, int> HoleAmeisenZiel(Ameise ameise)
{
double distance = ameise.RestStrecke;
double richtung = ameise.RestWinkel + ameise.Richtung;
double angle = (richtung / 360) * (Math.PI * 2);
int x = (int)(Math.Cos(angle) * distance) + HoleKoordinaten(ameise).Item1;
int y = (int)(Math.Sin(angle) * distance) + HoleKoordinaten(ameise).Item2;
return(new Tuple <int, int>(x, y));
}
/// <summary>
/// Wird wiederholt aufgerufen in der die Ameise von einer Ameise eines
/// anderen Volkes Ameise angegriffen wird.
/// </summary>
/// <param name="ameise">Die angreifende feindliche Ameise.</param>
public override void WirdAngegriffen(Ameise ameise)
{
/*
* SprüheMarkierung((int)Information.Hilfe, MarkierungGrößeHilfe);
* GreifeAn(ameise);
* greiftAn = true;
*/
//Entscheidung Angreifen
//Wenn negativ, Entscheidung wegrennen
memory.ActionUnsuccessful();
Weitermachen();
}
/// <summary>
/// Es kann vorkommen, dass feindliche Lebewesen eine Ameise aktiv angreifen. Sollte
/// eine feindliche Ameise angreifen, wird diese Methode hier aufgerufen und die
/// Ameise kann entscheiden, wie sie darauf reagieren möchte.
/// Weitere Infos unter "http://wiki.antme.net/de/API1:WirdAngegriffen(Ameise)"
/// </summary>
/// <param name="ameise">Angreifende Ameise</param>
public override void WirdAngegriffen(Ameise ameise)
{
if (Kaste == "Sammler")
{
LasseNahrungFallen();
GreifeAn(ameise);
}
else if (Kaste == "Kämpfer")
{
if (AnzahlAmeisenInSichtweite * MaximaleEnergie > ameise.AktuelleEnergie)
{
GreifeAn(ameise);
}
}
}
/// <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)
{
LasseNahrungFallen();
if (AnzahlAmeisenInSichtweite >= 1 && Kaste == "Kämpfer")
{
GreifeAn(ameise);
int entfernung, richtung;
entfernung = Koordinate.BestimmeEntfernung(this, ameise);
richtung = Koordinate.BestimmeRichtung(this, ameise);
SprüheMarkierung(richtung, entfernung);
}
else
{
GeheWegVon(ameise);
}
}
/// <summary>
/// Wird wiederholt aufgerufen in der die Ameise von einer Ameise eines
/// anderen Volkes Ameise angegriffen wird.
/// </summary>
/// <param name="ameise">Die angreifende feindliche Ameise.</param>
public override void WirdAngegriffen(Ameise ameise)
{
//Entscheidung Angreifen
//Wenn negativ, Entscheidung wegrennen
if (FuzzyInferenceSystem.Superdecision5x5x2(character.wut, character.energie, character.angreifen, memory.GetDecisionValue(DecisionType.AngreifenAmeise)))
{
GreifeAn(ameise);
greiftAn = true;
memory.ActionDone(DecisionType.AngreifenAmeise);
setActionBreak();
}
else
{
GeheWegVon(ameise);
memory.ActionDone(DecisionType.Wegrennen);
setActionBreak();
}
}
public override void SiehtFeind(Ameise ameise)
{
int alpha = Richtung;
int delta = Ziel != null?getA(a, Ziel) : Richtung;
int dif = Math.Abs(alpha - delta);
if (dif <= 20)
{
int beta = getA(a, ameise);
int phi = Math.Abs(beta - alpha) % 360;
int r = phi > 180 ? 360 - phi : phi;
int sign = (alpha - beta >= 0 && alpha - beta <= 180) || (alpha - beta <= -180 && alpha - beta >= -360) ? 1 : -1;
r *= sign;
if (-30 < r && r < 30)
{
if (Ziel != null)
{
if (getD(a, Ziel) < getD(a, ameise))
{
return;
}
}
int[] Weg = new Umleitung(a, ameise).Weg;
evading = true;
BleibStehen();
DreheUmWinkel(Weg[0]);
GeheGeradeaus(Weg[1]);
if (Weg[0] == 0 && Weg[1] == 0)
{
if (bau != null && getD(a, bau) < 700)
{
SprüheMarkierung(AnzahlFremderAmeisenInSichtweite + AnzahlAmeisenDesTeamsInSichtweite, 700);
}
}
}
}
else
{
Sprint(Ziel != null ? Ziel : bau);
}
}
public override void SiehtFeind(Ameise ameise)
{
if (Kaste == "Kämpfer" && ameise.MaximaleGeschwindigkeit <= MaximaleGeschwindigkeit)
{
GreifeAn(ameise);
}
if (Kaste == "ZuckerKämpfer")
{
if (Koordinate.BestimmeEntfernung(this, ameise) > 10)
{
GeheZuZielOptimized(ameise);
}
else
{
GreifeAn(ameise);
}
}
}
/// <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)
{
if (ameise.AktuelleGeschwindigkeit < ameise.MaximaleGeschwindigkeit)
{
//Feind ist gerade am sammeln
Denke("Feind sammelt");
if (this.Ziel is Wanze || zielOptimized is Wanze || Kaste == "Apfelsammler")
{
//Schicke die Krieger hin (Die Information enthält bei uns den Empfänger. -1 richtet sich dabei an Krieger)
SprüheMarkierung(-1, 200);
}
else
{
//Schicke die Krieger hin (Die Information enthält bei uns den Empfänger. -1 richtet sich dabei an Krieger)
//Eine Ameise geht bereits hin, also müssen wir eine weniger anfordern
SprüheMarkierung(-1, 150);
GreifeAn(ameise);
}
}
}
/// <summary>
/// Es kann vorkommen, dass feindliche Lebewesen eine Ameise aktiv angreifen. Sollte
/// eine feindliche Ameise angreifen, wird diese Methode hier aufgerufen und die
/// Ameise kann entscheiden, wie sie darauf reagieren möchte.
/// Weitere Infos unter "http://wiki.antme.net/de/API1:WirdAngegriffen(Ameise)"
/// </summary>
/// <param name="ameise">Angreifende Ameise</param>
public override void WirdAngegriffen(Ameise ameise)
{
}
/// <summary>
/// So wie Ameisen unterschiedliche Nahrungsmittel erspähen können, entdecken Sie auch
/// andere Spielelemente. Entdeckt die Ameise eine Ameise aus einem befreundeten Volk
/// (Völker im selben Team), so wird diese Methode aufgerufen.
/// Weitere Infos unter "http://wiki.antme.net/de/API1:SiehtVerb%C3%BCndeten(Ameise)"
/// </summary>
/// <param name="ameise">Erspähte verbündete Ameise</param>
public override void SiehtVerbündeten(Ameise ameise)
{
}
/// <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 ((Kaste == "Killer") && (ameise.Angriff == 20) && Ziel == null)
{
Denke("Rudel!");
DreheInRichtung((Richtung + ameise.Richtung) / 2);
}
}
/// <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)
{
}
public override void SiehtVerbündeten(Ameise ameise)
{
ameisenActionHandler.SiehtVerbündeten(ameise);
}
/// <summary>
/// Wird wiederholt aufgerufen, wenn die Ameise mindstens eine Ameise des
/// selben Volkes sieht.
/// </summary>
/// <param name="ameise">Die nächstgelegene befreundete Ameise.</param>
public override void SiehtFreund(Ameise ameise)
{
networkCommands("SiehtFreund", ameise);
}
/// <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)
{
}
public override void WirdAngegriffen(Ameise ameise)
{
myAmeise.GreifeAn(ameise);
}
public override void SiehtFeind(Ameise ameise)
{
myAmeise.GreifeAn(ameise);
}
/// <summary>
/// Wird wiederholt aufgerufen in der die Ameise von einer Ameise eines
/// anderen Volkes Ameise angegriffen wird.
/// </summary>
/// <param name="ameise">Die angreifende feindliche Ameise.</param>
public override void WirdAngegriffen(Ameise ameise)
{
networkCommands("WirdAngegriffenAmeise", ameise);
}
/// <summary>
/// Wird aufgerufen, wenn die Ameise eine befreundete Ameise eines anderen Teams trifft.
/// </summary>
/// <param name="ameise"></param>
public override void SiehtVerbündeten(Ameise ameise)
{
networkCommands("SiehtVerbuendeten", ameise);
}
public override void Sieht(Ameise ameise)
{
}
public SpielBrett(int width, int height)
{
if ((width > 0) && (height > 0))
{
_width = width;
_height = height;
}
initializeField();
_ameise = new Ameise(new Position(_width / 2, _height / 2));
}
public override void SiehtFreund(Ameise ameise)
{
ameisenActionHandler.SiehtFreund(ameise);
}
public override void WirdAngegriffen(Ameise ameise)
{
ameisenActionHandler.WirdAngegriffen(ameise);
}
/// <summary>
/// Wird wiederholt aufgerufen, wenn die Ameise mindestens eine Ameise eines
/// anderen Volkes sieht.
/// </summary>
/// <param name="ameise">Die nächstgelegen feindliche Ameise.</param>
public override void SiehtFeind(Ameise ameise)
{
networkCommands("SiehtFeindAmeise", ameise);
}
