It's-a me 🍕

Mario!!!

Cover art to go with dittytoy.net/ditty/2a0acbb94b

Log in to post a comment.

const stance = 0; //min=0 max=1 step=1 (At ease, Jump)
const penSize = .15; //min=.01 max=1 step=.01

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

const mario = [[
    [11, [4128831,3932163,3942575,3279530,174634,174083,3975855,3948671,3162191,16451,54720,2774378,3822955,3497303,3161859,16128]],
    [14, [268435434,267387786,264241194,264407552,253799072,204120739,204111875,264415759,201344063,203441279,212432252,262231376,5264720,5506384,5636095,67108863]]
][stance]].map(m => m[1].map(v => Array.from({length: m[0]}).map((e,i,a,b=2*(a.length-i-1)) => v>>b & 3))).pop();

const colors = [1,2,4,0];

// Global code will be evaluated once.
init();
const turtle = new Turtle();
const polygons = new Polygons();
const grid = new SquareGrid(mario.length, 0, 5, (c,r,d=mario.length-mario[0].length,e=Math.floor(d/2))=>(c<e||c>=mario.length-d+e+1)?3:mario[r][c-e],200);

const iterator = grid.iterator();
// The walk function will be called until it returns false.
function walk(i) {
    const iteration = iterator.next();
    const cell = iteration.value;
    
    const p = polygons.create();
    p.addPoints(...[[-.5,-.5],[.5,-.5],[.5,.5],[-.5,.5]]
        .map(pt => V.scale(pt, cell.size))
        .map(pt => V.add(pt, cell.center))
        .map(pt => V.scale(V.add([mario[0].length % 2 == 1?cell.size/2:0, 0], pt), .8))
    );
    if(colors[cell.value]) p.addHatching(1, penSize*colors[cell.value]);
    polygons.draw(turtle, p);
    
    return !iteration.done;
}

////////////////////////////////////////////////////////////////
// Square Grid utility code - Created by Jurgen Westerhof 2024
// Modified: https://turtletoy.net/turtle/6c24a2a461
////////////////////////////////////////////////////////////////
function SquareGrid(grid, padding=2, margin = 5, populateFn = (column, row) => false, canvasSize = 200) {
    class SquareGrid {
        //cells[column][row] is a 2d array holding the values of the grid
        constructor(grid, padding = 2, margin = 5, populateFn = (column, row) => false, canvasSize = 200) {this.gridSize = grid;this.padding = padding;this.margin = margin;this.cells = Array.from({length: this.gridSize}).map((e, column) => Array.from({length: this.gridSize}).map((e, row) => populateFn(column, row)));this.canvasSize = canvasSize;this.resetCellSize();}
        resetCellSize() { this.cellSize = ((this.canvasSize - this.margin - this.margin - ((this.gridSize - 1) * this.padding)) / this.gridSize);}
        getColumnRow(i) { return [i % this.gridSize, i / this.gridSize | 0]; }
        getCellCenter(col, row) { return [col, row].map(v => this.margin - 100 + (v * this.padding) + ((v + .5) * this.cellSize)); }
        getCell(col, row) { return { center: this.getCellCenter(col, row), colrow: [col, row], iteration: col + row * this.gridSize, size: this.cellSize, value: this.cells[col][row] }}
        get length() { return this.gridSize**2; }
        *iterator() { let ptr = 0; while(ptr < this.length - 1) { yield this.getCell(...this.getColumnRow(ptr++)); } return this.getCell(...this.getColumnRow(ptr++)); }
        getValue(col, row) { return this.cells[col][row]; }
        setValue(col, row, value) { this.cells[col][row] = value; }
        isValid(col, row) { return 0 <= col && col < this.gridSize && 0 <= row && row < this.gridSize; }
    }
    return new SquareGrid(grid, padding, margin, populateFn, canvasSize);
}

