跳至主要內容

9. 程序化生成

EVOCOSMOS2026/4/14大约 13 分钟

程序化生成

你玩《我的世界》的时候，每次创建新世界，地图都不一样——有高山、有海洋、有沙漠、有森林。这些地图不是设计师一个一个手动摆出来的，而是电脑自动生成的。

这就是程序化生成（Procedural Generation，简称 PCG）。简单来说：用代码和算法来自动创建游戏内容，而不是人工一个个放置。

打个比方：程序化生成就像"自动乐高机"——你丢进去一些参数（比如"我要一个 100x100 的地图，有 30% 的山、10% 的水"），机器就自动帮你拼出一个独一无二的乐高世界。

什么是程序化生成

为什么需要程序化生成

原因说明
节省人力手动设计一张大地图可能需要几个月，程序化生成几秒钟搞定
增加可玩性每次玩都不一样，玩家愿意反复尝试
减小包体不需要把巨大的地图数据打包进游戏，只需要存储生成算法
无限扩展理论上可以生成无限大的世界（只要算力够）

程序化生成能做什么

生成内容举例游戏
地形《我的世界》的地形、《泰拉瑞亚》的地下洞穴
关卡《哈迪斯》的房间、《死亡细胞》的地图
物品《暗黑破坏神》的随机装备属性
角色《星露谷物语》的村民外貌组合
音乐部分游戏用算法生成背景音乐
剧情少数游戏尝试用 AI 生成对话和事件

FastNoiseLite —— Godot 的噪声生成器

噪声（Noise）是程序化生成中最常用的工具。你可以把噪声理解成"有规律的无规律"——它看起来是随机的，但实际上有平滑的过渡。

打个比方：真正的随机数就像把一把豆子撒在地上——到处都是，毫无规律。噪声就像起伏的山丘——高高低低，但相邻的地方高度差不多，过渡很自然。

Godot 4 内置了 FastNoiseLite 节点，专门用来生成各种类型的噪声。

FastNoiseLite 的基本使用

C
using Godot;

public partial class NoiseGenerator : Node
{
    private FastNoiseLite _noise;

    public override void _Ready()
    {
        _noise = new FastNoiseLite();

        // 设置噪声参数
        _noise.NoiseType = FastNoiseLite.NoiseTypeEnum.Simplex; // 噪声类型
        _noise.Frequency = 0.05f;    // 频率：越小，地形越大越平缓
        _noise.Seed = 42;            // 种子：同样的种子生成同样的地形

        // 获取某个坐标的噪声值（返回 -1 到 1 之间的浮点数）
        float value = _noise.GetNoise2D(100, 200);
        GD.Print($"坐标 (100, 200) 的噪声值：{value}");
    }
}

噪声参数详解

参数作用常用值
NoiseType噪声类型（Simplex 最常用）Simplex、Perlin、Cellular
Frequency频率，值越小地形越平缓0.01（大山脉）到 0.1（小丘陵）
Seed种子，决定生成的内容任意整数，相同种子 = 相同结果
FractalOctaves叠加层数，越多细节越丰富1-6
FractalLacunarity每层的频率倍数通常 2.0
FractalGain每层的振幅衰减通常 0.5

用噪声生成地形

下面我们用噪声生成一个简单的 2D 地形图。不同的噪声值对应不同的地形类型：

  • 值 < -0.3：水（蓝色）
  • 值 -0.3 到 0.0：沙滩（黄色）
  • 值 0.0 到 0.4：草地（绿色）
  • 值 0.4 到 0.7：森林（深绿色）
  • 值 > 0.7：山地（灰色）
C
using Godot;

public partial class TerrainGenerator : Node2D
{
    [Export] public int MapWidth { get; set; } = 100;
    [Export] public int MapHeight { get; set; } = 100;
    [Export] public int TileSize { get; set; } = 16;
    [Export] public int Seed { get; set; } = 42;
    [Export] public float Frequency { get; set; } = 0.05f;

    private FastNoiseLite _noise;
    private TileMapLayer _tileMap;

    // 地形类型枚举
    private enum TerrainType { Water, Sand, Grass, Forest, Mountain }

    // 地形对应的颜色（用于调试可视化）
    private static readonly Color[] TerrainColors = new[]
    {
        new Color(0.2f, 0.4f, 0.8f),  // 水 - 蓝色
        new Color(0.9f, 0.8f, 0.5f),  // 沙滩 - 黄色
        new Color(0.3f, 0.7f, 0.3f),  // 草地 - 绿色
        new Color(0.1f, 0.5f, 0.2f),  // 森林 - 深绿色
        new Color(0.5f, 0.5f, 0.5f),  // 山地 - 灰色
    };

