// Forked from "Houses along the road 🏠🌲" by markknol
// https://turtletoy.net/turtle/5f7fa21c7c

// Forked from "circletransform" by reinder
// https://turtletoy.net/turtle/71d524ceb5

function Translate(x,y) { return p => [p[0]+x, p[1]+y]; }
function Scale(sx, sy = sx) { return p => [p[0]*sx, p[1]*sy]; }
function Circle(r) { return p => { let ry = r - p[1], a = p[0]/r; return [ry*Math.cos(a), ry*Math.sin(a)]; } }

const elementScale = 1.0; // min=0.5, max=2, step=0.1
const roadSize = 10; // min=1, max=20, step=0.1

const display = 2; // min=1, max=2, step=1 (One, Two)

const size1 = 82; // min=20, max=100, step=1
const numElementsOutside1 = 17; // min=0, max=30, step=1
const numElementsInside1 = 12; // min=0, max=30, step=1

const size2 = 35; // min=20, max=100, step=1
const numElementsOutside2 = 7; // min=0, max=30, step=1
const numElementsInside2= 6; // min=0, max=30, step=1

function drawRoad(size, t) {
    t.jump([0, -roadSize/2]);
    t.forward(size*Math.PI);
    t.forward(size*Math.PI);
    
    t.jump([0, 0]);
    for(let i=0; i<size*2; i++) {
        if (i % 2 == 0) t.penup(); // dotted line
        else t.pendown();
        t.forward(Math.PI);
    }
    t.pendown();
    
    t.jump([0, roadSize/2]);
    t.forward(size*Math.PI);
    t.forward(size*Math.PI);
}

drawRoad(size1, new Tortoise().addTransform(Circle(size1)));
if (display == 2) drawRoad(size2, new Tortoise().addTransform(Circle(size2)));

function walk(i) {
    drawElement(i, size1,numElementsInside1, true, 2);
    drawElement(i, size1,numElementsOutside1, false, 3);
    if (display > 1) {
        drawElement(i, size2,numElementsInside2, true, 2);
        drawElement(i, size2,numElementsOutside2, false, 3);
    }
    return i < Math.max(numElementsInside1,numElementsOutside1,numElementsInside2,numElementsOutside2) - 1;
}

function drawElement(i, size, total, inside, mod) {
    if (i < total) { 
        const h = new Tortoise()
            .addTransform(Scale(.4 * elementScale))
            .addTransform(Translate(i * size * Math.PI * 2 / total, -roadSize/2));
        if (inside) {
            h.addTransform(Scale(-1)).addTransform(Translate(total * 2, 0));
        }
        h.addTransform(Circle(size));
        
        if (i % mod > 0) {
            drawHouse(h);
        } else {
            drawTree(h);
        }
    }
}

function drawTree(t) {
    square(t, [-3,-8], [3,0]);
    t.jmp(-15,-8); 
    t.goto(15,-8);
    t.goto(6,-20);
    t.goto(11,-20);
    t.goto(3,-30);
    t.goto(7,-30);
    t.goto(0,-47);
    t.goto(-7,-30);
    t.goto(-3,-30);
    t.goto(-11,-20);
    t.goto(-6,-20);
    t.goto(-15,-8);
}

function drawHouse(t) {
    square(t, [-10,-20], [30,0]);
    square(t, [-5,-15], [2,-8]); // window
    square(t, [7,0], [14,-15]); // door
    square(t, [19,-15], [25,-8]); // window
    square(t, [-25,-15], [-15,-8]); // window
    for (let i=-20; i<=20; i+=5) {
        t.jmp(i,-30); t.goto(i+10,-20); // roof hatchng
    }
    t.jmp(-20,-30); t.goto(-30,-20); t.goto(-30,0);  t.goto(-10,0);  t.goto(-10,-20); t.goto(-20,-30); 
    t.jmp(-10,-20); t.goto(-20,-30); t.goto(20,-30); t.goto(30,-20); t.goto(-10,-20);
}
function square(t, lt, rb) {
    t.jmp(lt); t.goto(lt[0], rb[1]); t.goto(rb), t.goto(rb[0], lt[1]); t.goto(lt);
}

////////////////////////////////////////////////////////////////
// Tortoise utility code (Minimal Turtle and Transforms)
// https://turtletoy.net/turtle/102cbd7c4d
////////////////////////////////////////////////////////////////

function Tortoise(x, y) {
    class Tortoise extends Turtle {
        constructor(x, y) {
            super(x, y);
            this.ps = Array.isArray(x) ? [...x] : [x || 0, y || 0];
            this.transforms = [];
        }
        addTransform(t) {
            this.transforms.push(t);
            this.jump(this.ps);
            return this;
        }
        applyTransforms(p) {
            if (!this.transforms) return p;
            let pt = [...p];
            this.transforms.map(t => { pt = t(pt); });
            return pt;
        }
        goto(x, y) {
            const p = Array.isArray(x) ? [...x] : [x, y];
            const pt = this.applyTransforms(p);
            if (this.isdown() && (this.pt[0]-pt[0])**2 + (this.pt[1]-pt[1])**2 > 4) {
               this.goto((this.ps[0]+p[0])/2, (this.ps[1]+p[1])/2);
               this.goto(p);
            } else {
                super.goto(pt);
                this.ps = p;
                this.pt = pt;
            }
        }
        position() { return this.ps; }
    }
    return new Tortoise(x,y);
}