const shape = 0; // min=0, max=15, step=1 (Square, Bubble, Blur, Linear, Circle, Sin, Exponential, Swirl, Horseshoe, Polar, Handkerchief, Heart, Disc, Spiral, Diamond, Julia)
const x_height = 0.1; // min=-1, max=1, step=0.01
const y_height = 0.5; // min=-1, max=1, step=0.01
const x_post = 0.5; // min=-100, max=100, step=1
const y_post = 0.5; // min=-100, max=100, step=1
https://turtletoy.net/user/profile
Canvas.setpenopacity(-0.05);

const turtle = new Turtle();

let x = 0;
let y = 0;

function toRadians (angle) {
  return angle * (Math.PI / 180);
}

function toDegrees (angle) {
  return angle * (180 / Math.PI);
}

function matrix_multiplication(m0, m1){
    return [[m0[0][0]*m1[0][0] + m0[0][1]*m1[1][0], m0[0][0]*m1[0][1] + m0[0][1]*m1[1][1]], [m0[1][0]*m1[0][0] + m0[1][1]*m1[1][0], m0[1][0]*m1[0][1] + m0[1][1]*m1[1][1]]];
}

function rotation_matrix(theta){
    return [[Math.cos(toRadians(theta)), -Math.sin(toRadians(theta))], [Math.sin(toRadians(theta)), Math.cos(toRadians(theta))]];
}


var left_angle = toDegrees(Math.atan(y_height/x_height));
var right_angle = -toDegrees(Math.atan(y_height/(1.0-x_height)));

var left_length = Math.sqrt(Math.pow(x_height,2) + Math.pow(y_height, 2));
var right_length = Math.sqrt(Math.pow((1.0-x_height),2) + Math.pow(y_height, 2));

var left_x_offset = -0.5 - 0.5*Math.cos(toRadians(180 - 45 - left_angle))*Math.sqrt(2*Math.pow(left_length, 2));
var left_y_offset = -0.5 -0.5* Math.sin(toRadians(180 - 45 - left_angle))*Math.sqrt(2*Math.pow(left_length, 2));

var right_x_offset = 0.5 + Math.cos(toRadians(180 - 45 + right_angle))*0.5*Math.sqrt(2*Math.pow(right_length, 2));
var right_y_offset = -0.5 - Math.sin(toRadians(180 - 45 + right_angle))*0.5*Math.sqrt(2*Math.pow(right_length, 2));

var left_rotation_matrix = rotation_matrix(left_angle);
var right_rotation_matrix = rotation_matrix(right_angle);

var left_length_matrix = [[left_length, 0], [0, left_length]];
var right_length_matrix = [[right_length, 0], [0, right_length]];

var final_left_matrix = matrix_multiplication(left_rotation_matrix,left_length_matrix);
var final_right_matrix = matrix_multiplication(right_rotation_matrix,right_length_matrix);


let function_set = [[1.0, 0, 0, 1.0, 0, 0, 0.33],
                    [final_left_matrix[0][0], final_left_matrix[0][1], final_left_matrix[1][0], final_left_matrix[1][1], left_x_offset, -left_y_offset, 0.33],
                    [final_right_matrix[0][0], final_right_matrix[0][1], final_right_matrix[1][0], final_right_matrix[1][1], right_x_offset, -right_y_offset, 0.33]];

let shapes = ["Square", "Bubble", "Blur", "Linear", "Circle", "Sin", "Exponential", "Swirl", "Horseshoe", "Polar", "Handkerchief", "Heart", "Disc", "Spiral", "Diamond", "Julia"];
let function_transforms = [shapes[shape], "Linear", "Linear"];

function linear(x,y){
    return [x, y];
}

function square(x, y){
    var r1 = Math.random();
    var r2 = Math.random();
    return [(r1 - 0.5), (r2 - 0.5)];
}

function bubble(x, y){
    var r = 1.0;
    var multiplier = 4.0/(Math.pow(r,2.0) + 4.0);
    return [multiplier*x, multiplier*y];
}