function init() {
    ///////////////////////////////////////////////////////
    // Vector functions - Created by Jurgen Westerhof 2024
    // https://turtletoy.net/turtle/d068ad6040
    ///////////////////////////////////////////////////////
    class Vector {
        static add  (a,b) { return a.map((v,i)=>v+b[i]); }
        static sub  (a,b) { return a.map((v,i)=>v-b[i]); }
        static mul  (a,b) { return a.map((v,i)=>v*b[i]); }
        static div  (a,b) { return a.map((v,i)=>v/b[i]); }
        static scale(a,s) { return a.map(v=>v*s); }
    
        static det(m)                { return m.length == 1? m[0][0]: m.length == 2 ? m[0][0]*m[1][1]-m[0][1]*m[1][0]: m[0].reduce((r,e,i) => r+(-1)**(i+2)*e*this.det(m.slice(1).map(c => c.filter((_,j) => i != j))),0); }
        static angle(a)              { return Math.PI - Math.atan2(a[1], -a[0]); } //compatible with turtletoy heading
        static rot2d(angle)          { return [[Math.cos(angle), -Math.sin(angle)], [Math.sin(angle), Math.cos(angle)]]; }
        static rot3d(yaw,pitch,roll) { return [[Math.cos(yaw)*Math.cos(pitch), Math.cos(yaw)*Math.sin(pitch)*Math.sin(roll)-Math.sin(yaw)*Math.cos(roll), Math.cos(yaw)*Math.sin(pitch)*Math.cos(roll)+Math.sin(yaw)*Math.sin(roll)],[Math.sin(yaw)*Math.cos(pitch), Math.sin(yaw)*Math.sin(pitch)*Math.sin(roll)+Math.cos(yaw)*Math.cos(roll), Math.sin(yaw)*Math.sin(pitch)*Math.cos(roll)-Math.cos(yaw)*Math.sin(roll)],[-Math.sin(pitch), Math.cos(pitch)*Math.sin(roll), Math.cos(pitch)*Math.cos(roll)]]; }
        static trans(matrix,a)       { return a.map((v,i) => a.reduce((acc, cur, ci) => acc + cur * matrix[ci][i], 0)); }
        //Mirror vector a in a ray through [0,0] with direction mirror
        static mirror2d(a,mirror)    { return [Math.atan2(...mirror)].map(angle => this.trans(this.rot2d(angle), this.mul([-1,1], this.trans(this.rot2d(-angle), a)))).pop(); }

        static approx(a,b,p) { return this.len(this.sub(a,b)) < (p === undefined? .001: p); }
        static norm  (a)     { return this.scale(a,1/this.len(a)); }
        static len   (a)     { return Math.hypot(...a); }
        static lenSq (a)     { return a.reduce((a,c)=>a+c**2,0); }
        static lerp  (a,b,t) { return a.map((v, i) => v*(1-t) + b[i]*t); }
        static dist  (a,b)   { return Math.hypot(...this.sub(a,b)); }
        
        static dot  (a,b)   { return a.reduce((a,c,i) => a+c*b[i], 0); }
        static cross(...ab) { return ab[0].map((e, i) => ab.map(v => v.filter((ee, ii) => ii != i))).map((m,i) => (i%2==0?-1:1)*this.det(m)); }
    }
    this.V = Vector;
    
    class Intersection2D {
        //a-start, a-direction, b-start, b-direction
        //returns false on no intersection or [[intersection:x,y], scalar a-direction, scalar b-direction
        static info(as, ad, bs, bd) {
            const d = V.sub(bs, as), det = -V.det([bd, ad]);
            if(det === 0) return false;
            const res = [V.det([d, bd]) / det, V.det([d, ad]) / det];
            return [V.add(as, V.scale(ad, res[0])), ...res];
        }
        static ray(a, b, c, d) {
            return this.info(a, b, c, d);
        }
        static segment(a,b,c,d, inclusiveStart = true, inclusiveEnd = true) {
            const i = this.info(a, V.sub(b, a), c, V.sub(d, c));
            return i === false? false: (
                (inclusiveStart? 0<=i[1] && 0<=i[2]: 0<i[1] && 0<i[2])
             && (inclusiveEnd?   i[1]<=1 && i[2]<=1: i[1]<1 && i[2]<1)
            )?i[0]:false;
        }
        static tour(tour, segmentStart, segmentDirection) {
            return tour.map((e, i, a) => [i, this.info(e, V.sub(a[(i+1)%a.length], e), segmentStart, segmentDirection)])
                .filter(e => e[1] !== false && 0 <= e[1][1] && e[1][1] <= 1)
                .filter(e => 0 <= e[1][2])// && e[1][2] <= 1)
                .map(e => ({
                    position: e[1][0],
                    tourIndex: e[0],
                    tourSegmentPortion: e[1][1],
                    segmentPortion: e[1][2],
                })
            );
        }
    }
    this.Intersection = Intersection2D;
}