    public override void _Ready()
    {
        _noise = new FastNoiseLite();
        _noise.Seed = Seed;
        _noise.Frequency = Frequency;
        _noise.NoiseType = FastNoiseLite.NoiseTypeEnum.Simplex;
        _noise.FractalOctaves = 4;  // 4 层叠加，让地形更自然

        GenerateTerrain();
    }

    public void GenerateTerrain()
    {
        GD.Print("开始生成地形...");

        // 方法一：用 Image 可视化（方便调试）
        var image = Image.CreateEmpty(MapWidth, MapHeight, false, Image.Format.Rgba8);

        for (int x = 0; x < MapWidth; x++)
        {
            for (int y = 0; y < MapHeight; y++)
            {
                float noiseValue = _noise.GetNoise2D(x, y);
                TerrainType terrain = GetTerrainType(noiseValue);
                image.SetPixel(x, y, TerrainColors[(int)terrain]);
            }
        }

        // 保存为图片文件，方便查看
        var texture = ImageTexture.CreateFromImage(image);
        var sprite = GetNodeOrNull<Sprite2D>("Preview");
        if (sprite != null)
        {
            sprite.Texture = texture;
        }
        texture.GetImage().SavePng("user://terrain_preview.png");

        GD.Print("地形生成完成！预览图已保存");
    }

    private TerrainType GetTerrainType(float noiseValue)
    {
        // 噪声值范围通常是 -1 到 1
        if (noiseValue < -0.3f) return TerrainType.Water;
        if (noiseValue < 0.0f)  return TerrainType.Sand;
        if (noiseValue < 0.4f)  return TerrainType.Grass;
        if (noiseValue < 0.7f)  return TerrainType.Forest;
        return TerrainType.Mountain;
    }
}

随机地牢生成——BSP 算法简化版

地牢生成是程序化生成中的经典问题。最常见的算法是 BSP（Binary Space Partitioning，二叉空间分割）。

BSP 算法的原理

打个比方：你有一块长方形的地皮，你想在上面建几间房子。

  1. 第一步：把地皮从中间切一刀（横切或竖切），分成两块
  2. 第二步：对每一块再切一刀，继续分
  3. 第三步：切到每一块都够小了，就在每一块里放一个房间
  4. 第四步：用走廊把相邻的房间连起来

这就是 BSP 算法的核心思路。

C
using Godot;
using System.Collections.Generic;

public partial class DungeonGenerator : Node2D
{
    [Export] public int MapWidth { get; set; } = 64;
    [Export] public int MapHeight { get; set; } = 64;
    [Export] public int MinRoomSize { get; set; } = 6;
    [Export] public int MaxRoomSize { get; set; } = 14;
    [Export] public int Seed { get; set; } = 42;
    [Export] public int MaxDepth { get; set; } = 4;

    private RandomNumberGenerator _rng;
    private int[,] _map; // 0=墙壁, 1=地板, 2=走廊

    // 地牢房间数据
    public class Room
    {
        public int X { get; set; }
        public int Y { get; set; }
        public int Width { get; set; }
        public int Height { get; set; }

        public int CenterX => X + Width / 2;
        public int CenterY => Y + Height / 2;

        public Rect2I GetRect() => new(X, Y, Width, Height);
    }

    public List<Room> GeneratedRooms { get; private set; } = new();

    public override void _Ready()
    {
        _rng = new RandomNumberGenerator();
        _rng.Seed = (ulong)Seed;

        GenerateDungeon();
    }

    public void GenerateDungeon()
    {
        _map = new int[MapWidth, MapHeight];
        GeneratedRooms.Clear();

        // 用 BSP 递归分割空间
        var rootArea = new Rect2I(1, 1, MapWidth - 2, MapHeight - 2);
        SplitSpace(rootArea, 0);

        // 在地图上绘制房间
        foreach (var room in GeneratedRooms)
        {
            DrawRoom(room);
        }

        // 连接相邻房间
        for (int i = 0; i < GeneratedRooms.Count - 1; i++)
        {
            ConnectRooms(GeneratedRooms[i], GeneratedRooms[i + 1]);
        }

        GD.Print($"地牢生成完成！共 {GeneratedRooms.Count} 个房间");
    }

