const total = 200; // min=10, max=1000, step=1
const noise_frequency = 50; // min=5, max=200, step=1
const noise_waviness = 150; // min=0, max=750, step=1
const direction = 0; // min=-180, max=180, step=15
const offsetX = 0.004; // min=0, max=0.4, step=0.001
const offsetY = 0.005; // min=0, max=0.4, step=0.001
const useRotationForOffset = 0; // min=0, max=1, step=1 (No, Yes)
const circles = 1; // min=1, max=2, step=1
const circleSize = 50; // min=0, max=90, step=1
const turns = 1; // min=1, max=10, step=1
const quality = 0.99; // min=0.5, max=1, step=0.001

const seed = total;

const noise = new SimplexNoise(seed);

let turtles;
function setup() {
    turtles = [];
    for (let i = 0; i < total; ++i) {
        const idx = i / total;
        const turtle = new Turtle();
        const radius = circles == 1 ? circleSize : (i % 2 ? circleSize : circleSize * 0.5);
        turtle.jump(Math.sin(idx * Math.PI * 2) * radius, Math.cos(idx * Math.PI * 2) * radius);
        turtles.push(turtle);
    }
}

function walk(i, t) {
    if (i==0) setup();
    let pp = pingpong(t*t);
    const idx = i % total;
    const turtle = turtles[idx];
    let angle = direction + ((idx / total + t) * 360) * turns;
    
    let x, y;
    if (useRotationForOffset) {
        x = Math.sin(angle * (Math.PI / 180)) * (idx * offsetX);
        y = Math.cos(angle * (Math.PI / 180)) * (idx * offsetY);
    } else {
        x = idx * offsetX;
        y = idx * offsetY;
    }
    const p = noise.noise2D([(turtle.x() + x + pp*4) / noise_frequency, (turtle.y() + pp- t*4) / noise_frequency]);
    turtle.seth(p * noise_waviness + angle + pp*15);
    turtle.forward(0.05 + 20 * (1 - quality));
    
    return turtle.y() > -100 && turtle.y() < 100 && turtle.x() > -100 && turtle.x() < 100;
}

function pingpong(t) {
    return (t > 0.5 ? 1 - t : t) * 2;
}



////////////////////////////////////////////////////////////////
// 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;
		}
		hash(i) {
            i = 1103515245 * ((i >> 1) ^ i);
            const h32 = 1103515245 * (i ^ (i>>3));
            return h32 ^ (h32 >> 16);
		}
	}
	return new SimplexNoise(seed);
}