local function makeNoise(seed)
    -- Перемешиваем массив p на основе seed
    local p = {}
    for i = 0, 255 do
        p[i + 1] = i
    end
    -- Fisher-Yates shuffle
    math.randomseed(seed)
    for i = 256, 2, -1 do
        local j = math.random(1, i)
        p[i], p[j] = p[j], p[i]
    end
    -- Дублируем для упрощения вычислений
    for i = 0, 255 do
        p[256 + i + 1] = p[i + 1]
    end

    -- Вспомогательные функции
    local function lerp(a, b, t)
        return a + (b - a) * t
    end

    local function fade(t)
        return t * t * t * (t * (t * 6 - 15) + 10)
    end

    local function grad(hash, x, y, z)
        local h = hash % 16
        local u = h < 8 and x or y
        local v = h < 4 and y or (h == 12 or h == 14) and x or z
        return ((h % 2) == 0 and u or -u) + ((h % 3) == 0 and v or -v)
    end

    -- Основная функция шума
    return function(x, y, z)
        y = y or 0
        z = z or 0

        local X = math.floor(x) % 256
        local Y = math.floor(y) % 256
        local Z = math.floor(z) % 256

        x = x - math.floor(x)
        y = y - math.floor(y)
        z = z - math.floor(z)

        local u = fade(x)
        local v = fade(y)
        local w = fade(z)

        local A  = p[X + 1] + Y
        local AA = p[A + 1] + Z
        local AB = p[A + 2] + Z
        local B  = p[X + 2] + Y
        local BA = p[B + 1] + Z
        local BB = p[B + 2] + Z

        return lerp(
            lerp(
                lerp(grad(p[AA + 1], x, y, z), grad(p[BA + 1], x - 1, y, z), u),
                lerp(grad(p[AB + 1], x, y - 1, z), grad(p[BB + 1], x - 1, y - 1, z), u),
                v
            ),
            lerp(
                lerp(grad(p[AA + 2], x, y, z - 1), grad(p[BA + 2], x - 1, y, z - 1), u),
                lerp(grad(p[AB + 2], x, y - 1, z - 1), grad(p[BB + 2], x - 1, y - 1, z - 1), u),
                v
            ),
            w
        )
    end
end

function makeTerrainGenerator(seed)
    local noise = makeNoise(seed)

    -- Мультиоктавный шум для более естественного рельефа
    local function fractalNoise(x, z, octaves, persistence)
        local total = 0
        local frequency = 1
        local amplitude = 1
        local maxValue = 0

        for i = 1, octaves do
            total = total + noise(x * frequency, z * frequency) * amplitude
            maxValue = maxValue + amplitude
            amplitude = amplitude * persistence
            frequency = frequency * 2
        end

        return total / maxValue
    end

    -- Основная функция генерации высоты
    return function(x, z)
        -- Базовый шум (крупные формы рельефа)
        local baseNoise = fractalNoise(x / 100, z / 100, 4, 0.5) * 64

        -- Детализация (холмы, неровности)
        local detailNoise = fractalNoise(x / 20, z / 20, 2, 0.3) * 10

        -- Эрозия (сглаживание)
        local erosion = fractalNoise(x / 50, z / 50, 2, 0.4) * 5

        -- Итоговая высота
        local height = baseNoise + detailNoise - erosion

        -- Ограничиваем диапазон (например, от 50 до 120)
        height = math.max(50, math.min(120, height))

        return math.floor(height)
    end
end