    // 递归分割空间
    private void SplitSpace(Rect2I area, int depth)
    {
        // 深度够了或者面积太小，就放一个房间
        if (depth >= MaxDepth ||
            area.Size.X < MinRoomSize * 2 ||
            area.Size.Y < MinRoomSize * 2)
        {
            CreateRoom(area);
            return;
        }

        // 决定横切还是竖切
        bool splitHorizontally;

        if (area.Size.X > area.Size.Y * 1.25f)
            splitHorizontally = false; // 宽了就竖切
        else if (area.Size.Y > area.Size.X * 1.25f)
            splitHorizontally = true;  // 高了就横切
        else
            splitHorizontally = _rng.Randf() > 0.5f; // 差不多就随机

        // 找到分割点
        int split;

        if (splitHorizontally)
        {
            int minSplit = area.Position.Y + MinRoomSize;
            int maxSplit = area.End.Y - MinRoomSize;
            split = _rng.RandiRange(minSplit, maxSplit);

            // 上半部分
            var top = new Rect2I(
                area.Position.X, area.Position.Y,
                area.Size.X, split - area.Position.Y
            );
            // 下半部分
            var bottom = new Rect2I(
                area.Position.X, split,
                area.Size.X, area.End.Y - split
            );

            SplitSpace(top, depth + 1);
            SplitSpace(bottom, depth + 1);
        }
        else
        {
            int minSplit = area.Position.X + MinRoomSize;
            int maxSplit = area.End.X - MinRoomSize;
            split = _rng.RandiRange(minSplit, maxSplit);

            // 左半部分
            var left = new Rect2I(
                area.Position.X, area.Position.Y,
                split - area.Position.X, area.Size.Y
            );
            // 右半部分
            var right = new Rect2I(
                split, area.Position.Y,
                area.End.X - split, area.Size.Y
            );

            SplitSpace(left, depth + 1);
            SplitSpace(right, depth + 1);
        }
    }

    // 在一个区域内创建房间
    private void CreateRoom(Rect2I area)
    {
        int roomWidth = _rng.RandiRange(
            Mathf.Max(MinRoomSize, area.Size.X - 4),
            Mathf.Min(MaxRoomSize, area.Size.X - 2)
        );
        int roomHeight = _rng.RandiRange(
            Mathf.Max(MinRoomSize, area.Size.Y - 4),
            Mathf.Min(MaxRoomSize, area.Size.Y - 2)
        );

        int roomX = _rng.RandiRange(area.Position.X + 1, area.End.X - roomWidth - 1);
        int roomY = _rng.RandiRange(area.Position.Y + 1, area.End.Y - roomHeight - 1);

        GeneratedRooms.Add(new Room
        {
            X = roomX,
            Y = roomY,
            Width = roomWidth,
            Height = roomHeight
        });
    }

    // 在地图上画房间（把房间区域标记为地板）
    private void DrawRoom(Room room)
    {
        for (int x = room.X; x < room.X + room.Width; x++)
        {
            for (int y = room.Y; y < room.Y + room.Height; y++)
            {
                if (x > 0 && x < MapWidth - 1 && y > 0 && y < MapHeight - 1)
                {
                    _map[x, y] = 1;
                }
            }
        }
    }

    // 用 L 形走廊连接两个房间
    private void ConnectRooms(Room roomA, Room roomB)
    {
        int startX = roomA.CenterX;
        int startY = roomA.CenterY;
        int endX = roomB.CenterX;
        int endY = roomB.CenterY;

        // 随机决定先走横还是先走竖
        if (_rng.Randf() > 0.5f)
        {
            DrawHorizontalCorridor(startX, endX, startY);
            DrawVerticalCorridor(startY, endY, endX);
        }
        else
        {
            DrawVerticalCorridor(startY, endY, startX);
            DrawHorizontalCorridor(startX, endX, endY);
        }
    }

    private void DrawHorizontalCorridor(int x1, int x2, int y)
    {
        int minX = Mathf.Min(x1, x2);
        int maxX = Mathf.Max(x1, x2);
        for (int x = minX; x <= maxX; x++)
        {
            if (x > 0 && x < MapWidth - 1 && y > 0 && y < MapHeight - 1)
            {
                _map[x, y] = 2;
            }
        }
    }

