### Gaussian mountains

Inspired by maraz

```// Forked from "Unknown Turtles" by maraz
// https://turtletoy.net/turtle/ca12448d34

Canvas.setpenopacity(-1);

let dens = 4 // min=1, max=10, step=1
dens=1/dens
const turtle = new Turtle();
const width = 90;
const zstart = 80;
const layer = dens*6;
const layers = 27/dens;
const perspective = 0.7*dens+0.2;

turtle.penup();
let h=0;
const leeway=1 // min=0, max=30, step=1
const amp=1 // min=0, max=20, step=0.1
const res =1 // min=1, max=10, step=1

const rows = 200
const scale = 150 // min=0, max=400, step=1
const mean = 0
const rad = 18 // min=0, max=50, step=1
const vermult = 9 // min=0, max=20, step=1
const cols = (layers+3)*(vermult)
const filledge = 1 //min=0, max=1, step=1
const gaussMat1 = generateGaussianNoiseMatrix(rows, cols, scale, mean)

function walk(i) {
const left = -width + perspective * i;
const right = width - perspective * i;
const z = zstart - layer * i;

if (filledge==1){

turtle.penup();
turtle.goto(-500, z);
turtle.pendown();
turtle.goto(left, z);
turtle.penup();
turtle.goto(500, z);
turtle.pendown();
turtle.goto(right, z);
turtle.penup()

}
turtle.goto(left, z);

for (let n = left; n < right; n += res) {

const xIndex = Math.floor((n + width) / res);

if (n < left + leeway || n > right - leeway) {
h = z;
} else {
h = z + gaussMat[xIndex][i*vermult] * amp;
}

turtle.goto(n, h);
turtle.pendown();
}

turtle.goto(right, z);
turtle.penup();
return i < layers;
}

function generateGaussianNoiseMatrix(rows, cols, scale, mean) {
const noiseMatrix = [];

for (let i = 0; i < rows; i++) {
const row = [];
for (let j = 0; j < cols; j++) {
const u1 = 1 - Math.random();
const u2 = 1 - Math.random();

const z0 = Math.sqrt(-2 * Math.log(u1)) * Math.cos(2 * Math.PI * u2);
const z1 = Math.sqrt(-2 * Math.log(u1)) * Math.sin(2 * Math.PI * u2);

const noiseValue = mean + scale * z0;
row.push(noiseValue);
}
noiseMatrix.push(row);
}

return noiseMatrix;
}

// Function to apply Gaussian blur to a matrix
function applyGaussianBlur(matrix, radius) {
const kernelSize = radius * 2 + 1;
const kernel = [];

for (let i = 0; i < kernelSize; i++) {
const row = [];
for (let j = 0; j < kernelSize; j++) {
const x = i - radius;
const y = j - radius;
const weight = Math.exp(-(x * x + y * y) / (2 * radius * radius));
row.push(weight);
}
kernel.push(row);
}

const blurredMatrix = [];

for (let i = 0; i < matrix.length; i++) {
const newRow = [];
for (let j = 0; j < matrix[i].length; j++) {
let sum = 0;
let totalWeight = 0;
for (let ki = 0; ki < kernelSize; ki++) {
for (let kj = 0; kj < kernelSize; kj++) {
const mi = i - radius + ki;
const mj = j - radius + kj;
if (mi >= 0 && mi < matrix.length && mj >= 0 && mj < matrix[i].length) {
sum += matrix[mi][mj] * kernel[ki][kj];
totalWeight += kernel[ki][kj];
}
}
}
newRow.push(sum / totalWeight);
}
blurredMatrix.push(newRow);
}

return blurredMatrix;
}
```