/// <summary>
/// Gibt die Boardobjects von einer bestimmten Koordinate wieder.
/// </summary>
/// <param name="x">Die X Koordinate</param>
/// <param name="y">Die Y Koordinate</param>
/// <returns>Die BoardObjects von den Koordinaten</returns>
public BoardObject[] getBoardObjectsFromCoords(int x, int y)
{
BoardObject[] objsInCoords = boardObjectList[x, y];
if (objsInCoords == null)
{
objsInCoords = new BoardObject[0];
boardObjectList[x, y] = objsInCoords;
}
return(objsInCoords);
}
/// <summary>
/// </summary>
/// <returns>true wenn das BoardObject gemoved wurde andernfalls false.</returns>
public bool move(BoardObject obj, Coordinates coords)
{
if (!isValidCoords(coords) || containsType(getBoardObjectsFromCoords(coords.X, coords.Y), obj))
{
return(false);
}
removeFromMap(obj);
obj.Coords = coords;
addToMap(obj);
return(true);
}
private BoardObject[] getBoardObjectsInView(Coordinates antCoords, int viewRange)
{
BoardObject[] result = new BoardObject[0];
Coordinates[] coords = CircleCalculator.calculatePartCircle(viewRange);
for (int i = 0; i < coords.Length; i++)
{
addBoardObjectsToArrayForPartCoordinates(coords[i], antCoords, viewRange, ref result);
}
return(result);
}
/// <summary>
/// Entfernt das Boardobject vom Array und passt die Größe an.
/// </summary>
public static void remove(ref BoardObject[] objs, BoardObject toRemove)
{
for (int i = 0;i < objs.Length;i++) {
if (objs[i] == toRemove) {
objs[i] = null;
if (i != objs.Length - 1) {
BoardObject tmp = objs[objs.Length - 1];
objs[i] = tmp;
}
}
}
Array.Resize<BoardObject>(ref objs, objs.Length - 1);
}
public override void antTick(BoardObject[] view)
{
if (Ant.isScout()) {
// its a Scout
HashSet<Coordinates> set = new HashSet<Coordinates>();
set.Add(new Coordinates(2, 4));
Ant.notifyOtherAnts(set);
}
if (Ant.isWarrior()) {
for (int i = 0; i < view.Length; i++) {
BoardObject bObject = view[i];
if (bObject != Ant && bObject.isAnt() && bObject.Coords.isInRange(1, Ant.Coords)) {
Ant.fight(bObject as Ant);
break;
}
}
}
// Zucker aufheben Test
Ant.pickUpSugar();
// RANDOM FTW
Random rand = getRandom();
switch (rand.Next(0, 8)) {
case 1:
Ant.moveDown();
break;
case 2:
Ant.moveLeft();
break;
case 3:
Ant.moveRight();
break;
case 0:
Ant.moveUp();
break;
case 4:
Ant.moveLowerLeft();
break;
case 5:
Ant.moveLowerRight();
break;
case 6:
Ant.moveUpperLeft();
break;
case 7:
Ant.moveUpperRight();
break;
}
}
/// <summary>
/// </summary>
/// <param name="coords">Die Koordinaten</param>
/// <param name="sugar">out den Zucker der gefunden wurde oder null</param>
/// <returns>true wenn Zucker gefunden wurde</returns>
public bool getSugar(Coordinates coords, out Sugar sugar)
{
BoardObject[] objs = getBoardObjectsFromCoords(coords);
for (int i = 0; i < objs.Length; i++)
{
BoardObject boardObject = objs[i];
if (boardObject.isSugar())
{
sugar = (Sugar)boardObject;
return(true);
}
}
sugar = null;
return(false);
}
private bool addToMap(BoardObject boardObject)
{
BoardObject[] objsInCoords = boardObjectList[boardObject.Coords.X, boardObject.Coords.Y];
if (objsInCoords == null)
{
objsInCoords = new BoardObject[0];
}
if (!containsType(objsInCoords, boardObject))
{
ArrayUtils.add(ref objsInCoords, boardObject);
boardObjectList[boardObject.Coords.X, boardObject.Coords.Y] = objsInCoords;
return(true);
}
return(false);
}
private bool containsType(IList <BoardObject> objs, BoardObject objectToCheck)
{
foreach (BoardObject obj in objs)
{
if (obj == null)
{
continue;
}
// the OR is a workaround due to Carry != Scout in type so we use our isAnt() method
if (obj.GetType() == objectToCheck.GetType() || (obj.isAnt() && objectToCheck.isAnt()))
{
return(true);
}
}
return(false);
}
private void mergeWithoutAnt(int x, int y, ref BoardObject[] result)
{
BoardObject[] boardObjectsFromCoords = BoardObjects.getBoardObjectsFromCoords(x, y).Clone() as BoardObject[];
if (boardObjectsFromCoords.Length - 1 != 0)
{
for (int i = 0; i < boardObjectsFromCoords.Length; i++)
{
BoardObject obj = boardObjectsFromCoords[i];
if (obj.isAnt())
{
ArrayUtils.remove(ref boardObjectsFromCoords, obj);
break;
}
}
ArrayUtils.merge(ref result, boardObjectsFromCoords);
}
}
/// <summary>
/// Entfernt ein BoardObject vom Spielfeld
/// </summary>
/// <param name="boardObject">Das Boardobject was gelöscht werden soll.</param>
public void remove(BoardObject boardObject)
{
ArrayUtils.remove(ref boardObjects, boardObject);
if (boardObject.isAnt())
{
ants.Remove((Ant)boardObject);
}
else if (boardObject.isBase())
{
bases.Remove((Base)boardObject);
}
else if (boardObject.isSugar())
{
sugars.Remove((Sugar)boardObject);
}
removeFromMap(boardObject);
}
/// <summary>
/// Fügt ein BoardObject hinzu.
/// </summary>
/// <returns>true wenn er hinzugefügt wurde andernfalls false</returns>
public bool add(BoardObject boardObject)
{
if (!addToMap(boardObject)) {
return false;
}
ArrayUtils.add(ref boardObjects, boardObject);
if (boardObject.isAnt()) {
Ant ant = (Ant) boardObject;
ants.Add(ant);
ant.Owner.incrementAnts(ant);
} else if (boardObject.isBase()) {
bases.Add((Base) boardObject);
} else if (boardObject.isSugar()) {
sugars.Add((Sugar) boardObject);
}
return true;
}
/// <summary>
/// Benachrichtigt andere Ameisen.
/// </summary>
/// <param name="coords">Die Koordinaten welche den anderen Ameisen mitgeteilt werden soll</param>
/// <param name="ant">Die Ameise welche mitteilt</param>
public void notifyAnts(HashSet <Coordinates> coords, Ant ant)
{
BoardObject[] objs = getBoardObjectsInView(ant.Coords, ant.ViewRange * 2);
for (int i = 0; i < objs.Length; i++)
{
BoardObject obj = objs[i];
if (obj == ant)
{
continue;
}
if (obj.isAnt())
{
Ant antToNotify = obj as Ant;
antToNotify.AI.notify(coords);
}
}
}
/// <summary>
/// Fügt ein BoardObject hinzu.
/// </summary>
/// <returns>true wenn er hinzugefügt wurde andernfalls false</returns>
public bool add(BoardObject boardObject)
{
if (!addToMap(boardObject))
{
return(false);
}
ArrayUtils.add(ref boardObjects, boardObject);
if (boardObject.isAnt())
{
Ant ant = (Ant)boardObject;
ants.Add(ant);
ant.Owner.incrementAnts(ant);
}
else if (boardObject.isBase())
{
bases.Add((Base)boardObject);
}
else if (boardObject.isSugar())
{
sugars.Add((Sugar)boardObject);
}
return(true);
}
/// <summary>
/// Fügt ein BoardObject zu einem BoardObject array hinzu.
/// </summary>
public static void add(ref BoardObject[] array, BoardObject toAdd)
{
Array.Resize<BoardObject>(ref array, array.Length + 1);
array[array.Length - 1] = toAdd;
}
private void setColor(BoardObject obj, Bitmap bitmap)
{
if (obj.isCarry()) {
setColor(bitmap, obj.Coords, COLOR_PLAYER1_CARRY, COLOR_PLAYER2_CARRY, (obj as Ant).Owner);
} else if (obj.isScout()) {
setColor(bitmap, obj.Coords, COLOR_PLAYER1_SCOUT, COLOR_PLAYER2_SCOUT, (obj as Ant).Owner);
} else if (obj.isWarrior()) {
setColor(bitmap, obj.Coords, COLOR_PLAYER1_WARRIOR, COLOR_PLAYER2_WARRIOR, (obj as Ant).Owner);
} else if (obj.isBase()) {
Base playerbase = obj as Base;
if (playerbase.RangeLevel > 0) {
for (int i = 0;i < playerbase.RangeCoords.Count;i++) {
setColor(bitmap, playerbase.RangeCoords[i], COLOR_PLAYER1_BASE, COLOR_PLAYER2_BASE, playerbase.Player);
}
}
setColor(bitmap, obj.Coords, COLOR_PLAYER1_BASE, COLOR_PLAYER2_BASE, (obj as Base).Player);
} else if (obj.isSugar()) {
setColor(bitmap, obj.Coords, COLOR_GAME_SUGAR, Color.Transparent, null);
}
}
private void print(BoardObject[] boardObjects)
{
Bitmap tmp = new Bitmap(game.Conf.BoardWidth, game.Conf.BoardHeight);
for (int i = 0;i < boardObjects.Length;i++) {
setColor(boardObjects[i], tmp);
}
if (pb_Game.Image != null) {
pb_Game.Image.Dispose();
}
Bitmap bitmap = new Bitmap(tmp, tmp.Width * 4, tmp.Height * 4);
tmp.Dispose();
pb_Game.Image = bitmap;
}
private void removeFromMap(BoardObject boardObject)
{
BoardObject[] objsInCoords = boardObjectList[boardObject.Coords.X, boardObject.Coords.Y];
ArrayUtils.remove(ref objsInCoords, boardObject);
boardObjectList[boardObject.Coords.X, boardObject.Coords.Y] = objsInCoords;
}
/// <summary>
/// Entfernt ein BoardObject vom Spielfeld
/// </summary>
/// <param name="boardObject">Das Boardobject was gelöscht werden soll.</param>
public void remove(BoardObject boardObject)
{
ArrayUtils.remove(ref boardObjects, boardObject);
if (boardObject.isAnt()) {
ants.Remove((Ant) boardObject);
} else if (boardObject.isBase()) {
bases.Remove((Base) boardObject);
} else if (boardObject.isSugar()) {
sugars.Remove((Sugar) boardObject);
}
removeFromMap(boardObject);
}
private bool addToMap(BoardObject boardObject)
{
BoardObject[] objsInCoords = boardObjectList[boardObject.Coords.X, boardObject.Coords.Y];
if (objsInCoords == null) {
objsInCoords = new BoardObject[0];
}
if (!containsType(objsInCoords, boardObject)) {
ArrayUtils.add(ref objsInCoords, boardObject);
boardObjectList[boardObject.Coords.X, boardObject.Coords.Y] = objsInCoords;
return true;
}
return false;
}
private bool containsType(IList<BoardObject> objs, BoardObject objectToCheck)
{
foreach (BoardObject obj in objs) {
if (obj == null)
continue;
// the OR is a workaround due to Carry != Scout in type so we use our isAnt() method
if (obj.GetType() == objectToCheck.GetType() || (obj.isAnt() && objectToCheck.isAnt())) {
return true;
}
}
return false;
}
public abstract void antTick(BoardObject[] view);
private void removeFromMap(BoardObject boardObject)
{
BoardObject[] objsInCoords = boardObjectList[boardObject.Coords.X, boardObject.Coords.Y];
ArrayUtils.remove(ref objsInCoords, boardObject);
boardObjectList[boardObject.Coords.X, boardObject.Coords.Y] = objsInCoords;
}
private void addBoardObjectsToArrayForPartCoordinates(Coordinates coords, Coordinates current, int viewrange, ref BoardObject[] result)
{
int x1 = coords.X;
int x2 = Math.Abs(x1);
int y1 = coords.Y;
int y2 = Math.Abs(y1);
viewrange++;
if (coords.X == 0 && coords.Y == 0) {
mergeWithoutAnt(x1 + current.X, y1 + current.Y, ref result); // middle
return;
}
merge(x1 + current.X, y1 + current.Y, ref result); // upper left
if (coords.X == 0) {
merge(current.X, y2 + current.Y, ref result); // middle horizontal
return;
}
if (coords.Y == 0) {
merge(x2 + current.X, current.Y, ref result); // middle vertical
return;
}
merge(x2 + current.X, y1 + current.Y, ref result); // upper right
merge(x1 + current.X, y2 + current.Y, ref result); // lower left
merge(x2 + current.X, y2 + current.Y, ref result); // lower right
}
private BoardObject[] getBoardObjectsInView(Coordinates antCoords, int viewRange)
{
BoardObject[] result = new BoardObject[0];
Coordinates[] coords = CircleCalculator.calculatePartCircle(viewRange);
for (int i = 0;i < coords.Length;i++) {
addBoardObjectsToArrayForPartCoordinates(coords[i], antCoords, viewRange, ref result);
}
return result;
}
/// <summary>
/// </summary>
/// <returns>true wenn das BoardObject gemoved wurde andernfalls false.</returns>
public bool move(BoardObject obj, Coordinates coords)
{
if (!isValidCoords(coords) || containsType(getBoardObjectsFromCoords(coords.X, coords.Y), obj)) {
return false;
}
removeFromMap(obj);
obj.Coords = coords;
addToMap(obj);
return true;
}
private void merge(int x, int y, ref BoardObject[] result)
{
if (!BoardObjects.isValidCoords(x, y))
return;
BoardObject[] boardObjectsFromCoords = BoardObjects.getBoardObjectsFromCoords(x, y);
if (boardObjectsFromCoords.Length != 0) {
ArrayUtils.merge(ref result, boardObjectsFromCoords);
}
}
private void mergeWithoutAnt(int x, int y, ref BoardObject[] result)
{
BoardObject[] boardObjectsFromCoords = BoardObjects.getBoardObjectsFromCoords(x, y).Clone() as BoardObject[];
if (boardObjectsFromCoords.Length - 1 != 0) {
for (int i = 0;i < boardObjectsFromCoords.Length;i++) {
BoardObject obj = boardObjectsFromCoords[i];
if (obj.isAnt()) {
ArrayUtils.remove(ref boardObjectsFromCoords, obj);
break;
}
}
ArrayUtils.merge(ref result, boardObjectsFromCoords);
}
}
/// <summary>
/// Fügt 2 BoardObject-Array's zusammen.
/// </summary>
public static void merge(ref BoardObject[] array, BoardObject[] toAdd)
{
int array1OriginalLength = array.Length;
Array.Resize<BoardObject>(ref array, array1OriginalLength + toAdd.Length);
Array.Copy(toAdd, 0, array, array1OriginalLength, toAdd.Length);
}
/// <summary>
/// Gibt die Boardobjects von einer bestimmten Koordinate wieder.
/// </summary>
/// <param name="x">Die X Koordinate</param>
/// <param name="y">Die Y Koordinate</param>
/// <returns>Die BoardObjects von den Koordinaten</returns>
public BoardObject[] getBoardObjectsFromCoords(int x, int y)
{
BoardObject[] objsInCoords = boardObjectList[x, y];
if (objsInCoords == null) {
objsInCoords = new BoardObject[0];
boardObjectList[x, y] = objsInCoords;
}
return objsInCoords;
}