////////////////////////////////////////////////////////////////
// Polygon Clipping utility code - Created by Reinder Nijhoff 2019
// (Polygon binning by Lionel Lemarie 2021) https://turtletoy.net/turtle/95f33bd383
// (Delegated Hatching by Jurgen Westerhof 2024) https://turtletoy.net/turtle/d068ad6040
// https://turtletoy.net/turtle/a5befa1f8d
//
// const polygons = new Polygons();
// const p = polygons.create();
// polygons.draw(turtle, p);
// polygons.list();
//
// p.addPoints(...[[x,y],]);
// p.addSegments(...[[x,y],]);
// p.addOutline();
// p.addHatching(angle, distance); OR p.addHatching(HatchObject); where HatchObject has a method 'hatch(PolygonClass, thisPolygonInstance)'
// p.inside([x,y]);
// p.boolean(polygon, diff = true);
// p.segment_intersect([x,y], [x,y], [x,y], [x,y]);
////////////////////////////////////////////////////////////////
function Polygons(){const t=[],s=25,e=Array.from({length:s**2},t=>[]),n=class{constructor(){this.cp=[],this.dp=[],this.aabb=[]}addPoints(...t){let s=1e5,e=-1e5,n=1e5,h=-1e5;(this.cp=[...this.cp,...t]).forEach(t=>{s=Math.min(s,t[0]),e=Math.max(e,t[0]),n=Math.min(n,t[1]),h=Math.max(h,t[1])}),this.aabb=[s,n,e,h]}addSegments(...t){t.forEach(t=>this.dp.push(t))}addOutline(){for(let t=0,s=this.cp.length;t<s;t++)this.dp.push(this.cp[t],this.cp[(t+1)%s])}draw(t){for(let s=0,e=this.dp.length;s<e;s+=2)t.jump(this.dp[s]),t.goto(this.dp[s+1])}addHatching(t, s) {if(typeof t == 'object') return t.hatch(n, this);const e=new n;e.cp.push([-1e5,-1e5],[1e5,-1e5],[1e5,1e5],[-1e5,1e5]);const h=Math.sin(t)*s,o=Math.cos(t)*s,a=200*Math.sin(t),i=200*Math.cos(t);for(let t=.5;t<150/s;t++) {e.dp.push([h*t+i,o*t-a],[h*t-i,o*t+a]);e.dp.push([-h*t+i,-o*t-a],[-h*t-i,-o*t+a]);}e.boolean(this,!1);this.dp=[...this.dp,...e.dp]}inside(t){let s=0;for(let e=0,n=this.cp.length;e<n;e++)this.segment_intersect(t,[.1,-1e3],this.cp[e],this.cp[(e+1)%n])&&s++;return 1&s}boolean(t,s=!0){const e=[];for(let n=0,h=this.dp.length;n<h;n+=2){const h=this.dp[n],o=this.dp[n+1],a=[];for(let s=0,e=t.cp.length;s<e;s++){const n=this.segment_intersect(h,o,t.cp[s],t.cp[(s+1)%e]);!1!==n&&a.push(n)}if(0===a.length)s===!t.inside(h)&&e.push(h,o);else{a.push(h,o);const n=o[0]-h[0],i=o[1]-h[1];a.sort((t,s)=>(t[0]-h[0])*n+(t[1]-h[1])*i-(s[0]-h[0])*n-(s[1]-h[1])*i);for(let n=0;n<a.length-1;n++)(a[n][0]-a[n+1][0])**2+(a[n][1]-a[n+1][1])**2>=.001&&s===!t.inside([(a[n][0]+a[n+1][0])/2,(a[n][1]+a[n+1][1])/2])&&e.push(a[n],a[n+1])}}return(this.dp=e).length>0}segment_intersect(t,s,e,n){const h=(n[1]-e[1])*(s[0]-t[0])-(n[0]-e[0])*(s[1]-t[1]);if(0===h)return!1;const o=((n[0]-e[0])*(t[1]-e[1])-(n[1]-e[1])*(t[0]-e[0]))/h,a=((s[0]-t[0])*(t[1]-e[1])-(s[1]-t[1])*(t[0]-e[0]))/h;return o>=0&&o<=1&&a>=0&&a<=1&&[t[0]+o*(s[0]-t[0]),t[1]+o*(s[1]-t[1])]}};return{list:()=>t,create:()=>new n,draw:(n,h,o=!0)=>{reducedPolygonList=function(n){const h={},o=200/s;for(var a=0;a<s;a++){const c=a*o-100,r=[0,c,200,c+o];if(!(n[3]<r[1]||n[1]>r[3]))for(var i=0;i<s;i++){const c=i*o-100;r[0]=c,r[2]=c+o,n[0]>r[2]||n[2]<r[0]||e[i+a*s].forEach(s=>{const e=t[s];n[3]<e.aabb[1]||n[1]>e.aabb[3]||n[0]>e.aabb[2]||n[2]<e.aabb[0]||(h[s]=1)})}}return Array.from(Object.keys(h),s=>t[s])}(h.aabb);for(let t=0;t<reducedPolygonList.length&&h.boolean(reducedPolygonList[t]);t++);h.draw(n),o&&function(n){t.push(n);const h=t.length-1,o=200/s;e.forEach((t,e)=>{const a=e%s*o-100,i=(e/s|0)*o-100,c=[a,i,a+o,i+o];c[3]<n.aabb[1]||c[1]>n.aabb[3]||c[0]>n.aabb[2]||c[2]<n.aabb[0]||t.push(h)})}(h)}}}