### Circle field

Trying Perlin noise

```// You can find the Turtle API reference here: https://turtletoy.net/syntax
Canvas.setpenopacity(1);

const size = 90;                //min = 10, max = 100, step = 5
const perlinSize = 5;          //min = 1, max = 50, step = 1
const circleSize = 2;           //min = 0.2, max = 5, step = 0.2

// Global code will be evaluated once.
const turtle = new Turtle();

class Perlin{
constructor(size, gridSize){
this.size = size;
this.gridSize = gridSize;

this.grid = [];

// For each grid intersection, compute a random unit vector
for(let i = 0; i <= gridSize; i++){
let table = [];
for(let j = 0; j <= gridSize; j++){

let angle = Math.random() * 2 * Math.PI;
let x = Math.cos(angle);
let y = Math.sin(angle);

table.push([x, y]);
//                console.log([x, y]);
}
this.grid.push(table);
}
//        console.log(this.grid);
}

get(x, y){
x = x / 2 + this.size / 2;
y = y / 2 + this.size / 2;
if(x < 0) x = 0;
if(x >= this.size) x = this.size - 0.01;
if(y < 0) y = 0;
if(y >= this.size) y = this.size - 0.01;

//        console.log(x, y);

let posx = x * this.gridSize / this.size;
let posy = y * this.gridSize / this.size;

//        console.log(posx, posy);

let x1 = Math.floor(posx);
let x2 = x1 + 1;
let y1 = Math.floor(posy);
let y2 = y1 + 1;

let v = [];
let scal = [];

scal.push()

scal.push(this.scalar(posx, posy, x1, y1));
scal.push(this.scalar(posx, posy, x2, y1));
scal.push(this.scalar(posx, posy, x1, y2));
scal.push(this.scalar(posx, posy, x2, y2));

//        console.log(scal);

// interpolate : linear interpolation for a start
let int1 = this.interpolate(posx - x1, scal[0], scal[1]);
let int2 = this.interpolate(posx - x1, scal[2], scal[3]);

//        console.log(int1, int2);

return this.interpolate(posy - y1, int1, int2);
}

scalar(x, y, vx, vy){
x -= vx;
y -= vy;
//        console.log(x, y);
return x * this.grid[vx][vy][0] + y * this.grid[vx][vy][1];
}

smooth(v){
if(v < 0) v = 0;
if(v > 1) v = 1;
return v**2 * (3 - 2*v);

}

interpolate(x, a, b){
return a + (b - a) * this.smooth(x)
}
}

let perlin = new Perlin(size, perlinSize);

turtle.jump(-size, -size);
turtle.seth(0);

let posx = -size;
let posy = -size;
let angle = 0;

// The walk function will be called until it returns false.
function walk(i) {
/*
posx += 0.05;
if(posx > 90){
posx = -90;
posy += 5;
turtle.jump(posx, posy);
if(posy > 90) return false;
}
angle += 0.2;

let amp = perlin.getNoise(posx, posy);

turtle.goto(posx, posy + Math.cos(angle) * 5 * amp);
*/

let amp = perlin.get(posx, posy)
//    console.log(amp);
amp = (amp + 1) / 2;

for(amp; amp > 0.05; amp -= 0.05){
turtle.jump(posx - circleSize * amp, posy);
turtle.seth(-size);
turtle.circle(circleSize * amp);
}

posx += circleSize * 2;
if(posx > size){
posy += circleSize * 2;
posx = -size;

if(posy > size) return false;
}

/*
for(let i of perlin.grid){
for(let j of i){
console.log(j);
//            console.log(Math.sqrt(j[0]**2 + j[1]**2));
console.log(j[0]);
console.log(j[1]);
}
}
*/
return true;
}```