function blur(x, y){
    var r1 = Math.random();
    var r2 = Math.random();
    return [r1*Math.cos(2*Math.PI*r2), r1*Math.sin(2*Math.PI*r2)];
}

function circle(x, y){
    var t = 2*Math.PI*Math.random();
    var u = Math.random() + Math.random();
    var r = u;
    if(u>1.0){
        r = 2-u;
    }
    return [r*Math.cos(t), r*Math.sin(t)];
}

function sin_f(x, y) {
    return [Math.sin(x), Math.sin(y)];
}

function exponential(x, y) {
    let exp = Math.exp(x - 1);
    return [exp * Math.cos(Math.PI * y), exp * Math.sin(Math.PI * y)];
}

function swirl(x, y) {
    let r2 = x * x + y * y;
    return [x * Math.sin(r2) - y * Math.cos(r2), x * Math.cos(r2) + y * Math.sin(r2)];
}

function horseshoe(x, y) {
    let r = Math.sqrt(x * x + y * y);
    return [(x - y) * (x + y) / r, 2 * x * y / r];
}

function polar(x, y) {
    let r = Math.sqrt(x * x + y * y);
    let theta = Math.atan2(y, x);
    return [theta / Math.PI, r - 1];
}

function handkerchief(x, y) {
    let r = Math.sqrt(x * x + y * y);
    let theta = Math.atan2(y, x);
    return [r * Math.sin(theta + r), r * Math.cos(theta - r)];
}

function heart(x, y) {
    let r = Math.sqrt(x * x + y * y);
    let theta = Math.atan2(y, x);
    return [r * Math.sin(theta * r), -r * Math.cos(theta * r)];
}

function disc(x, y) {
    let r = Math.sqrt(x * x + y * y);
    let theta = Math.atan2(y, x);
    return [theta / Math.PI * Math.sin(Math.PI * r), theta / Math.PI * Math.cos(Math.PI * r)];
}

function spiral(x, y) {
    let r = Math.sqrt(x * x + y * y);
    let theta = Math.atan2(y, x);
    return [(1 / r) * (Math.cos(theta) + Math.sin(r)), (1 / r) * (Math.sin(theta) - Math.cos(r))];
}

function diamond(x, y) {
    let r = Math.sqrt(x * x + y * y);
    let theta = Math.atan2(y, x);
    return [Math.sin(theta) * Math.cos(r), Math.cos(theta) * Math.sin(r)];
}

function julia(x, y) {
    let r = Math.sqrt(x * x + y * y);
    let theta = Math.atan2(y, x);
    let omega = Math.random() < 0.5 ? theta / 2 : theta / 2 + Math.PI;
    return [Math.sqrt(r) * Math.cos(omega), Math.sqrt(r) * Math.sin(omega)];
}

function walk(i) {
    turtle.jump(x * 20 + x_post, - y * 20 + y_post);
    turtle.circle(.1);

    let r = Math.random();
    let p_total = 0;

    for (let j = 0; j < function_set.length; j++) {
        let f = function_set[j];
        p_total += f[6];

        if (r < p_total) {
            // Use precomputed function lookup
            let next;
            switch (function_transforms[j]) {
                case "Square": next = square(x, y); break;
                case "Bubble": next = bubble(x, y); break;
                case "Blur": next = blur(x, y); break;
                case "Circle": next = circle(x, y); break;
                case "Sin": next = sin_f(x, y); break;
                case "Exponential": next = exponential(x, y); break;
                case "Swirl": next = swirl(x, y); break;
                case "Horseshoe": next = horseshoe(x, y); break;
                case "Polar": next = polar(x, y); break;
                case "Handkerchief": next = handkerchief(x, y); break;
                case "Heart": next = heart(x, y); break;
                case "Disc": next = disc(x, y); break;
                case "Spiral": next = spiral(x, y); break;
                case "Diamond": next = diamond(x, y); break;
                case "Julia": next = julia(x, y); break;
                default: next = linear(x, y);
            }

            // Apply transformation matrix
            x = next[0] * f[0] + next[1] * f[1] + f[4];
            y = next[0] * f[2] + next[1] * f[3] + f[5];

            break;
        }
    }

    return i < 10000000;
}