public static HashSet<Point> getAnthillPoints() {

		/*
		 * The first part of the algorithm traces the outline of a hexagon on
		 * the grid
		 */

		// Pull out side length
		int sideLength = AntGame.CONFIG.CONTEST_MAP_ANTHILL_SIDE_LENGTH;
		
		// Height of hexagon = (2n - 1) where n = side length
		int height = ( 2 * sideLength ) - 1;

		// Initialise collection of points to be included in the anthill
		HashSet<Point> targetCells = new HashSet<Point>();

		// First cell is the one [sidelength - 1] units vertically ( -1 as we
		// start at 0)
		int drawYOffset = sideLength - 1;
		targetCells.add(new Point(0, drawYOffset));
		
		int curX = 0;
		
		int maxY = drawYOffset + 1;
		int minY = drawYOffset - 1;

		/*
		 * I started writing a good algorithm, it turned ugly, and this is the result.
		 * I don't even follow it but it seems to work. 
		 */
		
		// Open angled bit
		boolean done = false;
		while (!done) {
			
			if ( (maxY - minY) >= height ) {
				done = true;
				maxY--;
				minY++;
			}
			
			for (int curY = minY; curY <= maxY; curY++) {
				targetCells.add(new Point(curX, curY));
			}
			
			maxY += 2;
			minY -= 2;
			
			curX++;
			
		}
		
		maxY -= 2;
		minY += 2;
		
		// Straight bit
		int i;
		for (i = curX; i < ( (sideLength - 1) + curX ); i++) {
			for (int curY = minY; curY <= maxY; curY++) {
				targetCells.add(new Point(i, curY));
			}
		}
		
		curX = i;
		
		done = false;
		
		maxY = height - 3;
		minY = 2;
		
		// Closed angle bit
		while (!done) {
			
			if ( (maxY - minY) <= 1 ) {
				done = true;
			}
			for (int curY = minY; curY <= maxY; curY++) {
				targetCells.add(new Point(curX, curY));
			}
			
			maxY -= 2;
			minY += 2;
			
			curX++;
			
		}

		return targetCells;
/*		
		// Make a note of peak x and y offsets reached (to be used later)
		int peakX = -1;
		int peakY = -1;

		for (int i = 0; i < sideLength - 1; i++) {
			targetCells.add(new Point((i / 2), drawYOffset - i));
			targetCells.add(new Point((i / 2), drawYOffset + i));
			// If this is the last time the loop will run, record the peak
			// offsets
			if ((i + 1) == sideLength) {
				peakX = (i / 2);
				peakY = drawYOffset + i;
			}
		}

		for (int i = 0; i < sideLength - 1; i++) {
			targetCells.add(new Point(peakX + i, 0));
			targetCells.add(new Point(peakX + i, peakY));
		}

		// Record the new "peak x"
		peakX = peakX + (sideLength - 1);

		// Record our current x-position
		int curX = -1;
		for (int i = 0; i < sideLength - 1; i++) {
			curX = peakX + (i / 2);
			// If our two tracelines have converged, draw one point (convergence
			// point)
			if (i == (peakY - i)) {
				targetCells.add(new Point(curX, i));
				// Otherwise, continue to trace the lines
			} else {
				targetCells.add(new Point(curX, i));
				targetCells.add(new Point(curX, (peakY - i)));
			}
		}

		// Update peakX to reflect the maximum x-position reached
		peakX = curX;

		for (int y = 0; y <= peakY; y++) {
			// Flag to see if we're filling in the cells we're coming across
			boolean filling = false;
			// Flag to see if we're done filling in anthill cells in this row
			boolean reachedEnd = false;
			// We use a while loop as we may not iterate to the end of the row
			int x = 0;
			while (!reachedEnd) {
				// Check if this cell is already part of the anthill
				if (targetCells.contains(new Point(x, y))) {
					// If we weren't already filling, this cell is the start of
					// the anthill on this row,
					// so let's start filling
					if (!filling) {
						filling = true;
						// If we've already been filling, we've reached the end
						// of the row
					} else {
						reachedEnd = true;
					}
					// If this cell is empty and we're filling in cells, fill
					// this one
				} else if (filling) {
					targetCells.add(new Point(x, y));
				}
				// Increment loop counter
				x++;
			}
		}

		// Return the target cells
		return targetCells;*/
	}