// Forked from "Simplex Noise" by reinder
// https://turtletoy.net/turtle/6e4e06d42e

// Simplex Noise. Created by Reinder Nijhoff 2020 - @reindernijhoff
// The MIT License
//
// https://turtletoy.net/turtle/6e4e06d42e
// Added some stuff

const turtle = new Turtle();

const frequency = 3; //min=.1, max=10, step=.01
const grid = 50; // min=10, max=100, step=1
const seed = 1; // min=1, max=100, step=1
const noise = new SimplexNoise(seed);

function drawSquare(x, y, size) {
    // Draw the square
    turtle.jump(x - size / 2, y - size / 2);
    turtle.pendown();
    for (let i = 0; i < 4; i++) {
        turtle.forward(size);
        turtle.right(90);
    }
    turtle.penup();
}

function drawCircle(x, y, size) {
    // Draw the circle
    turtle.jump(x, y - size / 2);
    turtle.pendown();
    for (let i = 0; i < 360; i++) {
        turtle.forward(Math.PI * size / 180);
        turtle.right(1);
    }
    turtle.penup();
}

function drawLineBehindShape(x, y, size) {
    // Randomly decide if the line is vertical or horizontal
    const isVertical = Math.random() > 0.5;
    const lineLength = size + Math.random() * 6 - 3; // Line length between (size - 3) and (size + 3)

    if (isVertical) {
        // Draw vertical line
        turtle.jump(x, y - lineLength / 2);
        turtle.pendown();
        turtle.goto(x, y + lineLength / 2);
    } else {
        // Draw horizontal line
        turtle.jump(x - lineLength / 2, y);
        turtle.pendown();
        turtle.goto(x + lineLength / 2, y);
    }
    turtle.penup();
}

function walk(i) {
    const x = (i % grid) * 200 / grid - 100;
    const y = ((i / grid) | 0) * 200 / grid - 100;

    const r = 0.5 + 0.5 * noise.noise2D([x * frequency / 200, y * frequency / 200, 0.5]);
    const size = r * 100 / grid;

    drawLineBehindShape(x + 100 / grid, y + 100 * (1 - r) / grid, size);

    // Randomly decide whether to draw a square or a circle
    if (Math.random() > 0.5) {
        drawSquare(x + 100 / grid, y + 100 * (1 - r) / grid, size);
    } else {
        drawCircle(x + 100 / grid, y + 100 * (1 - r) / grid, size);
    }

    return i < grid * grid - 1;
}

////////////////////////////////////////////////////////////////
// Simplex Noise utility code. Created by Reinder Nijhoff 2020
// https://turtletoy.net/turtle/6e4e06d42e
// Based on: http://webstaff.itn.liu.se/~stegu/simplexnoise/simplexnoise.pdf
////////////////////////////////////////////////////////////////
function SimplexNoise(seed = 1) {
    const grad = [
        [1, 1, 0], [-1, 1, 0], [1, -1, 0], [-1, -1, 0],
        [1, 0, 1], [-1, 0, 1], [1, 0, -1], [-1, 0, -1],
        [0, 1, 1], [0, -1, 1], [0, 1, -1], [0, -1, -1]
    ];
    const perm = new Uint8Array(512);

    const F2 = (Math.sqrt(3) - 1) / 2, F3 = 1 / 3;
    const G2 = (3 - Math.sqrt(3)) / 6, G3 = 1 / 6;

    const dot2 = (a, b) => a[0] * b[0] + a[1] * b[1];
    const sub2 = (a, b) => [a[0] - b[0], a[1] - b[1]];
    const dot3 = (a, b) => a[0] * b[0] + a[1] * b[1] + a[2] * b[2];
    const sub3 = (a, b) => [a[0] - b[0], a[1] - b[1], a[2] - b[2]];

    class SimplexNoise {
        constructor(seed = 1) {
            for (let i = 0; i < 512; i++) {
                perm[i] = i & 255;
            }
            for (let i = 0; i < 255; i++) {
                const r = (seed = this.hash(i + seed)) % (256 - i) + i;
                const swp = perm[i];
                perm[i + 256] = perm[i] = perm[r];
                perm[r + 256] = perm[r] = swp;
            }
        }
        noise2D(p) {
            const s = dot2(p, [F2, F2]);
            const c = [Math.floor(p[0] + s), Math.floor(p[1] + s)];
            const i = c[0] & 255, j = c[1] & 255;
            const t = dot2(c, [G2, G2]);

            const p0 = sub2(p, sub2(c, [t, t]));
            const o = p0[0] > p0[1] ? [1, 0] : [0, 1];
            const p1 = sub2(sub2(p0, o), [-G2, -G2]);
            const p2 = sub2(p0, [1 - 2 * G2, 1 - 2 * G2]);

            let n = Math.max(0, 0.5 - dot2(p0, p0)) ** 4 * dot2(grad[perm[i + perm[j]] % 12], p0);
            n += Math.max(0, 0.5 - dot2(p1, p1)) ** 4 * dot2(grad[perm[i + o[0] + perm[j + o[1]]] % 12], p1);
            n += Math.max(0, 0.5 - dot2(p2, p2)) ** 4 * dot2(grad[perm[i + 1 + perm[j + 1]] % 12], p2);

            return 70 * n;
        }
        noise3D(p) {
            const s = dot3(p, [F3, F3, F3]);
            const c = [Math.floor(p[0] + s), Math.floor(p[1] + s), Math.floor(p[2] + s)];
            const i = c[0] & 255, j = c[1] & 255, k = c[2] & 255;
            const t = dot3(c, [G3, G3, G3]);

            const p0 = sub3(p, sub3(c, [t, t, t]));
            const [o0, o1] = p0[0] >= p0[1] ? p0[1] >= p0[2] ? [[1, 0, 0], [1, 1, 0]]
                : p0[0] >= p0[2] ? [[1, 0, 0], [1, 0, 1]]
                    : [[0, 0, 1], [1, 0, 1]]
                : p0[1] < p0[2] ? [[0, 0, 1], [0, 1, 1]]
                    : p0[0] < p0[2] ? [[0, 1, 0], [0, 1, 1]]
                        : [[0, 1, 0], [1, 1, 0]];
            const p1 = sub3(sub3(p0, o0), [-G3, -G3, -G3]);
            const p2 = sub3(sub3(p0, o1), [-2 * G3, -2 * G3, -2 * G3]);
            const p3 = sub3(p0, [1 - 3 * G3, 1 - 3 * G3, 1 - 3 * G3]);

            let n = Math.max(0, 0.6 - dot3(p0, p0)) ** 4 * dot3(grad[perm[i + perm[j + perm[k]]] % 12], p0);
            n += Math.max(0, 0.6 - dot3(p1, p1)) ** 4 * dot3(grad[perm[i + o0[0] + perm[j + o0[1] + perm[k + o0[2]]]] % 12], p1);
            n += Math.max(0, 0.6 - dot3(p2, p2)) ** 4 * dot3(grad[perm[i + o1[0] + perm[j + o1[1] + perm[k + o1[2]]]] % 12], p2);
            n += Math.max(0, 0.6 - dot3(p3, p3)) ** 4 * dot3(grad[perm[i + 1 + perm[j + 1 + perm[k + 1]]] % 12], p3);

            return 32 * n;
        }
        hash(i) {
            i = 1103515245 * ((i >> 1) ^ i);
            const h32 = 1103515245 * (i ^ (i >> 3));
            return h32 ^ (h32 >> 16);
        }
    }
    return new SimplexNoise(seed);
}