Looking for an algorithm to build an influence map

Quote:

Original post by captain_crunch If you are on a tile map, then, to draw the influence from an object out to the radius of 10 tiles, you start at coordinates (x - 10, y - 10), clamped to the map dimensions, then use two for loops to set the influence value on each of the 400 (2 * 10 * 2 * 10) tiles. something like: for (y = startY; y < endY; y++) { for (x = startX; x < endX; x++) { // make influence fall of with distance: map[x, y] = 100 / Math.Distance(Point(x, y), entity.Position) } }

Quote:

Original post by alexjc To spread the influence, a common technique is to repeatedly blur the map. The main advantage of this approach is that you can do it once every frame (or so). Another advantage is that you can have many influence sources. However, it wouldn't spread single influence as fast as say, Dijstra's algorithm.

            public static bool FloodFill(            int fromX, int fromY, bool[,] pathability,            out double[,] influenceMap            )        {            // Set initial data            int x, y,                tPosX, tPosY,                sizeX = pathability.GetLength(0),                sizeY = pathability.GetLength(1);            influenceMap = new double[sizeX, sizeY];            for (x = 0; x < sizeX; ++x)                for (y = 0; y < sizeY; ++y)                    influenceMap[x,y] = double.PositiveInfinity;            // Create node queue            Queue<FloodFillNode> nodeQueue = new Queue<FloodFillNode>(sizeX * sizeY);            // Add initial node            nodeQueue.Enqueue(new FloodFillNode(fromX, fromY, 0));            // Temporary distance variable, current node and a temporary node.            double tempDistance;            FloodFillNode node, tempNode = new FloodFillNode();            do            {                // Get first node.                node = nodeQueue.Dequeue();                // Check the surounding area                for (x = -1; x <= 1; ++x)                    for (y = -1; y <= 1; ++y)                    {                        if (x != 0 || y != 0)                        {                            // Map position                            tPosX = node.X + x;                            tPosY = node.Y + y;                            // If it's pathable,                            if (pathability[tPosX, tPosY])                            {                                // Get a temporary distance value                                tempDistance = node.D + Math.Sqrt((x * x) + (y * y));                                // if its less than the recorded value,                                if (tempDistance < influenceMap[tPosX, tPosY])                                {                                    // Set the recored value to that value                                    influenceMap[tPosX, tPosY] = tempDistance;                                    // Set the temporary node data. Not creating a new one speeds things up.                                    tempNode.X = tPosX;                                    tempNode.Y = tPosY;                                    tempNode.D = tempDistance;                                    // Add the temporary node to the queue                                    nodeQueue.Enqueue(tempNode); // Struct, so passed by value.                                }                            }                        }                    }            } while (nodeQueue.Count > 0); // If there's no more nodes, we're done.                        return true;        }

Quote:

Original post by ID Merlin You can optimize this by keeping track of the distance in the queue. Increment it each time you move a step, which will always be one square/hex/move away from where you were.