Perlin噪音造成的世界中的产卵单位？

我在Perlin基于噪音的游戏中遇到了一些问题。请看下面的截图。

您看到的白色区域是墙壁，黑色区域是可步行的。中间的三角形是玩家。

我已经在游戏中实现了物理学，方法是将其绘制到纹理（白色或黑色像素）上，然后从CPU中获取。

但是，现在我面临另一个问题。我希望单位（或小兵，无论您叫什么）在屏幕边缘不断生成。这里的要点是，在最终游戏中，将会出现“战争迷雾”，无论如何玩家都无法看到它。

我认为我可以只扫描屏幕边缘的像素，看看它们的物理纹理是否为黑色，然后在其中随机生成东西。但是，如果您再看一下屏幕截图，则（在左上角）有一个我不想让小兵产生的示例（因为它们无法从那里到达玩家） 。

GPU是否可以以某种方式为我确定这些生成点，或者以其他方式确定？我考虑过要在屏幕边缘的建议点和播放器之间制作矢量，然后每10个体素跟随一次矢量，看一面墙是否发生碰撞，然后在此处生成一个单元。

但是，上面提出的解决方案可能会占用过多CPU资源。

关于这个问题有什么建议吗？

注意1 对于生成的单位，我不希望使用任何形式的寻路以避免墙碰撞，因为这些单位朝向玩家。因此，这些单位必须在屏幕的边缘生成，并且该位置必须朝向玩家的直线走，而不会碰到任何墙壁。

有一个非常有用的算法可以完成这项工作，在这种情况下，效率比泛洪算法要高得多（复杂度是运行时间与边界大小成正比，而不是与泛滥区域成正比）：这是行进平方算法。这个概念很简单：从玩家的位置（屏幕中点）开始，选择一个方向，然后步行直到找到墙为止。与墙碰撞时，将启动算法：选择方向（向上或向下），然后开始在该区域的边界上行进，突出显示像素。这为您提供了允许区域的内部边界。然后，您只需检查生成单元的候选点是否在此边界上。

这是运行边界应遵循的原则：

http://en.wikipedia.org/wiki/File:Marchsquares.png （我还不能发布图片）

Wikipedia描述（尽管它具有很多复杂性，因为它已与其他应用程序结合使用）：

http://en.wikipedia.org/wiki/Marching_squares

从玩家的位置进行洪水填充；那么每个“淹没”的区域就是一个有效的游戏区域，其他所有区域都是墙壁。

编辑：关于“在直线上可到达”的附加要求，请记住，在离散空间中，您必须对此进行进一步定义。例如，在这样的环境中，以上所有路径都可能是有效的“直线”，而我已经看到它们在某个时间点或另一个时间点都已用于游戏中：

特别是，大多数都不是可交换的 -这意味着仅仅因为您可以沿“直线”从A到达B并不意味着您也可以从B到达A。相反也不一定是正确的。

此外，还有一个问题是，如果一个或两个“侧面”点被阻挡，那么如何处理对角线运动。

只让产卵怎么样？我认为没有任何特别的问题。

如果仅对播放器有效的直线标记点对您很重要，则可以使用以下算法（这是C ++代码），它比普通的Floodfill消耗更多的资源。可能存在一些小错误（如果有人更正我会很高兴的），因为我自己没有测试代码，但是您会明白的。

