### It's-a me 🍕

Mario!!!

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

```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();
.map(pt => V.scale(pt, cell.size))
.map(pt => V.scale(V.add([mario[0].length % 2 == 1?cell.size/2:0, 0], pt), .8))
);
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
///////////////////////////////////////////////////////
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];
}
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) {
.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();
//