Canvas.setpenopacity(1);
let rows = 10; // min=1 max=64 step=1
let columns = 0;// min=0 max=64 step=1
let layout = 0; // min=0, max=1, step=1, (compact, distributed)
let size = 0.9; // min=0.3 max=2 step=0.1
let gap = 0.4; // min=0 max=1 step=0.01
let circleEnable=1; // min=0 max=2 step=1
let circleR=0.7;// min=0 max=2 step=0.01
let circleR0=0;// min=0 max=2 step=0.01
let w=7; // min=2 max=32 step=1
let density=0.55; // min=0 max=1 step=0.01

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

function p(size, w, i, j, offset) 
{
    let r = [ size*((i)/(w-1) - 0.5), size*((j)/(w-1) - 0.5) ];
    if (offset) {
        r[0] += offset[0];
        r[1] += offset[1];
    }
    return r;
}

const DV=[[1, 1], [-1, 1], [-1, -1], [1, -1]];
function draw(size, w, pos, pattern=null)
{
    let m = [];
    if (pattern) {
        m = pattern;
    } else {
        for (let i=0; i<w; i++) {
            if (i < Math.floor(((w+1)/2))) {
                let r = [];
                m.push(r);
                for (let j=0; j<w; j++) {
                    r.push(Math.random() > density ? 0 : 1);
                }
            } else {
                m.push(m[w-1-i]);
            }
        }
    }
    
    for (let i=0; i<w; i++) {
        for (let j=0; j<w; j++) {
            if (!m[i][j]) {
                continue;
            }
            let flags = 0;
            for (let k=0; k<4; k++) {
                let t = [i+DV[k][0], j+DV[k][1]];
                if (t[0] >= 0 && t[0] < w && t[1] >= 0 && t[1] < w && m[t[0]][t[1]]) {
                    flags |= (1<<k);
                }
            }
            if (i+1 >= w || j+1 >= w || !m[i+1][j+1]) {
                let l = 1;
                while (i >= l && j >= l && m[i-l][j-l]) {
                    l++;
                }
                if (l > 1) {
                    turtle.goto(p(size, w, i-l+1, j-l+1, pos));
                    turtle.pendown();
                    turtle.goto(p(size, w, i, j, pos));
                    turtle.penup();
                }
            }
            if (i-1 < 0 || j+1 >= w || !m[i-1][j+1]) {
                let l = 1;
                while (i+l < w && j >= l && m[i+l][j-l]) {
                    l++;
                }
                if (l > 1) {
                    turtle.goto(p(size, w, i+l-1, j-l+1, pos));
                    turtle.pendown();
                    turtle.goto(p(size, w, i, j, pos));
                    turtle.penup();
                }
            }
            let need = circleEnable >= 2 || (circleEnable >= 1 && !flags);
            if (need || circleR0 > 0.0001) {
                let r = 0.5 * circleR * (need ? 1 : circleR0);
                turtle.goto(p(size, w, i, j-r, pos));
                turtle.pendown();
                turtle.circle(r *(size/w));
                turtle.penup();
            }
        }
    }
    return m;
}

let col = columns > 0 ? columns : rows;
let count = rows * col;
let swap = [Math.floor((Math.random()*count)), Math.floor((Math.random()*count))];
if (swap[0] == swap[1]) {
    swap[1] = (swap[0] + Math.floor(count/3))%count;
}
if (swap[0] > swap[1]) {
    let t = swap[0];
    swap[0] = swap[1];
    swap[1] = t;
}
console.log(`swap ${swap[0]} ${swap[1]}`);
let copy = null;
let d = 200 * size;
let cellSize = d / Math.max(rows, col);
let drawingW = col * cellSize;
let drawingH = rows * cellSize;
for (let i=0; i<rows; i++) {
    for (let j=0; j<col; j++) {
        let id = (i*col)+j;
        let p = [0, 0];
        if (layout == 1) {
            p[0] = ((j+0.5)*d)/col -0.5*d;
            p[1] = ((i+0.5)*d)/rows-0.5*d;
        } else {
            p[0] = drawingW * ((j+0.5)/col - 0.5);
            p[1] = drawingH * ((i+0.5)/rows - 0.5);
        }
        let m = draw(cellSize * (1-gap), w, p, id == swap[1] ? copy : null);
        
        if (id == swap[0] && count > 9){
            copy = m;
        } 
        
    }
}
//draw(100, (w), [0, 0]);
function walk(i) {
    false;
}