void straightlineFill(Point startPoint, Texture target)
{
    queue<Point> pointQueue;
    for (int dx = -1;dx <=1;dx ++)
            for(int dy = -1;dy <=1;dy++)
                if(dx != 0 && dy != 0)
                    pointQueue.push(point(startPoint.x + dx, startPoint.y + dy));
    while (!pointQueue.empty())
    {
        point front = pointQueue.front();
        pointQueue.pop();
        if (target.pixelAt(front) == COLOR_SPAWNABLE||
            target.pixelAt(front) == COLOR_WALL||
            target.pixelAt(front) == COLOR_NOT_SPAWNABLE)
                continue;
        taraget.setPixelAt(front, colorFilled); 
        for (int dx = -1;dx <=1;dx ++)
            for(int dy = -1;dy <=1;dy++)
                if(dx != 0 && dy != 0)
                    pointQueue.push(point(front.x + dx, front.y + dy));
        // up until now was the normal floodfill code
        // and here is the part that will do the real straight line checking

        // lineDX & lineDY will keep how much the line we are checking is skewed
        int lineDX = front.x - startPoint.x;
        int lineDY = front.y - startPoint.y;

        // step will show us how much we have to travel to reach each point of line
        point step;
        if (abs(lineDX) < abs(lineDY))
        {
            if (lineDX < 0)
                step = point(-1,0);
            if (lineDX == 0)
                if (lineDY < 0)
                    step = point(0,-1);
                else
                    step = point(0,1);
            if (lineDX > 0)
                step = point(1,0);
        }

        if (abs(lineDX) < abs(lineDY))
        {
            if (lineDY < 0)
                step = point(0,-1);
            if (lineDY == 0)
                if (lineDX < 0)
                    step = point(-1,0);
                else
                    step = point(1,0);
            if (lineDY > 0)
                step = point(0,1);
        }

        // moved will keep how much we have traveled so far, it's just some value that will speed up calculations and doesn't have any mathematical value
        point moved = 0;

        // spawnable will keep if the current pixel is a valid spawnpaint

        bool spawnable = true;

        // now we will travel on the straight line from player position to the edges of the map and check if whole line is valid spawn points or not.

        while (target.isInside(front))
        {
            front = front + step;
            moved = moved + point(step.x * lineDX, step.y * lineDY);
            if (step.x != 0 && moved.x < moved.y)
            {
                moved.x = moved.x - lineDY * sign(lineDY);
                front.y = front.y + sign(lineDY);
            }
            if (step.y != 0 && moved.y < moved.x)
            {
                moved.y = moved.y - lineDX * sign(lineDX);
                front.x = front.x + sign(lineDX);
            }

            if (target.getPixelAt(front) == COLOR_WALL)
                spawnable = false;

            if (spawnable)
            {
                target.setPixelAt(front,COLOR_SPAWNABLE);
                for (int dx = -1;dx <=1;dx ++)
                    for(int dy = -1;dy <=1;dy++)
                        if(dx != 0 && dy != 0)
                            pointQueue.push(point(front.x + dx, front.y + dy));             
            }
            else
            {
                target.setPixelAt(front,COLOR_NOT_SPAWNABLE);
            }
        }
    }
}

您可以使用代表凸面区域的颜色来填充地图...，这样，如果您位于同一区域，则可以生成您的单位。或者，您可以更轻松地搜索可达区域。

这是静态数据，因此您可以对其进行预计算。

您必须填充从凹到凸的变化的图像查找点，在视觉上似乎很容易找到，您有两种情况：

1. 水平：橙色变为蓝色。
2. 垂直：红色变为绿色和橙色。

这是我在自己的游戏中实际使用过的东西（二维单纯形噪声产生的世界，几乎与您的世界完全一样）-射线。从玩家开始，确定方向（如果需要，可以随意），然后沿着那条线直到碰到某物（屏幕边缘或小行星边缘）。如果您击中屏幕边缘（而不是小行星/白色斑点），那么您会知道从屏幕边缘到播放器之间有一条直线。然后在击中点生成一个怪物。如果您撞上了小行星，请重新进行测试。

您可以使用的另一种（非GPU）解决方案是路径查找。在绘制地图之前，请在地图的每个边缘上从每个潜在的生成点寻找路径，并查看是否有通往中心的路径。A *寻路在成本/性能上还算不错，但如果有问题，您可以在游戏开始之前做到这一点。

任何没有路径的生成点都可以放在排除列表中；反之亦然（带路径的任何点都可以放在包含列表中）。