    private void DrawVerticalCorridor(int y1, int y2, int x)
    {
        int minY = Mathf.Min(y1, y2);
        int maxY = Mathf.Max(y1, y2);
        for (int y = minY; y <= maxY; y++)
        {
            if (x > 0 && x < MapWidth - 1 && y > 0 && y < MapHeight - 1)
            {
                _map[x, y] = 2;
            }
        }
    }

    // 获取地图数据
    public int GetTile(int x, int y)
    {
        if (x < 0 || x >= MapWidth || y < 0 || y >= MapHeight)
            return 0;
        return _map[x, y];
    }
}

随机物品和敌人放置

地牢生成好了，里面空空的可不行。需要在房间里随机放置宝箱、怪物、陷阱等。

C
using Godot;
using System.Collections.Generic;

public partial class EntitySpawner : Node
{
    [Export] public PackedScene ChestScene { get; set; }
    [Export] public PackedScene EnemyScene { get; set; }
    [Export] public PackedScene TrapScene { get; set; }

    private RandomNumberGenerator _rng = new();

    // 在生成的地牢中放置实体
    public void PopulateDungeon(DungeonGenerator dungeon, Node2D parent)
    {
        _rng.Randomize();

        foreach (var room in dungeon.GeneratedRooms)
        {
            // 每个房间至少一个宝箱（30% 概率）
            if (_rng.Randf() < 0.3f)
            {
                SpawnEntity(ChestScene, room, parent, "Chest");
            }

            // 每个房间有敌人（50% 概率）
            if (_rng.Randf() < 0.5f)
            {
                int enemyCount = _rng.RandiRange(1, 3);
                for (int i = 0; i < enemyCount; i++)
                {
                    SpawnEntity(EnemyScene, room, parent, "Enemy");
                }
            }

            // 陷阱（20% 概率）
            if (_rng.Randf() < 0.2f)
            {
                SpawnEntity(TrapScene, room, parent, "Trap");
            }
        }
    }

    private void SpawnEntity(PackedScene scene, DungeonGenerator.Room room, Node2D parent, string type)
    {
        if (scene == null) return;

        var entity = scene.Instantiate<Node2D>();

        // 在房间内随机一个位置（避开边缘）
        float randomX = room.X + 2 + _rng.Randf() * (room.Width - 4);
        float randomY = room.Y + 2 + _rng.Randf() * (room.Height - 4);
        entity.Position = new Vector2(randomX * 16, randomY * 16);

        parent.AddChild(entity);
        GD.Print($"放置 {type} 在 ({randomX:F0}, {randomY:F0})");
    }
}

种子系统——让世界可复现

"种子"（Seed）是程序化生成中非常重要的概念。你可以把种子想象成一串密码——同样的种子 + 同样的算法 = 完全相同的结果。

这意味着：

  • 玩家 A 和玩家 B 输入相同的种子，会生成一模一样的地图
  • 你可以用种子来"分享"一个特别好看的地图
  • 存档时只需要保存种子，不需要保存整个地图数据
C
using Godot;

public partial class WorldSeedManager : Node
{
    private int _currentSeed;

    // 根据种子生成世界
    public void GenerateWorld(int seed)
    {
        _currentSeed = seed;
        var rng = new RandomNumberGenerator();
        rng.Seed = (ulong)seed;

        // 用这个 rng 来生成所有随机内容
        // 地形、物品、敌人位置……全部用同一个 rng
        // 这样同样的种子就能得到完全相同的世界

        GD.Print($"使用种子 {seed} 生成世界");
    }

    // 用字符串生成种子（方便玩家分享）
    // 比如 "mountain_dream" 转换成一个数字种子
    public int StringToSeed(string seedString)
    {
        int hash = 0;
        foreach (char c in seedString)
        {
            hash = hash * 31 + c;
        }
        return Mathf.Abs(hash);
    }

    // 随机生成一个种子
    public int GenerateRandomSeed()
    {
        var rng = new RandomNumberGenerator();
        rng.Randomize();
        return (int)rng.Randi();
    }
}

最终建议

  1. 从噪声地形开始，这是程序化生成最基础也最实用的部分
  2. 种子系统一定要做，它让程序化生成的内容可复现、可分享
  3. 生成的内容要有规则约束，比如"房间里不能放太多敌人"、"走廊不能太窄"
  4. 做好缓存，生成一次就够了，不要每帧都重新生成
  5. 程序化生成 + 手动调整结合效果最好——先用算法生成骨架，再人工打磨细节
最近更新:
贡献者: zefeng.peng
EVOCOSMOS
Copyright © 2026 EVOCOSMOS