/// <summary>
/// Es kann vorkommen, dass feindliche Lebewesen eine Ameise aktiv angreifen. Sollte
/// eine Wanze 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(Wanze)"
/// </summary>
/// <param name="wanze">Angreifende Wanze</param>
public override void WirdAngegriffen(Wanze wanze)
{
if (AktuelleLast > 0)
{
LasseNahrungFallen();
}
}
/// <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 Käfer
/// sieht.
/// </summary>
/// <param name="wanze">Der nächstgelegene Käfer.</param>
public override void SiehtFeind(Wanze wanze)
{
if (Kaste == "Wächter" && gemerkterZucker != null)
{
GreifeAn(wanze);
}
}
public override void SiehtFeind(Wanze wanze)
{
if (myAmeise.AnzahlAmeisenDerSelbenKasteInSichtweite >= 5)
{
myAmeise.GreifeAn(wanze);
}
}
public override void WirdAngegriffen(Wanze wanze)
{
if (Kaste == "Kämpfer")
{
GreifeAn(wanze);
}
}
public override void WirdAngegriffen(Wanze wanze)
{
if (myAmeise.AnzahlAmeisenDerSelbenKasteInSichtweite >= 5)
{
myAmeise.GreifeAn(wanze);
}
}
/// <summary>
/// Wird wiederholt aufgerufen, wenn die Ameise von einem Käfer angegriffen
/// wird.
/// </summary>
/// <param name="wanze">Der angreifende Käfer.</param>
public override void WirdAngegriffen(Wanze wanze)
{
if (AktuelleEnergie < MaximaleEnergie / 4)
{
GeheZuBau();
}
}
/// <summary>
/// Wird wiederholt aufgerufen, wenn die Ameise von einer Wanze angegriffen
/// wird.
/// </summary>
/// <param name="wanze">Die angreifende Wanze.</param>
public override void WirdAngegriffen(Wanze wanze)
{
/*
* SprüheMarkierung((int)Information.Hilfe, MarkierungGrößeHilfe);
* GreifeAn(wanze);
* greiftAn = true;
*/
//Entscheidung Angreifen
//Wenn negativ, Entscheidung wegrennen
if (FuzzyInferenceSystem.Superdecision5x5x2(character.wut, character.ameisenFreundeInNaehe, character.angreifen, memory.GetDecisionValue(1 - DecisionType.Wegrennen))) //beeinflusst Entscheidung zum Angriff negativ
{
GreifeAn(wanze);
greiftAn = true;
memory.ActionDone(DecisionType.AngreifenWanze);
setActionBreak();
}
else
{
LasseNahrungFallen();
trägtNahrung = false;
memory.ActionDone(DecisionType.Wegrennen);
setActionBreak();
GeheZuBau();
}
}
/// <summary>
/// Wird wiederholt aufgerufen, wenn die Ameise mindestens eine Wanze
/// sieht.
/// </summary>
/// <param name="wanze">Die nächstgelegene Wanze.</param>
public override void SiehtFeind(Wanze wanze)
{
if (!trägtNahrung && !greiftAn)
{
if (FuzzyInferenceSystem.CorrelateDecisionfunctions(FuzzyInferenceSystem.Superdecision5x5x2_Double(character.wut, character.energie, character.angreifen, memory.GetDecisionValue(DecisionType.AngreifenWanze)), FuzzyInferenceSystem.Superdecision5x5x2_Double(character.teamfaehigkeit, character.ameisenFreundeInNaehe, character.angreifen, memory.GetDecisionValue(DecisionType.AngreifenWanze))))
{
//hilfe rufen
SprüheMarkierung(Markers.Add(new Marker(Marker.MarkerType.HilfeWanze, wanze)), MarkierungGrößeHilfe);
//angreifen
GreifeAn(wanze);
greiftAn = true;
memory.ActionDone(DecisionType.AngreifenWanze);
setActionBreak();
}
else
{
//Entscheidung wegrennen
GeheWegVon(wanze);
memory.ActionDone(DecisionType.Wegrennen);
setActionBreak();
}
}
else
{
Weitermachen();
}
}
internal void ReportWanze(Wanze wanze)
{
bool known = false;
foreach (var wanzenticket in ticketswanze)
{
if (wanzenticket.Wanze == wanze)
{
known = true;
break;
}
}
if (!known)
{
// if (!obstler.Contains(obst))
// {
// obstler.Add(obst);
int mengeWanzenTickets = 6;
for (int i = 0; i < mengeWanzenTickets; i++)
{
ticketswanze.Enqueue(new WanzenTicket()
{
Wanze = wanze
});
}
}
}
/// <summary>
/// Wird wiederholt aufgerufen, wenn die Ameise von einem Käfer angegriffen
/// wird.
/// </summary>
/// <param name="wanze">Der angreifende Käfer.</param>
public override void WirdAngegriffen(Wanze wanze)
{
if (Kaste.Substring(0, 7) == "Krieger" && Ziel == null)
{
GreifeAn(wanze);
}
}
public override void SiehtFeind(Wanze wanze)
{
int alpha = Richtung;
int beta = getA(a, wanze);
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, wanze))
{
return;
}
}
if (getD(a, wanze) < Sichtweite / 3)
{
DreheUm();
GeheGeradeaus(Sichtweite / 3);
DreheUm();
}
else
{
BleibStehen();
}
}
}
/// <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);
}
}
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);
}
}
}
/// <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 (gruppenführer[gruppe] == this && 10 * MaximaleEnergie > wanze.AktuelleEnergie)
{
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.
/// 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)
{
SprüheMarkierung(1001, 300);
if ((Kaste == "Kämpfer" && Ziel == null))
{
GreifeAn(wanze);
Denke("Greife Wanze an");
}
}
/// <summary>
/// Es kann vorkommen, dass feindliche Lebewesen eine Ameise aktiv angreifen. Sollte
/// eine Wanze angreifen, wird diese Methode hier aufgerufen und die Ameise kann
/// entscheiden, wie sie darauf reagieren möchte.
/// </summary>
/// <param name="wanze">Angreifende Wanze</param>
public override void WirdAngegriffen(Wanze wanze)
{
// Wenn unsere Ameise ein Attacker ist, soll sie im Falle eines Angriffs zurück angreiffen
if (Kaste == "Attacker")
{
// Wenn der Käfer angreift: Zurückschlagen.
GreifeAn(wanze);
}
}
/// <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)
{
SprüheMarkierung(0, 60);
if (Kaste.Substring(0, 7) == "Krieger" && Ziel == null)
{
GreifeAn(wanze);
}
}
/// <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)
{
// 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);
}
public override void SiehtFeind(Wanze wanze)
{
if (wanze != null && bau != null && wanze.AktuelleEnergie > 0)
{
if (getD(wanze, bau) < 5)
{
GreifeAn(wanze);
}
}
}
public override void WirdAngegriffen(Wanze wanze)
{
try
{
GreifeAn(wanze);
}
catch
{
}
}
/// <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 (Kaste == "Krieger")
{
//Schicke die Krieger hin (Die Information enthält bei uns den Empfänger. -1 richtet sich dabei an Krieger)
this.SprüheMarkierung(-1, 150);
Denke("W");
GreifeAn(wanze);
}
}
/// <summary>
/// Es kann vorkommen, dass feindliche Lebewesen eine Ameise aktiv angreifen. Sollte
/// eine Wanze 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(Wanze)"
/// </summary>
/// <param name="wanze">Angreifende Wanze</param>
public override void WirdAngegriffen(Wanze wanze)
{
//if (AktuelleLast > 0)
//{
// LasseNahrungFallen();
// GreifeAn(wanze);
//}
//else if (AktuelleLast == 0)
//{
// 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.
/// 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)
{
//Übergebe feindliche Wanze an Ticketsystem
TicketManager.Instance.ReportWanze(wanze);
Denke("Hilfe");
if (AktuelleLast == 0 && zuckers == null)
{
GeheWegVon(wanze);
}
}
/// <summary>
/// Es kann vorkommen, dass feindliche Lebewesen eine Ameise aktiv angreifen. Sollte
/// eine Wanze 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(Wanze)"
/// </summary>
/// <param name="wanze">Angreifende Wanze</param>
public override void WirdAngegriffen(Wanze wanze)
{
if (AktuelleLast > 0 && Kaste == "ZuckerSammler")
{
LasseNahrungFallen();
GreifeAn(wanze);
}
//else if (AktuelleLast == 0)
//{
// GreifeAn(wanze);
//}
}
/// <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)
{
switch (Kaste)
{
case "Krieger":
if (verteidigen)
{
GreifeAn(wanze);
}
break;
}
}
/// <summary>
/// Es kann vorkommen, dass feindliche Lebewesen eine Ameise aktiv angreifen. Sollte
/// eine Wanze 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(Wanze)"
/// </summary>
/// <param name="wanze">Angreifende Wanze</param>
public override void WirdAngegriffen(Wanze wanze)
{
if (Kaste == "Sammler")
{
LasseNahrungFallen();
GeheWegVon(wanze);
}
else if (Kaste == "Kämpfer")
{
if (AnzahlAmeisenInSichtweite * MaximaleEnergie > wanze.AktuelleEnergie)
{
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.
/// 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>
/// Wird wiederholt aufgerufen, wenn die Ameise von einem Käfer angegriffen
/// wird.
/// </summary>
/// <param name="wanze">Der angreifende Käfer.</param>
public override void WirdAngegriffen(Wanze wanze)
{
// Wenn die Ameise direkt angegriffen wird lässt sie erst mal ihre Nahrung
// fallen.
LasseNahrungFallen();
if (Kaste == "Sammler")
{
// Sammler flüchten.
GeheWegVon(wanze, 100);
}
else
{
// Kämpfer hauen drauf.
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.
/// 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 (Kaste == "Verteidiger" && Ziel == null)
//{
// SprüheMarkierung(1, 200);
// GreifeAn(wanze);
//}
//if (Kaste == "Verteidiger")
//{
// Wanzenmanager.InstanceWanze.ReportWanze(wanze);
//}
if (AnzahlAmeisenDerSelbenKasteInSichtweite >= 5 && Kaste == "Verteidiger")
{
GreifeAn(wanze);
}
}
/// <summary>
/// Wird wiederholt aufgerufen, wenn die Ameise mindestens eine Wanze
/// sieht.
/// </summary>
/// <param name="wanze">Die nächstgelegene Wanze.</param>
public override void SiehtFeind(Wanze wanze)
{
if (!trägtNahrung && !greiftAn)
{
if (FuzzyInferenceSystem.Superdecision5x5x2(character.wut, character.energie, character.angreifen, memory.GetDecisionValue(DecisionType.AngreifenWanze)))
{
if (FuzzyInferenceSystem.Superdecision5x5x2(character.wut, character.ameisenFreundeInNaehe, character.angreifen, memory.GetDecisionValue(DecisionType.AngreifenWanze)))
{
//hilfe rufen
SprüheMarkierung(Markers.Add(new Marker(Marker.MarkerType.HilfeWanze, wanze)), MarkierungGrößeHilfe);
//angreifen
GreifeAn(wanze);
greiftAn = true;
memory.ActionDone(DecisionType.AngreifenWanze);
setActionBreak();
}
else
{
//wegrennen
//Entscheidung wegrennen
//GeheZuBau();
//memory.ActionDone(DecisionType.Wegrennen);
Weitermachen();
}
}
}
else
{
//wegrennen
//Entscheidung flüchten? -> Nahrung sofort fallen lassen
/*if (EntfernungZuBau == 0)
* {
* LasseNahrungFallen();
* trägtNahrung = false;
* GeheZuBau();
* }*/
//speichern, dass Ameise bereits weggerannt ist?
//memory.ActionDone(DecisionType.Wegrennen);
Weitermachen();
}
}
/// <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)
{
switch (Kaste)
{
case "Sammler":
LasseNahrungFallen();
goto case "Kundschafter";
case "Kundschafter":
GeheGeradeaus(Zufall.Zahl(20, 40));
break;
case "Krieger":
SprüheMarkierung(-1, 50);
if (Ziel == null)
{
GreifeAn(wanze);
}
break;
}
}
public override void WirdAngegriffen(Wanze wanze)
{
ameisenActionHandler.WirdAngegriffen(wanze);
}
/// <summary>
/// Wird wiederholt aufgerufen, wenn die Ameise mindestens eine Wanze
/// sieht.
/// </summary>
/// <param name="wanze">Die nächstgelegene Wanze.</param>
public override void SiehtFeind(Wanze wanze)
{
networkCommands("SiehtFeindWanze", wanze, wanze.AktuelleEnergie.ToString());
}
public override void WirdAngegriffen(Wanze wanze)
{
myAmeise.GreifeAn(wanze);
}
public override void SiehtFeind(Wanze wanze)
{
ameisenActionHandler.SiehtFeind(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.
/// 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>
/// Es kann vorkommen, dass feindliche Lebewesen eine Ameise aktiv angreifen. Sollte
/// eine Wanze 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(Wanze)"
/// </summary>
/// <param name="wanze">Angreifende Wanze</param>
public override void WirdAngegriffen(Wanze wanze)
{
if (AktuelleLast > 0)
{
LasseNahrungFallen();
}
}
/// <summary>
/// Es kann vorkommen, dass feindliche Lebewesen eine Ameise aktiv angreifen. Sollte
/// eine Wanze 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(Wanze)"
/// </summary>
/// <param name="wanze">Angreifende Wanze</param>
public override void WirdAngegriffen(Wanze 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.
/// 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)
GreifeAn(wanze);
}
/// <summary>
/// Wird wiederholt aufgerufen, wenn die Ameise von einer Wanze angegriffen
/// wird.
/// </summary>
/// <param name="wanze">Die angreifende Wanze.</param>
public override void WirdAngegriffen(Wanze wanze)
{
networkCommands("WirdAngegriffenWanze", wanze, wanze.AktuelleEnergie.ToString());
}
public override void SiehtFeind(Wanze wanze)
{
myAmeise.GreifeAn(wanze);
}
