Defold 程序化生成与 Roguelike 关卡

可复现   同一个种子必须生成同一张图，否则存档、联机、回放全部失效
可连通   任何两个房间之间必须有路径，否则玩家会被卡死
可调节   难度、房间数、宝藏密度要能按层数调参
可存档   只存种子和少量差异，不存整张地图
不卡顿   生成过程不能一次阻塞几百毫秒

-- 能跑，但跨平台不保证一致
math.randomseed(12345)
local n = math.random(1, 100)

-- rng.lua
local M = {}
function M.new(seed)
    return setmetatable({ state = seed % 2147483647 }, { __index = M })
end
function M.next(self)                      -- 32 位 LCG
    self.state = (self.state * 16807) % 2147483647
    return self.state
end
function M.int(self, n)  return (self.next(self) % n) + 1 end   -- [1, n]
function M.float(self)   return (self.next(self) - 1) / 2147483646 end
return M

local rng = require("rng")
local r = rng.new(20261006)
print(r:int(100), r:float())

local seed = os.time()                          -- 每局新种子
local seed = tonumber(os.date("%Y%m%d"))        -- 每日挑战

-- 玩家输入的种子码转成整数
local function seed_from_string(s)
    local h = 0
    for i = 1, #s do h = (h * 31 + string.byte(s, i)) % 2147483647 end
    return h
end

local function split(node, depth)
    if depth <= 0 or node.w < 16 or node.h < 16 then
        node.room = {
            x = node.x + rng:int(math.max(1, node.w - 8)),
            y = node.y + rng:int(math.max(1, node.h - 8)),
            w = rng:int(6) + 4, h = rng:int(6) + 4,
        }
        return
    end
    -- 沿长边切一刀，递归两半，最后用走廊连接两子节点的房间中心
end

local function smooth(grid, w, h)
    local ng = {}
    for y = 1, h do
        ng[y] = {}
        for x = 1, w do
            local walls = 0
            for dy = -1, 1 do for dx = -1, 1 do
                if not (dx == 0 and dy == 0) then
                    local nx, ny = x + dx, y + dy
                    if nx < 1 or ny < 1 or nx > w or ny > h
                       or grid[ny][nx] == 1 then walls = walls + 1 end
                end
            end end
            -- 4-5 规则：邻居墙 >= 5 变墙，<= 3 变空
            if walls >= 5 then ng[y][x] = 1
            elseif walls <= 3 then ng[y][x] = 0
            else ng[y][x] = grid[y][x] end
        end
    end
    return ng
end

local function drunkards_walk(grid, w, h, x, y, steps)
    for i = 1, steps do
        grid[y][x] = 0                      -- 挖空
        local d = rng:int(4)
        if d == 1 then x = math.max(2, x - 1)
        elseif d == 2 then x = math.min(w - 1, x + 1)
        elseif d == 3 then y = math.max(2, y - 1)
        else y = math.min(h - 1, y + 1) end
    end
end

local MAP = "/level#map"
-- 写：url, layer, x, y, tile, flags
tilemap.set_tile(MAP, "ground", x, y, 1)                  -- 1 = 地板
tilemap.set_tile(MAP, "walls", x, y, 5)                   -- 5 = 墙
tilemap.set_tile(MAP, "ground", x, y, 1, tilemap.H_FLIP)  -- 随机翻转减少重复感
local t = tilemap.get_tile(MAP, "ground", x, y)           -- 读

local bx, by, bw, bh = tilemap.get_bounds(MAP)
for y = 0, bh - 1 do
    for x = 0, bw - 1 do
        local solid = grid[y + 1][x + 1] == 1
        tilemap.set_tile(MAP, "walls", x, y, solid and 5 or 0)
    end
end

local TILE = 32   -- 与 tile source 的瓦片尺寸一致

local function tile_to_world(tx, ty)
    local origin = go.get_position("/level")
    return vmath.vector3(
        origin.x + tx * TILE + TILE / 2,
        origin.y - ty * TILE - TILE / 2,   -- 注意 y 轴方向
        0)
end

local function flood(grid, w, h, sx, sy)
    local seen, count = {}, 0
    local stack = { { sx, sy } }
    while #stack > 0 do
        local p = table.remove(stack)
        local x, y = p[1], p[2]
        if x >= 1 and y >= 1 and x <= w and y <= h
           and grid[y][x] == 0 and not seen[y * w + x] then
            seen[y * w + x] = true; count = count + 1
            for _, d in ipairs({ {1,0}, {-1,0}, {0,1}, {0,-1} }) do
                stack[#stack + 1] = { x + d[1], y + d[2] }
            end
        end
    end
    return count, seen
end

local function spawn_entities(self)
    for _, room in ipairs(self.rooms) do
        factory.create("#chest_factory", tile_to_world(room.cx, room.cy))
        -- 按房间大小决定敌人数
        local n = math.min(4, math.floor(room.w * room.h / 30))
        for i = 1, n do
            local ex, ey = room.x + rng:int(room.w), room.y + rng:int(room.h)
            factory.create("#enemy_factory", tile_to_world(ex, ey))
        end
    end
end

1. 这个位置可走吗？（查 grid，不要查 tilemap，更快）
2. 会不会挡住唯一的通路？（关键格要标记为 reserved）
3. 与出生点距离够远吗？（防止开局就被贴脸）

function regenerate(self, seed)
    go.delete_all(self.spawned)      -- 删掉上一局所有实体
    self.spawned = {}
    self.rng = rng.new(seed)
    self:generate()
    self:spawn_entities()
end

local save = {
    seed = self.seed,
    floor = self.floor,
    player = { x = self.player.x, y = self.player.y, hp = self.hp },
    opened_chests = self.opened_chests,   -- 只存差异
}
sys.save("save1", save)

1. 所有结构相关的随机都走同一个 rng 实例，且调用顺序固定
2. 生成过程中不要依赖遍历 table 的顺序（pairs 顺序不保证）
3. 不要在地图生成里插入与帧率相关的逻辑（如按 dt 决定迭代次数）

-- 方案 A：分帧，每帧写入若干行
function update(self, dt)
    if self.gen_row and self.gen_row <= self.map_h then
        for x = 0, self.map_w - 1 do
            self:write_tile(x, self.gen_row - 1)
        end
        self.gen_row = self.gen_row + 1
    end
end

- 大地图：按区域（chunk）生成，玩家靠近才生成
- 小地图：整张一次生成，但写入分帧
- 已探索区域：不再重算，缓存结果

local t0 = os.clock()
self:generate()
print(string.format("gen: %.1f ms", (os.clock() - t0) * 1000))