/// <summary>
/// Erntfernt Ameisen die keine Energie mehr haben.
/// </summary>
/// <param name="colony">betroffenes Volk</param>
private void removeAnt(CoreColony colony)
{
List <CoreAnt> liste = new List <CoreAnt>();
for (int i = 0; i < colony.VerhungerteInsekten.Count; i++)
{
CoreAnt ant = colony.VerhungerteInsekten[i] as CoreAnt;
if (ant != null && !liste.Contains(ant))
{
liste.Add(ant);
colony.Statistik.StarvedAnts++;
PlayerCall.HasDied(ant, CoreKindOfDeath.Starved);
}
}
for (int i = 0; i < colony.EatenInsects.Count; i++)
{
CoreAnt ant = colony.EatenInsects[i] as CoreAnt;
if (ant != null && !liste.Contains(ant))
{
liste.Add(ant);
colony.Statistik.EatenAnts++;
PlayerCall.HasDied(ant, CoreKindOfDeath.Eaten);
}
}
for (int i = 0; i < colony.BeatenInsects.Count; i++)
{
CoreAnt ant = colony.BeatenInsects[i] as CoreAnt;
if (ant != null)
{
if (!liste.Contains(ant))
{
liste.Add(ant);
colony.Statistik.BeatenAnts++;
PlayerCall.HasDied(ant, CoreKindOfDeath.Beaten);
}
}
}
for (int i = 0; i < liste.Count; i++)
{
CoreAnt ant = liste[i];
if (ant != null)
{
colony.EntferneInsekt(ant);
for (int j = 0; j < Playground.Fruits.Count; j++)
{
CoreFruit fruit = Playground.Fruits[j];
fruit.TragendeInsekten.Remove(ant);
}
}
}
colony.VerhungerteInsekten.Clear();
colony.EatenInsects.Clear();
colony.BeatenInsects.Clear();
}
/// <summary>
/// Prüft ob die Ameise eine Markierung bemerkt.
/// </summary>
/// <param name="ameise">betroffene Ameise</param>
private static void ameiseUndMarkierungen(CoreAnt ameise)
{
CoreMarker marker = ameise.colony.Marker.FindMarker(ameise);
if (marker != null)
{
PlayerCall.SmellsFriend(ameise, marker);
ameise.SmelledMarker.Add(marker);
}
}
/// <summary>
/// Entfernt abgelaufene Markierungen und erzeugt neue Markierungen.
/// </summary>
/// <param name="colony">betroffenes Volk</param>
private static void aktualisiereMarkierungen(CoreColony colony)
{
// TODO: Settings berücksichtigen
// Markierungen aktualisieren und inaktive Markierungen löschen.
List <CoreMarker> gemerkteMarkierungen = new List <CoreMarker>();
foreach (CoreMarker markierung in colony.Marker)
{
if (markierung.IstAktiv)
{
markierung.Aktualisieren();
}
else
{
gemerkteMarkierungen.Add(markierung);
}
}
gemerkteMarkierungen.ForEach(delegate(CoreMarker marker)
{
colony.Insects.ForEach(delegate(CoreInsect insect)
{
CoreAnt ant = insect as CoreAnt;
if (ant != null)
{
ant.SmelledMarker.Remove(marker);
}
});
});
colony.Marker.Remove(gemerkteMarkierungen);
// Neue Markierungen überprüfen und hinzufügen.
gemerkteMarkierungen.Clear();
colony.NewMarker.ForEach(delegate(CoreMarker newMarker)
{
bool zuNah = false;
foreach (CoreMarker markierung in colony.Marker)
{
int entfernung =
CoreCoordinate.BestimmeEntfernungDerMittelpunkteI
(markierung.CoordinateBase, newMarker.CoordinateBase);
if (entfernung < SimulationSettings.Custom.MarkerDistance * PLAYGROUND_UNIT)
{
zuNah = true;
break;
}
}
if (!zuNah)
{
colony.Marker.Add(newMarker);
}
});
colony.NewMarker.Clear();
}
/// <summary>
/// Prüft ob eine Ameise ein Obsstück sieht.
/// </summary>
/// <param name="ameise">betroffene Ameise</param>
private void ameiseUndObst(CoreAnt ameise)
{
for (int i = 0; i < Playground.Fruits.Count; i++)
{
CoreFruit obst = Playground.Fruits[i];
int entfernung = CoreCoordinate.BestimmeEntfernungI(ameise.CoordinateBase, obst.CoordinateBase);
if (ameise.ZielBase != obst && entfernung <= ameise.SichtweiteI)
{
PlayerCall.Spots(ameise, obst);
}
}
}
/// <summary>
/// Prüft ob eine Ameise einen Zuckerhaufen sieht.
/// </summary>
/// <param name="ant">betroffene Ameise</param>
private void ameiseUndZucker(CoreAnt ant)
{
for (int i = 0; i < Playground.SugarHills.Count; i++)
{
CoreSugar sugar = Playground.SugarHills[i];
int entfernung = CoreCoordinate.BestimmeEntfernungI(ant.CoordinateBase, sugar.CoordinateBase);
if (ant.ZielBase != sugar && entfernung <= ant.SichtweiteI)
{
PlayerCall.Spots(ant, sugar);
}
}
}
/// <summary>
/// Prüft ob eine Ameise an ihrem Ziel angekommen ist.
/// </summary>
/// <param name="ant">betroffene Ameise</param>
private static void ameiseUndZiel(CoreAnt ant)
{
// Ameisenbau.
if (ant.ZielBase is CoreAnthill)
{
if (ant.GetragenesObstBase == null)
{
ant.ZurückgelegteStreckeI = 0;
ant.ZielBase = null;
ant.SmelledMarker.Clear();
ant.colony.Statistik.CollectedFood += ant.AktuelleLastBase;
ant.AktuelleLastBase = 0;
ant.AktuelleEnergieBase = ant.MaximaleEnergieBase;
ant.IstMüdeBase = false;
}
}
// Zuckerhaufen.
else if (ant.ZielBase is CoreSugar)
{
CoreSugar zucker = (CoreSugar)ant.ZielBase;
ant.ZielBase = null;
if (zucker.Menge > 0)
{
PlayerCall.TargetReached(ant, zucker);
}
}
// Obststück.
else if (ant.ZielBase is CoreFruit)
{
CoreFruit obst = (CoreFruit)ant.ZielBase;
ant.ZielBase = null;
if (obst.Menge > 0)
{
PlayerCall.TargetReached(ant, obst);
}
}
// Insekt.
else if (ant.ZielBase is CoreInsect)
{
}
// Anderes Ziel.
else
{
ant.ZielBase = null;
}
}
/// <summary>
/// Perform call to "HasDied()" on given ant.
/// </summary>
/// <param name="ant">ant</param>
/// <param name="kindOfDeath">kind of death</param>
public static void HasDied(CoreAnt ant, CoreKindOfDeath kindOfDeath)
{
AreaChanged(
null, new AreaChangeEventArgs(ant.colony.Player, Area.HasDied));
playerRights.PermitOnly();
try {
ant.IstGestorbenBase(kindOfDeath);
}
catch (Exception ex) {
throw new AiException("KI-Fehler in der IstGestorben()-Methode", ex);
}
AreaChanged(
null, new AreaChangeEventArgs(null, Area.Unknown));
}
/// <summary>
/// Perform call to "BecomesTired()" on given ant.
/// </summary>
/// <param name="ant">ant</param>
public static void BecomesTired(CoreAnt ant)
{
AreaChanged(
null, new AreaChangeEventArgs(ant.colony.Player, Area.BecomesTired));
playerRights.PermitOnly();
ant.NimmBefehleEntgegen = true;
try {
ant.WirdMüdeBase();
}
catch (Exception ex) {
throw new AiException("KI-Fehler in der WirdMüde()-Methode", ex);
}
ant.NimmBefehleEntgegen = false;
AreaChanged(
null, new AreaChangeEventArgs(null, Area.Unknown));
}
/// <summary>
/// Perform call to "SpotsTeamMember()" on given ant.
/// </summary>
/// <param name="ant">ant</param>
/// <param name="friend">friendly ant</param>
public static void SpotsTeamMember(CoreAnt ant, CoreAnt friend)
{
AreaChanged(
null, new AreaChangeEventArgs(ant.colony.Player, Area.SpotsTeamMember));
playerRights.PermitOnly();
ant.NimmBefehleEntgegen = true;
try {
ant.SiehtVerbündetenBase(friend);
}
catch (Exception ex) {
throw new AiException("KI-Fehler in der SiehtVerbündeten(Ameise)-Methode", ex);
}
ant.NimmBefehleEntgegen = false;
AreaChanged(
null, new AreaChangeEventArgs(null, Area.Unknown));
}
/// <summary>
/// Perform call to "SmellsFriend()" on given ant.
/// </summary>
/// <param name="ant">ant</param>
/// <param name="marker">marker</param>
public static void SmellsFriend(CoreAnt ant, CoreMarker marker)
{
AreaChanged(
null, new AreaChangeEventArgs(ant.colony.Player, Area.SmellsFriend));
playerRights.PermitOnly();
ant.NimmBefehleEntgegen = true;
try {
ant.RiechtFreundBase(marker);
}
catch (Exception ex) {
throw new AiException("KI-Fehler in der RiechtFreund(Markierung)-Methode", ex);
}
ant.NimmBefehleEntgegen = false;
AreaChanged(
null, new AreaChangeEventArgs(null, Area.Unknown));
}
/// <summary>
/// Perform call to "Spots(Ant)" on given ant.
/// </summary>
/// <param name="ant">ant</param>
/// <param name="enemy">foreign ant</param>
public static void SpotsEnemy(CoreAnt ant, CoreAnt enemy)
{
AreaChanged(
null, new AreaChangeEventArgs(ant.colony.Player, Area.SpotsEnemy));
playerRights.PermitOnly();
ant.NimmBefehleEntgegen = true;
try {
ant.SiehtFeindBase(enemy);
}
catch (Exception ex) {
throw new AiException("KI-Fehler in der SiehtFeind(Ameise)-Methode", ex);
}
ant.NimmBefehleEntgegen = false;
AreaChanged(
null, new AreaChangeEventArgs(null, Area.Unknown));
}
/// <summary>
/// Findet die Markierung, die die gegebene Ameise noch nicht gerochen hat
/// und die der Ameise am nächsten liegt.
/// </summary>
/// <remarks>
/// Die Simulation legt ein Gitter mit dem maximalen Radius einer Markierung als
/// Seitenlänge an und benutzt diese Methode auf dieser Instanz zum Finden von
/// Markierungen. In dieses Gitter werden nur Markierungen einsortiert.
/// </remarks>
/// <param name="ant">Die Referenzameise.</param>
/// <returns>Eine Markierung.</returns>
public CoreMarker FindMarker(CoreAnt ant)
{
CoreMarker nearestMarker = null;
int nearestMarkerDistance = int.MaxValue;
// Bestimme die Zelle in der die übergebene Ameise sich befindet.
int col = ant.CoordinateBase.X / sideLength;
int row = ant.CoordinateBase.Y / sideLength;
// Betrachte die Zelle und die acht Zellen daneben.
for (int c = -1; c <= 1; c++)
{
if (col + c >= 0 && col + c < columns)
{
for (int r = -1; r <= 1; r++)
{
if (row + r >= 0 && row + r < rows)
{
List <T> cell = cells[col + c, row + r];
// Betrachte alle Markierungen in der aktuellen Zelle.
for (int i = 0; i < cell.Count; i++)
{
CoreMarker marker = cell[i] as CoreMarker;
Debug.Assert(marker != null);
// Bestimme die Entfernung der Mittelpunkte und der Kreise.
int distance = CoreCoordinate.BestimmeEntfernungDerMittelpunkteI(ant.CoordinateBase, marker.CoordinateBase);
int circleDistance = distance - ant.CoordinateBase.Radius - marker.CoordinateBase.Radius;
// Die neue Markierung wurde noch nicht gerochen und
// liegt näher als die gemerkte.
if (circleDistance <= 0 && distance < nearestMarkerDistance &&
!ant.SmelledMarker.Contains(marker))
{
nearestMarkerDistance = distance;
nearestMarker = marker;
}
}
}
}
}
}
return(nearestMarker);
}
/// <summary>
/// Perform call to "Spots(Fruit)" on given ant.
/// </summary>
/// <param name="ant">ant</param>
/// <param name="fruit">fruit</param>
public static void Spots(CoreAnt ant, CoreFruit fruit)
{
AreaChanged(
null, new AreaChangeEventArgs(ant.colony.Player, Area.SpotsFruit));
playerRights.PermitOnly();
ant.NimmBefehleEntgegen = true;
try {
ant.SiehtBase(fruit);
}
catch (Exception ex) {
throw new AiException("KI-Fehler in der Sieht(Obst)-Methode", ex);
}
ant.NimmBefehleEntgegen = false;
AreaChanged(
null, new AreaChangeEventArgs(null, Area.Unknown));
}
/// <summary>
/// Perform call to "TargetReached(Sugar)" on given ant.
/// </summary>
/// <param name="ant">ant</param>
/// <param name="sugar">sugar</param>
public static void TargetReached(CoreAnt ant, CoreSugar sugar)
{
AreaChanged(
null,
new AreaChangeEventArgs(ant.colony.Player, Area.ReachedSugar));
playerRights.PermitOnly();
ant.NimmBefehleEntgegen = true;
try {
ant.ZielErreichtBase(sugar);
}
catch (Exception ex) {
throw new AiException("KI-Fehler in der ZielErreicht(Zucker)-Methode", ex);
}
ant.NimmBefehleEntgegen = false;
AreaChanged(
null, new AreaChangeEventArgs(null, Area.Unknown));
}
/// <summary>
/// Perform call to "Waits()" on given ant.
/// </summary>
/// <param name="ant">ant</param>
public static void Waits(CoreAnt ant)
{
AreaChanged(
null, new AreaChangeEventArgs(ant.colony.Player, Area.Waits));
playerRights.PermitOnly();
ant.NimmBefehleEntgegen = true;
try
{
ant.WartetBase();
}
catch (Exception ex)
{
throw new AiException(string.Format("{0}: KI-Fehler in der Wartet()-Methode", ant.colony.Player.Guid), ex);
}
ant.NimmBefehleEntgegen = false;
AreaChanged(
null, new AreaChangeEventArgs(null, Area.Unknown));
}
/// <summary>
/// Perform call to "UnderAttack(Ant)" on given ant.
/// </summary>
/// <param name="ant">ant</param>
/// <param name="enemy">enemy</param>
public static void UnderAttack(CoreAnt ant, CoreAnt enemy)
{
AreaChanged(
null,
new AreaChangeEventArgs(ant.colony.Player, Area.UnderAttackByAnt));
playerRights.PermitOnly();
ant.NimmBefehleEntgegen = true;
try {
ant.WirdAngegriffenBase(enemy);
}
catch (Exception ex) {
throw new AiException("KI-Fehler in der WirdAngegriffen(Ameise)-Methode", ex);
}
ant.NimmBefehleEntgegen = false;
AreaChanged(
null, new AreaChangeEventArgs(null, Area.Unknown));
}
/// <summary>
/// Perform call to "Spots(Sugar)" on given ant.
/// </summary>
/// <param name="ant">ant</param>
/// <param name="sugar">sugar</param>
public static void Spots(CoreAnt ant, CoreSugar sugar)
{
AreaChanged(
null, new AreaChangeEventArgs(ant.colony.Player, Area.SpotsSugar));
playerRights.PermitOnly();
ant.NimmBefehleEntgegen = true;
try
{
ant.SiehtBase(sugar);
}
catch (Exception ex)
{
throw new AiException(string.Format("{0}: KI-Fehler in der Sieht(Zucker)-Methode", ant.colony.Player.Guid), ex);
}
ant.NimmBefehleEntgegen = false;
AreaChanged(
null, new AreaChangeEventArgs(null, Area.Unknown));
}
/// <summary>
/// Perform call to "Spots(Bug)" on given ant.
/// </summary>
/// <param name="ant">ant</param>
/// <param name="bug">bug</param>
public static void SpotsEnemy(CoreAnt ant, CoreBug bug)
{
AreaChanged(
null, new AreaChangeEventArgs(ant.colony.Player, Area.SpotsBug));
playerRights.PermitOnly();
ant.NimmBefehleEntgegen = true;
try
{
ant.SiehtFeindBase(bug);
}
catch (Exception ex)
{
throw new AiException(string.Format("{0}: KI-Fehler in der SiehtFeind(Wanze)-Methode", ant.colony.Player.Guid), ex);
}
ant.NimmBefehleEntgegen = false;
AreaChanged(
null, new AreaChangeEventArgs(null, Area.Unknown));
}
/// <summary>
/// Perform call to "TargetReached(Fruit)" on given ant.
/// </summary>
/// <param name="ant">ant</param>
/// <param name="fruit">fruit</param>
public static void TargetReached(CoreAnt ant, CoreFruit fruit)
{
AreaChanged(
null,
new AreaChangeEventArgs(ant.colony.Player, Area.ReachedFruit));
playerRights.PermitOnly();
ant.NimmBefehleEntgegen = true;
try
{
ant.ZielErreichtBase(fruit);
}
catch (Exception ex)
{
throw new AiException(string.Format("{0}: KI-Fehler in der ZielErreicht(Obst)-Methode", ant.colony.Player.Guid), ex);
}
ant.NimmBefehleEntgegen = false;
AreaChanged(
null, new AreaChangeEventArgs(null, Area.Unknown));
}
/// <summary>
/// Perform call to "UnderAttack(Bug)" on given ant.
/// </summary>
/// <param name="ant">ant</param>
/// <param name="bug">bug</param>
public static void UnderAttack(CoreAnt ant, CoreBug bug)
{
AreaChanged(
null,
new AreaChangeEventArgs(
ant.colony.Player, Area.UnderAttackByBug));
playerRights.PermitOnly();
ant.NimmBefehleEntgegen = true;
try
{
ant.WirdAngegriffenBase(bug);
}
catch (Exception ex)
{
throw new AiException(string.Format("{0}: KI-Fehler in der WirdAngegriffen(Wanze)-Methode", ant.colony.Player.Guid), ex);
}
ant.NimmBefehleEntgegen = false;
AreaChanged(
null, new AreaChangeEventArgs(null, Area.Unknown));
}
/// <summary>
/// Berechnet einen neuen Spielschritt
/// </summary>
/// <returns>Zustandskopie des Simulationsstandes nachdem der Schritt ausgeführt wurde</returns>
/// <throws>RuleViolationException</throws>
/// <throws>Exception</throws>
public void Step(SimulationState simulationState)
{
currentRound++;
#region Food
removeSugar();
spawnSugar();
spawnFruit();
#endregion
#region Bugs
Bugs.Grids[0].Clear();
for (int i = 0; i < Teams.Length; i++)
{
for (int j = 0; j < Teams[i].Colonies.Length; j++)
{
Bugs.Grids[0].Add(Teams[i].Colonies[j].Insects);
}
}
// Lasse die Wanzen von der Spiel Befehle entgegen nehmen.
//foreach (CoreBug wanze in Bugs.Insects) {
// wanze.NimmBefehleEntgegen = true;
//}
// Schleife über alle Wanzen.
for (int bugIndex = 0; bugIndex < Bugs.Insects.Count; bugIndex++)
{
CoreBug bug = Bugs.Insects[bugIndex] as CoreBug;
Debug.Assert(bug != null);
bug.NimmBefehleEntgegen = true;
// Finde Ameisen in Angriffsreichweite.
List <CoreInsect> ants = Bugs.Grids[0].FindAnts(bug);
// Bestimme wie der Schaden auf die Ameisen verteilt wird.
if (ants.Count >= SimulationSettings.Custom.BugAttack)
{
// Es sind mehr Ameisen in der SpielUmgebung als die Wanze
// Schadenpunke verteilen kann. Daher werden den Ameisen am
// Anfang der Liste jeweils ein Energiepunkt abgezogen.
for (int index = 0; index < SimulationSettings.Custom.BugAttack; index++)
{
ants[index].AktuelleEnergieBase--;
//((Ameise)ameisen[i]).WirdAngegriffen(wanze);
PlayerCall.UnderAttack((CoreAnt)ants[index], bug);
if (ants[index].AktuelleEnergieBase <= 0)
{
ants[index].colony.EatenInsects.Add(ants[index]);
}
}
}
else if (ants.Count > 0)
{
// Bestimme die Energie die von jeder Ameise abgezogen wird.
// Hier können natürlich Rundungsfehler auftreten, die die Wanze
// abschwächen, die ignorieren wir aber.
int schaden = SimulationSettings.Custom.BugAttack / ants.Count;
for (int index = 0; index < ants.Count; index++)
{
ants[index].AktuelleEnergieBase -= schaden;
//((Ameise)ameisen[i]).WirdAngegriffen(wanze);
PlayerCall.UnderAttack((CoreAnt)ants[index], bug);
if (ants[index].AktuelleEnergieBase <= 0)
{
ants[index].colony.EatenInsects.Add(ants[index]);
}
}
}
// Während eines Kampfes kann die Wanze sich nicht bewegen.
if (ants.Count > 0)
{
continue;
}
// Bewege die Wanze.
bug.Bewegen();
if (bug.RestStreckeBase == 0)
{
bug.DreheInRichtungBase(random.Next(360));
bug.GeheGeradeausBase(random.Next(160, 320));
}
bug.NimmBefehleEntgegen = false;
}
// Verhindere, daß ein Spieler einer gesichteten Wanze Befehle gibt.
//for(int i = 0; i < Bugs.Insects.Count; i++) {
// CoreBug wanze = Bugs.Insects[i] as CoreBug;
// if(wanze != null) {
// wanze.NimmBefehleEntgegen = false;
// }
//}
#endregion
#region Ants
// Loop through all teams.
for (int teamIndex = 0; teamIndex < Teams.Length; teamIndex++)
{
// Loop through all colonies in that team.
for (int colonyIndex = 0; colonyIndex < Teams[teamIndex].Colonies.Length; colonyIndex++)
{
CoreColony colony = Teams[teamIndex].Colonies[colonyIndex];
// Leere alle Buckets.
for (int casteIndex = 0; casteIndex < colony.AnzahlKasten; casteIndex++)
{
colony.Grids[casteIndex].Clear();
}
// Fülle alle Buckets, aber befülle keinen Bucket doppelt.
for (int casteIndex = 0; casteIndex < colony.AnzahlKasten; casteIndex++)
{
if (colony.Grids[casteIndex].Count == 0)
{
colony.Grids[casteIndex].Add(Bugs.Insects);
for (int j = 0; j < Teams.Length; j++)
{
for (int i = 0; i < Teams[j].Colonies.Length; i++)
{
CoreColony v = Teams[j].Colonies[i];
colony.Grids[casteIndex].Add(v.Insects);
}
}
}
}
// Schleife über alle Ameisen.
for (int antIndex = 0; antIndex < colony.Insects.Count; antIndex++)
{
CoreAnt ameise = colony.Insects[antIndex] as CoreAnt;
Debug.Assert(ameise != null);
// Finde und Zähle die Insekten im Sichtkreis der Ameise.
CoreBug wanze;
CoreAnt feind;
CoreAnt freund;
CoreAnt teammember;
int bugCount, enemyAntCount, colonyAntCount, casteAntCount, teamAntCount;
colony.Grids[ameise.CasteIndexBase].FindAndCountInsects(
ameise,
out wanze,
out bugCount,
out feind,
out enemyAntCount,
out freund,
out colonyAntCount,
out casteAntCount,
out teammember,
out teamAntCount);
ameise.BugsInViewrange = bugCount;
ameise.ForeignAntsInViewrange = enemyAntCount;
ameise.FriendlyAntsInViewrange = colonyAntCount;
ameise.FriendlyAntsFromSameCasteInViewrange = casteAntCount;
ameise.TeamAntsInViewrange = teamAntCount;
// Bewege die Ameise.
ameise.Bewegen();
#region Reichweite
// Ameise hat ihre Reichweite überschritten.
if (ameise.ZurückgelegteStreckeI > colony.ReichweiteI[ameise.CasteIndexBase])
{
ameise.AktuelleEnergieBase = 0;
colony.VerhungerteInsekten.Add(ameise);
continue;
}
// Ameise hat ein Drittel ihrer Reichweite zurückgelegt.
else if (ameise.ZurückgelegteStreckeI > colony.ReichweiteI[ameise.CasteIndexBase] / 3)
{
if (ameise.IstMüdeBase == false)
{
ameise.IstMüdeBase = true;
PlayerCall.BecomesTired(ameise);
}
}
#endregion
#region Kampf
// Rufe die Ereignisse auf, falls die Ameise nicht schon ein
// entsprechendes Ziel hat.
if (wanze != null && !(ameise.ZielBase is CoreBug))
{
PlayerCall.SpotsEnemy(ameise, wanze);
}
if (feind != null && !(ameise.ZielBase is CoreAnt) ||
(ameise.ZielBase is CoreAnt && ((CoreAnt)ameise.ZielBase).colony == colony))
{
PlayerCall.SpotsEnemy(ameise, feind);
}
if (freund != null && !(ameise.ZielBase is CoreAnt) ||
(ameise.ZielBase is CoreAnt && ((CoreAnt)ameise.ZielBase).colony != colony))
{
PlayerCall.SpotsFriend(ameise, freund);
}
if (teammember != null && !(ameise.ZielBase is CoreAnt) ||
(ameise.ZielBase is CoreAnt && ((CoreAnt)ameise.ZielBase).colony != colony))
{
PlayerCall.SpotsTeamMember(ameise, teammember);
}
// Kampf mit Wanze.
if (ameise.ZielBase is CoreBug)
{
CoreBug k = (CoreBug)ameise.ZielBase;
if (k.AktuelleEnergieBase > 0)
{
int entfernung =
CoreCoordinate.BestimmeEntfernungI(ameise.CoordinateBase, ameise.ZielBase.CoordinateBase);
if (entfernung < SimulationSettings.Custom.BattleRange * PLAYGROUND_UNIT)
{
k.AktuelleEnergieBase -= ameise.AngriffBase;
if (k.AktuelleEnergieBase <= 0)
{
Bugs.EatenInsects.Add(k);
colony.Statistik.KilledBugs++;
ameise.BleibStehenBase();
}
}
}
else
{
ameise.ZielBase = null;
}
}
// Kampf mit feindlicher Ameise.
else if (ameise.ZielBase is CoreAnt)
{
CoreAnt a = (CoreAnt)ameise.ZielBase;
if (a.colony != colony && a.AktuelleEnergieBase > 0)
{
int entfernung =
CoreCoordinate.BestimmeEntfernungI(ameise.CoordinateBase, ameise.ZielBase.CoordinateBase);
if (entfernung < SimulationSettings.Custom.BattleRange * PLAYGROUND_UNIT)
{
PlayerCall.UnderAttack(a, ameise);
a.AktuelleEnergieBase -= ameise.AngriffBase;
if (a.AktuelleEnergieBase <= 0)
{
a.colony.BeatenInsects.Add(a);
colony.Statistik.KilledAnts++;
ameise.BleibStehenBase();
}
}
}
else
{
ameise.ZielBase = null;
}
}
#endregion
// Prüfe ob die Ameise an ihrem Ziel angekommen ist.
if (ameise.AngekommenBase)
{
ameiseUndZiel(ameise);
}
// Prüfe ob die Ameise einen Zuckerhaufen oder ein Obststück sieht.
ameiseUndZucker(ameise);
if (ameise.GetragenesObstBase == null)
{
ameiseUndObst(ameise);
}
// Prüfe ob die Ameise eine Markierung bemerkt.
ameiseUndMarkierungen(ameise);
if (ameise.ZielBase == null && ameise.RestStreckeBase == 0)
{
PlayerCall.Waits(ameise);
}
PlayerCall.Tick(ameise);
}
removeAnt(colony);
spawnAnt(colony);
aktualisiereMarkierungen(colony);
removeFruit(colony);
}
}
#endregion
#region Bugs again
removeBugs();
healBugs();
spawnBug();
#endregion
bewegeObstUndInsekten();
erzeugeZustand(simulationState);
}
/// <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>
internal virtual void WirdAngegriffenBase(CoreAnt 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>
internal virtual void SiehtFeindBase(CoreAnt ameise)
{
}
/// <summary>
/// Wird wiederholt aufgerufen, wenn die Ameise mindestens eine Ameise verbündeter
/// Völker sieht.
/// </summary>
/// <param name="ameise"></param>
internal virtual void SiehtVerbündetenBase(CoreAnt ameise)
{
}
/// <summary>
/// Findet die Wanze, die feindliche Ameise und die befreundete Ameise mit der
/// geringsten Entfernung innerhalb des Sichtkreis der gegebenen Ameise und
/// zählt die Anzahl an Wanzen, feindlichen und befreundeten Ameisen im Sichtkreis.
/// </summary>
/// <remarks>
/// Wird für Ameisen verwendet. Die Simulation legt für jeden vorkommenden Sichtradius
/// eine eigenes Gitter an und benutzt diese Methode auf der passenden Instanz zum Finden
/// von Insekten. Die Seitenlänge dieses Gitters ist also der Sichradius der Ameise.
/// In diese Gitter werden Wanzen und Ameisen einsortiert.
/// </remarks>
/// <param name="ant">Die Referenzameise.</param>
/// <param name="nearestBug">Eine Wanze.</param>
/// <param name="bugCount">Die Anzahl an Wanzen.</param>
/// <param name="nearestEnemyAnt">Eine feindliche Ameise.</param>
/// <param name="enemyAntCount">Die Anzahl an feindlichen Ameisen.</param>
/// <param name="nearestColonyAnt">Eine befreundete Ameise.</param>
/// <param name="colonyAntCount">Die Anzahl an befreundeten Ameisen.</param>
/// <param name="casteAntCount">Die Anzahl an befreundeten Ameisen der selben Kaste.</param>
public void FindAndCountInsects(CoreAnt ant, out CoreBug nearestBug, out int bugCount,
out CoreAnt nearestEnemyAnt, out int enemyAntCount, out CoreAnt nearestColonyAnt,
out int colonyAntCount, out int casteAntCount, out CoreAnt nearestTeamAnt,
out int teamAntCount)
{
// Die nächstliegenden gefundenen Wanzen und Ameisen.
nearestBug = null;
nearestEnemyAnt = null;
nearestColonyAnt = null;
nearestTeamAnt = null;
// Die Entfernungen zu den nächstliegenden gefundenen Wanzen und Ameisen.
int nearestBugDistance = int.MaxValue;
int nearestEnemyAntDistance = int.MaxValue;
int nearestColonyAntDistance = int.MaxValue;
int nearestTeamAntDistance = int.MaxValue;
// Die Anzahlen der gefundenen Wanzen und Ameisen.
bugCount = 0;
enemyAntCount = 0;
colonyAntCount = 0;
casteAntCount = 0;
teamAntCount = 0;
// Bestimme die Zelle in der die übergebene Ameise sich befindet.
int col = ant.CoordinateBase.X / sideLength;
int row = ant.CoordinateBase.Y / sideLength;
// Betrachte die Zelle und die acht Zellen daneben.
for (int c = -1; c <= 1; c++)
{
if (col + c >= 0 && col + c < columns)
{
for (int r = -1; r <= 1; r++)
{
if (row + r >= 0 && row + r < rows)
{
// Betrachte alle Insekten in der aktuellen Zelle.
List <T> cell = cells[col + c, row + r];
for (int i = 0; i < cell.Count; i++)
{
CoreInsect insect = cell[i] as CoreInsect;
Debug.Assert(insect != null);
if (insect == ant)
{
continue;
}
// Vergleiche die Entfernung zum aktuellen Insekt mit der
// Sichtweite der Ameise bzw. der Seitenlänge des Gitters.
int distance = CoreCoordinate.BestimmeEntfernungI(ant.CoordinateBase, insect.CoordinateBase);
if (distance > sideLength)
{
continue;
}
// Selbes Volk. Die Abfrage "insect is CoreAnt" ist unnötig.
if (insect.colony == ant.colony)
{
colonyAntCount++;
if (insect.CasteIndexBase == ant.CasteIndexBase)
{
casteAntCount++;
}
// Die neue Ameise liegt näher als die gemerkte.
if (distance < nearestColonyAntDistance)
{
nearestColonyAntDistance = distance;
nearestColonyAnt = (CoreAnt)insect;
}
}
// Selbes Team.
else if (insect.colony.Team == ant.colony.Team)
{
teamAntCount++;
// Die neue Ameise liegt näher als die gemerkte.
if (distance < nearestTeamAntDistance)
{
nearestTeamAntDistance = distance;
nearestTeamAnt = (CoreAnt)insect;
}
}
// Wanze.
else if (insect is CoreBug)
{
bugCount++;
// Die neue Wanze liegt näher als die gemerkte.
if (distance < nearestBugDistance)
{
nearestBugDistance = distance;
nearestBug = (CoreBug)insect;
}
}
// Feindliche Ameise.
else
{
enemyAntCount++;
// Die neue Ameise liegt näher als die gemerkte.
if (distance < nearestEnemyAntDistance)
{
nearestEnemyAntDistance = distance;
nearestEnemyAnt = (CoreAnt)insect;
}
}
}
}
}
}
}
}
/// <summary>
/// Entfernt abgelaufene Markierungen und erzeugt neue Markierungen.
/// </summary>
/// <param name="colony">betroffenes Volk</param>
private static void aktualisiereMarkierungen(CoreColony colony)
{
// TODO: Settings berücksichtigen
// Markierungen aktualisieren und inaktive Markierungen löschen.
List <CoreMarker> gemerkteMarkierungen = new List <CoreMarker>();
foreach (CoreMarker markierung in colony.Marker)
{
if (markierung.IstAktiv)
{
markierung.Aktualisieren();
}
else
{
gemerkteMarkierungen.Add(markierung);
}
}
gemerkteMarkierungen.ForEach(delegate(CoreMarker marker)
{
colony.Insects.ForEach(delegate(CoreInsect insect)
{
CoreAnt ant = insect as CoreAnt;
if (ant != null)
{
ant.SmelledMarker.Remove(marker);
}
});
});
//for(int i = 0; i < gemerkteMarkierungen.Count; i++) {
// CoreMarker markierung = gemerkteMarkierungen[i];
// for(int j = 0; j < volk.Insects.Count; j++) {
// CoreAnt ameise = volk.Insects[j] as CoreAnt;
// if(ameise != null) {
// ameise.GerocheneMarkierungen.Remove(markierung);
// }
// }
//}
colony.Marker.Remove(gemerkteMarkierungen);
// Neue Markierungen überprüfen und hinzufügen.
gemerkteMarkierungen.Clear();
colony.NewMarker.ForEach(delegate(CoreMarker newMarker)
{
bool zuNah = false;
//for(int i = 0; i < volk.Marker.Count; i++) {
// CoreMarker marker = volk.Marker[i];
// if(marker != null) {
// int distance =
// CoreCoordinate.BestimmeEntfernungDerMittelpunkteI
// (marker.Coordinate, newMarker.Coordinate);
// if(distance < SimulationSettings.Settings.MarkerDistance * SPIELFELD_EINHEIT) {
// zuNah = true;
// break;
// }
// }
//}
foreach (CoreMarker markierung in colony.Marker)
{
int entfernung =
CoreCoordinate.BestimmeEntfernungDerMittelpunkteI
(markierung.CoordinateBase, newMarker.CoordinateBase);
if (entfernung < SimulationSettings.Custom.MarkerDistance * PLAYGROUND_UNIT)
{
zuNah = true;
break;
}
}
if (!zuNah)
{
colony.Marker.Add(newMarker);
}
});
//foreach (CoreMarker neueMarkierung in volk.NewMarker) {
// bool zuNah = false;
// foreach (CoreMarker markierung in volk.Marker) {
// int entfernung =
// CoreCoordinate.BestimmeEntfernungDerMittelpunkteI
// (markierung.Coordinate, neueMarkierung.Coordinate);
// if (entfernung < SimulationSettings.Settings.MarkerDistance * SPIELFELD_EINHEIT) {
// zuNah = true;
// break;
// }
// }
// if (!zuNah) {
// volk.Marker.Add(neueMarkierung);
// }
//}
colony.NewMarker.Clear();
}
