/// <summary>
/// Lässt das Insekt ein Ziel angreifen. Das Ziel darf sich bewegen.
/// In der aktuellen Version kann das Ziel nur eine Wanze sein.
/// </summary>
/// <param name="ziel">Ziel</param>
internal void GreifeAnBase(CoreInsect ziel)
{
if (!NimmBefehleEntgegen)
{
return;
}
ZielBase = ziel;
}
/// <summary>
/// Removes fruit from list.
/// </summary>
/// <param name="colony">winning colony</param>
private void removeFruit(CoreColony colony)
{
//List<CoreFruit> gemerktesObst = new List<CoreFruit>();
for (int j = 0; j < Playground.Fruits.Count; j++)
{
CoreFruit obst = Playground.Fruits[j];
for (int i = 0; i < colony.AntHills.Count; i++)
{
CoreAnthill bau = colony.AntHills[i];
if (bau != null)
{
int entfernung = CoreCoordinate.BestimmeEntfernungI(obst.CoordinateBase, bau.CoordinateBase);
if (entfernung <= PLAYGROUND_UNIT)
{
//gemerktesObst.Add(obst);
// Löschen
colony.Statistik.CollectedFood += obst.Menge;
colony.Statistik.CollectedFruits++;
obst.Menge = 0;
for (int z = 0; z < obst.TragendeInsekten.Count; z++)
{
CoreInsect insect = obst.TragendeInsekten[z];
if (insect != null)
{
insect.GetragenesObstBase = null;
insect.AktuelleLastBase = 0;
insect.RestStreckeI = 0;
insect.RestWinkelBase = 0;
insect.GeheZuBauBase();
}
}
obst.TragendeInsekten.Clear();
Playground.EntferneObst(obst);
j--;
}
}
}
}
}
/// <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;
}
}
}
}
}
}
}
}
