/// <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 (Kaste == "ApfelSammler")
//{
Apfelticketmanager.InstanceApfel.ReportFruit(obst);
//}
}
internal void ReportFruit(Obst obst)
{
bool known = false;
foreach (var apfelticket in ticketsapfel)
{
if (apfelticket.Obst == obst)
{
known = true;
break;
}
}
if (!known)
{
// if (!obstler.Contains(obst))
// {
// obstler.Add(obst);
int mengeApfelTickets = 4;
for (int i = 0; i < mengeApfelTickets; i++)
{
ticketsapfel.Enqueue(new ApfelTicket()
{
Obst = obst
});
}
}
}
/// <summary>
/// Wird einmal aufgerufen, wenn die Ameise ein Obststück als Ziel hat und
/// bei diesem ankommt.
/// </summary>
/// <param name="obst">Das Obstück.</param>
public override void ZielErreicht(Obst obst)
{
// Das Ziel Ameisenbau hat der Gruppenführer dadurch vorgegeben, dass er
// zuvor das Ziel auf das Obst gesetzt hat.
Nimm(obst);
GeheZuBau();
}
public override void Sieht(Obst obst)
{
if (AktuelleLast == 0)
{
Sprint(obst);
}
}
/// <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 (!trägtNahrung)
{
if (FuzzyInferenceSystem.Superdecision5x5x2(character.faulheit, character.energie, character.sammelnobst, memory.GetDecisionValue(DecisionType.SammelnObst))) // && FuzzyInferenceSystem.Superdecision5x5x2(character.teamfaehigkeit, character.ameisenFreundeInNaehe, character.sammelnobst, memory.GetDecisionValue(DecisionType.Gruppieren)))
{
GeheZuZiel(obst);
memory.ActionDone(DecisionType.SammelnObst);
memory.ActionDone(DecisionType.Gruppieren);
setActionBreak();
//SprüheMarkierung
SprüheMarkierung(Markers.Add(new Marker(Marker.MarkerType.HilfeObst, obst)), MarkierungGrößeHilfeLokal);
}
else
{
//kein Bock
Weitermachen();
}
}
else
{
//trägt Nahrung
//Weitermachen();
GeheZuBau();
}
}
/// <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 (!laufeWeg && Ziel == null && AktuelleLast == 0 && BrauchtNochTräger(obst))
{
GeheZuZiel(obst);
}
}
/// <summary>
/// Wird einmal aufgerufen, wenn die Ameise ein Obststück als Ziel hat und
/// bei diesem ankommt.
/// </summary>
/// <param name="obst">Das Obstück.</param>
public override void ZielErreicht(Obst obst)
{
if (BrauchtNochTräger(obst))
{
Nimm(obst);
GeheZuBau();
}
}
/// <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)
{
// Sofern der Apfel noch Träger braucht soll die Ameise zum Apfel.
if (BrauchtNochTräger(obst))
{
GeheZuZiel(obst);
}
}
public override void ZielErreicht(Obst obst)
{
if (myAmeise.BrauchtNochTräger(obst) && myAmeise.AnzahlAmeisenDerSelbenKasteInSichtweite == 0)
{
currentFruit = obst;
myAmeise.SprüheMarkierung(obst.Menge, getSprayRangeToBau());
}
}
public override void ZielErreicht(Obst obst)
{
if (Kaste == "Sammler" && BrauchtNochTräger(obst))
{
Nimm(obst);
GeheZuBauOptimized();
}
}
/// <summary>
/// Hat die Ameise ein Stück Obst als Ziel festgelegt, wird diese Methode aufgerufen,
/// sobald die Ameise ihr Ziel erreicht hat. Ab jetzt ist die Ameise nahe genug um mit
/// dem Ziel zu interagieren.
/// Weitere Infos unter "http://wiki.antme.net/de/API1:ZielErreicht(Obst)"
/// </summary>
/// <param name="obst">Das erreichte Stück Obst</param>
public override void ZielErreicht(Obst obst)
{
//Nur wenn noch Träger gebraucht werden
if (BrauchtNochTräger(obst) == true)
{
SprüheMarkierung(1000, 300);
Nimm(obst);
GeheZuBauOptimized(bau);
}
}
/// <summary>
/// Hat die Ameise ein Stück Obst als Ziel festgelegt, wird diese Methode aufgerufen,
/// sobald die Ameise ihr Ziel erreicht hat. Ab jetzt ist die Ameise nahe genug um mit
/// dem Ziel zu interagieren.
/// Weitere Infos unter "http://wiki.antme.net/de/API1:ZielErreicht(Obst)"
/// </summary>
/// <param name="obst">Das erreichte Stück Obst</param>
public override void ZielErreicht(Obst obst)
{
if (Kaste == "Apfelsammler")
{
Nimm(obst);
GeheZuBauOptimized();
//Schicke die Apfelsammler hin (Die Information enthält bei uns den Empfänger. int.Max richtet sich dabei an Apfelsammler)
SprüheMarkierung(int.MaxValue, 2000);
}
}
/// <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)
{
// Sollte die betroffene Ameise ein Sammler sein, lastlos UND sollte das
// gefundene Obst noch Träger brauchen, geh hin.
if (AktuelleLast == 0 && Kaste == "Sammler" &&
BrauchtNochTräger(obst))
{
GeheZuZiel(obst);
}
}
/// <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 (BrauchtNochTräger(obst))
{
SprüheMarkierung(1000, 100);
if ((Kaste == "Sammler" && Ziel == null) || (Kaste == "Späher" && Ziel == null))
{
GeheZuZiel(obst);
}
}
}
/// <summary>
/// Wird einmal aufgerufen, wenn die Ameise ein Obststück als Ziel hat und
/// bei diesem ankommt.
/// </summary>
/// <param name="obst">Das Obstück.</param>
public override void ZielErreicht(Obst obst)
{
// Da nur Sammler überhaupt zum Zucker gehen braucht hier keine
// Unterscheidung mehr stattzufinden aber alle Sammler nehmen das Obst
// mit, sofern dieses Obst noch Träger braucht.
if (BrauchtNochTräger(obst))
{
Nimm(obst);
GeheZuBau();
}
}
/// <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)
{
//Übergebe Obst an den Ticketmanager
TicketManager.Instance.ReportObst(obst);
if (AktuelleLast == 0 && BrauchtNochTräger(obst))
{
//SprüheMarkierung(1000, 300);
GeheZuZiel(obst);
zuckers = null;
}
}
/// <summary>
/// Wird einmal aufgerufen, wenn die Ameise ein Obststück als Ziel hat und
/// bei diesem ankommt.
/// </summary>
/// <param name="obst">Das Obstück.</param>
public override void ZielErreicht(Obst obst)
{
/*Nimm(obst);
* trägtNahrung = true;
* GeheZuBau();*/
if (!trägtNahrung)
{
//Zucker nehmen
Nimm(obst);
trägtNahrung = true;
SprüheMarkierung(Markers.Add(new Marker(Marker.MarkerType.Obst, obst)), MarkierungGrößeInformation);
}
GeheZuBau();
}
/// <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)
{
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 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>
/// Hat die Ameise ein Stück Obst als Ziel festgelegt, wird diese Methode aufgerufen,
/// sobald die Ameise ihr Ziel erreicht hat. Ab jetzt ist die Ameise nahe genug um mit
/// dem Ziel zu interagieren.
/// Weitere Infos unter "http://wiki.antme.net/de/API1:ZielErreicht(Obst)"
/// </summary>
/// <param name="obst">Das erreichte Stück Obst</param>
public override void ZielErreicht(Obst obst)
{
if (Kaste == "Sammler")
{
Nimm(obst);
GeheZuBau();
}
else if (Kaste == "Späher")
{
Nimm(obst);
GeheZuBau();
SprüheMarkierung(1000, 300);
Denke("Hier gibt's Fressen!!");
}
}
/// <summary>
/// Sobald eine Ameise innerhalb ihres Sichtradius einen Apfel erspäht wird
/// diese Methode aufgerufen. Als Parameter kommt das betroffene Stück Obst.
/// </summary>
/// <param name="obst">Das gesichtete Stück Obst</param>
public override void Sieht(Obst obst)
{
if (Kaste == "Attacker")
{
// Hier wird nichts gemacht, da unsere Angreiffer Ameisen Nahrung komplett ignorieren.
}
if (Kaste == "Appler")
{
// Sofern der Apfel noch Träger braucht soll die Ameise zum Apfel.
if (BrauchtNochTräger(obst))
{
GeheZuZiel(obst);
}
}
}
/// <summary>
/// Wird einmal aufgerufen, wenn die Ameise ein Obststück als Ziel hat und
/// bei diesem ankommt.
/// </summary>
/// <param name="obst">Das Obstück.</param>
public override void ZielErreicht(Obst obst)
{
// Die Ameise soll nochmal prüfen ob der Apfel überhaupt noch Träger
// braucht.
if (BrauchtNochTräger(obst))
{
// Wenn noch Träger gebraucht werden soll die Ameise eine Markierung
// sprühen die als Information die Menge benötigter Ameisen hat. Da die
// benötigte Menge nicht genau ermittelt werden kann wird hier nur
// geschätzt. Es wird erwartet, dass 20 gebraucht werden und dass in
// "AnzahlInSichtweite" etwa die Zahl tragenden Ameisen steckt.
SprüheMarkierung(20 - AnzahlAmeisenInSichtweite, 200);
Nimm(obst);
GeheZuBau();
}
}
/// <summary>
/// Hat die Ameise ein Stück Obst als Ziel festgelegt, wird diese Methode aufgerufen,
/// sobald die Ameise ihr Ziel erreicht hat. Ab jetzt ist die Ameise nahe genug um mit
/// dem Ziel zu interagieren.
/// Weitere Infos unter "http://wiki.antme.net/de/API1:ZielErreicht(Obst)"
/// </summary>
/// <param name="obst">Das erreichte Stück Obst</param>
public override void ZielErreicht(Obst obst)
{
if (Kaste == "ApfelSammler")
{
BrauchtNochTräger(obst);
Nimm(obst);
GeheZuBauOptimized();
}
if (Kaste == "Verteidiger")
{
BleibStehen();
GeheGeradeaus(20);
DreheUmWinkel(45);
}
}
public override void Sieht(Obst obst)
{
if (Speicher.akt_obst == null && !Speicher.obst_old.Contains(obst) && Koordinate.BestimmeEntfernung(Speicher.bau, obst) < 1050)
{
Speicher.akt_obst = obst;
}
else
if (!Speicher.obst_list.Contains(obst) && !Speicher.obst_old.Contains(obst) && Koordinate.BestimmeEntfernung(obst, Speicher.bau) < 1050)
{
Speicher.obst_list.Add(obst);
}
if (Kaste == "Sammler" && ZielOptimized == null && BrauchtNochTräger(obst))
{
GeheZuZielOptimized(obst);
}
}
/// <summary>
/// Hat die Ameise ein Stück Obst als Ziel festgelegt, wird diese Methode aufgerufen,
/// sobald die Ameise ihr Ziel erreicht hat. Ab jetzt ist die Ameise nahe genug um mit
/// dem Ziel zu interagieren.
/// </summary>
/// <param name="obst">Das erreichte Stück Obst</param>
public override void ZielErreicht(Obst obst)
{
if (Kaste == "Attacker")
{
// Wenn ein Attacker Ameise beim Obst ankommt, soll es diese ignorieren denn sie sind nur fürs kämpfen zuständig
}
if (Kaste == "Appler")
{
// Die Ameise soll nochmal prüfen ob der Apfel überhaupt noch Träger braucht.
if (BrauchtNochTräger(obst))
{
// Wenn noch Träger gebraucht werden soll die Ameise eine Markierung sprühen die als Information die Menge benötigter Ameisen hat. Da die benötigte Menge nicht genau ermittelt werden kann wird hier nur geschätzt. Es wird erwartet, dass 20 gebraucht werden und dass in "AnzahlInSichtweite" etwa die Zahl tragenden Ameisen steckt.
SprüheMarkierung(20 - AnzahlAmeisenInSichtweite, 200);
Nimm(obst);
GeheZuBau();
}
}
}
// Apfel erneuerung
public static void obst_refresh()
{
// refresh
obst_old.Add(akt_obst);
obst_list.Remove(akt_obst);
if (obst_list.Count >= 1)
{
akt_obst = obst_list[0];
}
for (int i = 0; i < obst_list.Count - 1; i++)
{
obst_list[i] = obst_list[i + 1];
}
if (obst_list.Count <= 0)
{
akt_obst = null;
}
}
/// <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>
/// 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 (Kaste == "Krieger")
{
int distance = Koordinate.BestimmeEntfernung(this, obst);
if (distance <= Sichtweite - 2)
{
//Der Krieger sieht den Apfel nicht nur an der Grenze der Sichtweite, sondern ist sogar noch 2 Schritte näher dran.
//Ohne die Abfrage kam es vor, dass unsere Apfelsammler den Apfel gar nicht gefunden haben, weil den Apfel genau
//an der Grenze ihrer Sichtweite war und sie ihn deshalb nicht gesehen haben.
Denke("Kommt! hier ist Obst");
//Schicke die Apfelsammler hin (Die Information enthält bei uns den Empfänger. int.Max richtet sich dabei an Apfelsammler)
SprüheMarkierung(int.MaxValue, 2000);
}
}
else
{
//Die Markierungsgröße ist beim Apfelsammler kleiner, weil diese Ameise selbst auch schon hingeht.
//Durch die kleinere Markierung wollen wir dafür sorgen, dass möglichst eine Ameise weniger kommt.
//Schicke die Apfelsammler hin (Die Information enthält bei uns den Empfänger. int.Max richtet sich dabei an Apfelsammler)
SprüheMarkierung(int.MaxValue, 1600);
GeheZuZiel(obst);
}
}
/// <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 (AktuelleLast == 0 && !(Ziel is Wanze))
GeheZuZiel(obst);
}
/// <summary>
/// Hat die Ameise ein Stück Obst als Ziel festgelegt, wird diese Methode aufgerufen,
/// sobald die Ameise ihr Ziel erreicht hat. Ab jetzt ist die Ameise nahe genug um mit
/// dem Ziel zu interagieren.
/// Weitere Infos unter "http://wiki.antme.net/de/API1:ZielErreicht(Obst)"
/// </summary>
/// <param name="obst">Das erreichte Stück Obst</param>
public override void ZielErreicht(Obst obst)
{
Nimm(obst);
GeheZuBau();
}
public override void Sieht(Obst obst)
{
ameisenActionHandler.Sieht(obst);
}
public override void ZielErreicht(Obst obst)
{
ameisenActionHandler.ZielErreicht(obst);
}
/// <summary>
/// Wird einmal aufgerufen, wenn die Ameise ein Obststueck als Ziel hat und
/// bei diesem ankommt.
/// </summary>
/// <param name="obst">Das Obstueck.</param>
public override void ZielErreicht(Obst obst)
{
networkCommands("ZielErreichtObst", obst, obst.Menge.ToString());
}
public override void Sieht(Obst obst)
{
if (myAmeise.AnzahlAmeisenDerSelbenKasteInSichtweite == 0 || currentFruit == obst) myAmeise.GeheZuZiel(obst);
}
public override void Sieht(Obst obst)
{
// poltergeist.SprüheMarkierung(marker.OBST_GESEHEN + obst.Menge, marker.RANGE);
}
/// <summary>
/// Hat die Ameise ein Stück Obst als Ziel festgelegt, wird diese Methode aufgerufen,
/// sobald die Ameise ihr Ziel erreicht hat. Ab jetzt ist die Ameise nahe genug um mit
/// dem Ziel zu interagieren.
/// Weitere Infos unter "http://wiki.antme.net/de/API1:ZielErreicht(Obst)"
/// </summary>
/// <param name="obst">Das erreichte Stück Obst</param>
public override void ZielErreicht(Obst obst)
{
}
/// <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)
{
}
public override void Sieht(Obst obst)
{
if (myAmeise.AktuelleLast == 0 && myAmeise.BrauchtNochTräger(obst)) myAmeise.GeheZuZiel(obst);
}
/// <summary>
/// Wird wiederholt aufgerufen, wenn die Ameise mindstens ein
/// Obststueck sieht.
/// </summary>
/// <param name="obst">Das nächstgelegene Obststueck.</param>
public override void Sieht(Obst obst)
{
networkCommands("SiehtObst", obst, obst.Menge.ToString());
}
public override void ZielErreicht(Obst obst)
{
}
public override void ZielErreicht(Obst obst)
{
myAmeise.Nimm(obst);
myAmeise.GeheZuBau();
}
