0xa3e51498…25a5sent to0xa7d8d9ef…d270·#13,202,507·view on Etherscan
}
if (centeredShape > 64 && centeredShape < 128 && frameShape != "ellipse") {
centeredShapeType = "solid";
noStroke();
let centEllipseScaler = random(72, 97);
fill(clrs[0]);
ellipse(s(512), s(512), s(centEllipseScaler * 7 + (centEllipseScaler / 2)), s(centEllipseScaler * 7 + (centEllipseScaler / 3)));
}
if (centeredShape > 127 && centeredShape < 226) {
centeredShapeType = "solid";
if (centeredShapeType == "solid") {
noStroke();
fill(clrs[0]);
triangle(DIM / 6 + (s(centeredShape) / 5), DIM / 6 + (s(centeredShape) / 5), DIM / 2 + (s(centeredShape) / 5), DIM / 2 + (s(centeredShape) / 5), DIM / 3 + (s(centeredShape) / 5), DIM / 1.5 + (s(centeredShape) / 5));
}
}
if (centeredShape > 224 && frameShape != "square" && type == "dark") {
if (frameShape == "square") centeredShape = xx(28);
let sourceGradientRect;
let maskGradientRect;
let rect_mover = Math.floor(randomOffset / 2);
let rect_mover2 = Math.floor(randomOffset2 / 2);
let rect_size = 0;
sourceGradientRect = createGraphics(DIM, DIM);
let y_lerp = 0;
let gradientShapePosX = int(srandom(228, 724));
let gradientShapePosY = int(srandom(128, 724));
let w_lerp = gradientShapePosX + s(340);
let h_lerp = gradientShapePosY + s(340);
for (var i = (s(320) + rect_mover2); i <= ((s(320) + rect_mover2) + (rect_size * 2 + s(320))) * 2; i++) {
let inter = map(i, y_lerp, y_lerp + h_lerp, 0, 1);
let c = lerpColor(clrs[2], clrs[0], inter);
sourceGradientRect.strokeWeight(2);
sourceGradientRect.stroke(c);
sourceGradientRect.line(0, i, DIM + w_lerp, i);
}
maskGradientRect = createGraphics(DIM, DIM);
if (abs(randomOffset2) < s(100)) rect_size = 2 * (abs(randomOffset2));
if (abs(randomOffset2) > s(99)) rect_size = abs(randomOffset2) / 2;
maskGradientRect.rect(s(480) + rect_mover, s(320) + rect_mover2, rect_size + s(160), rect_size * 2 + s(320));
applyMask(sourceGradientRect, maskGradientRect);
}
let floatingShape1 = xx(14);
if (floatingShape1 < 65 && floatingShape1 > 31) {
noStroke();
fill(clrs[1]);
triangle(s(128) + DIM / 2 + randomOffset, DIM / 2 + randomOffset, DIM / 3, DIM / 1.5, DIM / 4 + randomOffset, DIM / 4);
}
if (floatingShape1 < 32 && floatingShape1 > 16) {
strokeWeight(s(16));
fill(clrs[1]);
stroke(clrs[3]);
triangle(s(128) + DIM / 2 + randomOffset, DIM / 2 + randomOffset, DIM / 3, DIM / 1.5, DIM / 4 + randomOffset, DIM / 4);
}
if (floatingShape1 < 16) {
strokeWeight(s(16));
fill(clrs[1]);
triangle(s(128) + DIM / 2 + randomOffset, DIM / 2 + randomOffset, DIM / 3, DIM / 1.5, DIM / 4 + randomOffset, DIM / 4);
}
if (floatingShape1 > 64 && floatingShape1 < 230) {
noStroke();
fill(clrs[3]);
triangle(s(768) + randomOffset / 4, s(420) + randomOffset2 / 2, s(626) + randomOffset2 / 2, s(824) + randomOffset3 / 3, s(400) + randomOffset3 / 3, s(512) + randomOffset / 2); }
if (floatingShape1 > 229 && sprinkles_used == false) {
sprinkles_used = true;
let sourceSprinklesTriangle;
let maskSprinklesTriangle;
sourceSprinklesTriangle = createGraphics(DIM, DIM);
sourceSprinklesTriangle.background(clrs[1]);
sourceSprinklesTriangle.strokeCap(ROUND);
sourceSprinklesTriangle.strokeWeight(s(6));
sourceSprinklesTriangle.stroke(clrs[3]);
let sprinkle_column = 0;
let sprinkle_row = 0;
let sprinkle_switch = 0;
while (sprinkle_row < (round(1.1953125 * DIM))) {
while (sprinkle_column < DIM) {
sourceSprinklesTriangle.line(s(-6) + sprinkle_row, s(16) + sprinkle_column, s(4) + sprinkle_row, s(30) + sprinkle_column);
sourceSprinklesTriangle.line(s(-8) + sprinkle_row, s(48) + sprinkle_column, s(8) + sprinkle_row, s(48) + sprinkle_column);
sourceSprinklesTriangle.line(s(0) + sprinkle_row, s(72) + sprinkle_column, s(0) + sprinkle_row, s(88) + sprinkle_column);
sourceSprinklesTriangle.line(s(4) + sprinkle_row, s(108) + sprinkle_column, s(-6) + sprinkle_row, s(124) + sprinkle_column);
sourceSprinklesTriangle.line(s(-8) + sprinkle_row, s(148) + sprinkle_column, s(8) + sprinkle_row, s(148) + sprinkle_column);
sprinkle_column = sprinkle_column + s(158);
}
sprinkle_switch++;
sprinkle_row = sprinkle_row + s(32);
if (sprinkle_switch % 2 == 0) {
sprinkle_column = s(0);
}
if (sprinkle_switch % 2 != 0) {
sprinkle_column = s(-79);
}
if (sprinkle_switch % 3 == 0) {
sprinkle_column = s(-128);
}
}
maskSprinklesTriangle = createGraphics(DIM, DIM);
maskSprinklesTriangle.noStroke();
maskSprinklesTriangle.fill(255);
maskSprinklesTriangle.triangle(s(768) + randomOffset / 4, s(420) + randomOffset2 / 2, s(626) + randomOffset2 / 2, s(824) + randomOffset / 3, s(400) + randomOffset / 3, s(512) + randomOffset / 2);
applyMask(sourceSprinklesTriangle, maskSprinklesTriangle);
}
if (floatingShape1 > 64 && floatingShape1 < 80 && bgType != "notebook" && framingShapeType != "notebook") {
let sourceNotebook;
let maskNotebook;
sourceNotebook = createGraphics(DIM, DIM);
'use strict'
let grid = [];
let notebook = [];
let f = 0.02;
let seed = floor(xx(17));
noiseSeed(seed);
notebook[0] = color(0, 0, 0);
notebook[1] = color(255, 255, 255);
let ratio = .5;
if (type == "light") {
ratio = .39
} else {
ratio = .58
}
let dimScale = DIM/DEFAULT_SIZE
for (let y = 0; y < DIM; y++) {
for (let x = 0; x <= DIM; x++) {
let xsc = floor(x/dimScale)
let ysc = floor(y/dimScale)
let i = noise(xsc * f, ysc * f) < ratio ? 1 : 0;
grid.push({
x,
y,
i
});
}
}
sourceNotebook.noStroke();
grid.forEach((g, index) => {
sourceNotebook.fill(notebook[g.i])
sourceNotebook.rect(g.x, g.y, 1, 1);
});
maskNotebook = createGraphics(DIM, DIM);
maskNotebook.noStroke();
maskNotebook.fill(255);
let notebookellipse_failsafe = 0;
let notebookellipseX_failsafe = 0;
let notebookellipseSize_failsafe = 0;
if (abs(randomOffset * 2) < s(256)) notebookellipse_failsafe = s(480);
if (abs(randomOffset2 * 2) > s(400)) notebookellipseSize_failsafe = s(-100);
if (abs(randomOffset2 * 2) < s(65)) notebookellipseSize_failsafe = s(256);
if (abs(randomOffset * 3) < s(256)) notebookellipseX_failsafe = s(256);
maskNotebook.ellipse(abs(randomOffset * 3) + notebookellipseX_failsafe, abs(randomOffset * 2) + notebookellipse_failsafe, abs(randomOffset2 * 2) + notebookellipseSize_failsafe, abs(randomOffset2 * 2) + notebookellipseSize_failsafe);
if (type == "based") {
blendMode(ADD);
}
applyMask(sourceNotebook, maskNotebook);
blendMode(BLEND);
}
if (floatingShape1 > 79 && floatingShape1 < 100) {
ss_circle = true;
sprinkles_used = true;
let sourceSprinksCircle;
let maskSprinksCircle;
sourceSprinksCircle = createGraphics(DIM, DIM);
sourceSprinksCircle.background(clrs[2]);
sourceSprinksCircle.strokeCap(ROUND);
sourceSprinksCircle.strokeWeight(s(6));
sourceSprinksCircle.stroke(clrs[3]);
let sprinkle_column = 0;
let sprinkle_row = 0;
let sprinkle_switch = 0;
while (sprinkle_row < (round(1.1953125 * DIM))) {
while (sprinkle_column < DIM) {
sourceSprinksCircle.line(s(-6) + sprinkle_row, s(16) + sprinkle_column, s(4) + sprinkle_row, s(30) + sprinkle_column);
sourceSprinksCircle.line(s(-8) + sprinkle_row, s(48) + sprinkle_column, s(8) + sprinkle_row, s(48) + sprinkle_column);
sourceSprinksCircle.line(s(0) + sprinkle_row, s(72) + sprinkle_column, s(0) + sprinkle_row, s(88) + sprinkle_column);
sourceSprinksCircle.line(s(4) + sprinkle_row, s(108) + sprinkle_column, s(-6) + sprinkle_row, s(124) + sprinkle_column);
sourceSprinksCircle.line(s(-8) + sprinkle_row, s(148) + sprinkle_column, s(8) + sprinkle_row, s(148) + sprinkle_column);
sprinkle_column = sprinkle_column + s(158);
}
sprinkle_switch++;
sprinkle_row = sprinkle_row + s(32);
if (sprinkle_switch % 2 == 0) {
sprinkle_column = s(0);
}
if (sprinkle_switch % 2 != 0) {
sprinkle_column = s(-79);
}
if (sprinkle_switch % 3 == 0) {
sprinkle_column = s(-128);
}
}
maskSprinksCircle = createGraphics(DIM, DIM);
maskSprinksCircle.ellipse(s(512) + randomOffset, s(512) + randomOffset, floatingShape1 * s(2), floatingShape1 * s(2));
applyMask(sourceSprinksCircle, maskSprinksCircle);
}
if (floatingShape1 > 69 && floatingShape1 < 150 && bgType != "horizon" && bgType != "grid" && bgType != "fakegrid" && bgType != "3Dgrid" && centeredShapeType != "horizon" && bars_used == false && grid_used == false) {
bars_used = true;
let gridSize = xx(42);
gridSize = gridSize * 2;
if (gridSize < 65) {
gridSize = gridSize + 64;
}
if (gridSize > 500) {
gridSize = Math.floor(gridSize / 2);
}
gridSize = s(gridSize);
let floatingGridCounter = s(32);
let floatingGridCounterH = s(32);
let floatingGrid_height_failsafe = 0;
if (s(340) + randomOffset2 + floatingGridCounterH > s(512) && gridSize > s(200)) {
floatingGrid_height_failsafe = s(-200);
}
noFill();
strokeWeight(s(2));
if (type == "light") {
stroke(0);
}
if (type == "dark") {
stroke(255);
}
while (floatingGridCounterH < gridSize) {
while (floatingGridCounter < gridSize) {
square(s(300) + randomOffset3 + floatingGridCounter, s(340) + randomOffset2 + floatingGridCounterH + floatingGrid_height_failsafe, s(32));
floatingGridCounter = floatingGridCounter + s(32);
}
floatingGridCounterH = floatingGridCounterH + s(32);
floatingGridCounter = s(32);
}
}
if (floatingShape1 > 149 && floatingShape1 < 175 && bgType != "horizon" && bgType != "grid" && bgType != "fakegrid" && bgType != "3Dgrid" && centeredShapeType != "horizon" && bars_used == false) {
if (type == "based") {
blendMode(ADD);
}
bars_used = true;
let gridSize = s(xx(40)) * 2;
gridSize = gridSize * 2;
if (gridSize < s(65)) {
gridSize = gridSize + s(64);
}
if (gridSize > s(500)) {
gridSize = Math.floor(gridSize / 2);
}
let floatingGridCounter = s(32);
let floatingGridCounterH = s(32);
let floatingGrid_height_failsafe = 0;
if (s(340) + randomOffset2 + floatingGridCounterH > s(512) && gridSize > s(200)) {
floatingGrid_height_failsafe = s(-200);
}
noFill();
strokeWeight(s(2));
if (type == "light") {
stroke(0);
}
if (type == "dark") {
stroke(255);
}
let blackSquareStart = true;
while (floatingGridCounterH < gridSize) {
currSquareBlack = blackSquareStart;
while (floatingGridCounter < gridSize) {
fill(currSquareBlack ? 0 : 255);
square(s(300) + randomOffset3 + floatingGridCounter, s(340) + randomOffset2 + floatingGridCounterH + floatingGrid_height_failsafe, s(32));
floatingGridCounter += s(32);
currSquareBlack = !currSquareBlack;
}
blackSquareStart = !blackSquareStart;
floatingGridCounterH += s(32);
floatingGridCounter = s(32);
}
blendMode(BLEND);
}
if (floatingShape1 > 174 && floatingShape1 < 200 && bgType != "horizon" && centeredShapeType != "horizon") {
bars_used = true;
stroke(nonBGColor(2));
strokeWeight(s(4));
strokeCap(ROUND);
let radius = s(xx(30));
if (radius < s(100)) {
radius += s(76);
}
if (radius > s(200)) {
radius -= s(55);
}
let lineH = radius * (-1);
let firstlastline = 16;
let venetian_circle_failsafe = 0;
while (lineH < radius) {
let chord = pow(radius, 2) - pow(lineH, 2);
if (lineH + s(32) >= radius) {
firstlastline = (-4);
}
if (randomOffset < s(-100)) {
venetian_circle_failsafe = s(250);
}
line(s(412) + randomOffset2, s(356) + lineH + randomOffset + venetian_circle_failsafe, s(412) + firstlastline + sqrt(chord) + randomOffset2, s(356) + lineH + randomOffset + venetian_circle_failsafe);
line(s(412) + randomOffset2, s(356) + lineH + randomOffset + venetian_circle_failsafe, s(412) - firstlastline - sqrt(chord) + randomOffset2, s(356) + lineH + randomOffset + venetian_circle_failsafe);
lineH = lineH + s(16);
firstlastline = 0;
}
}
if (floatingShape1 > 99 && floatingShape1 < 125) {
strokeWeight(s(32));
noFill();
stroke(nonBGColor(2));
strokeCap(SQUARE);
let arcBegin = radians(random(0, 200) + 10);
let arcEnd = radians(random(0, 200) + 10);
arcBegin = arcBegin / 4;
arcEnd = arcEnd * 2;
if (arcEnd - arcBegin < radians(50)) {
arcEnd = arcEnd * 4;
}
if (arcEnd - arcBegin > radians(330)) {
arcEnd = arcEnd / 3;
}
if (randomOffset4 > s(125)) {
arcBegin = arcBegin + radians(180);
arcEnd = arcEnd + radians(180);
}
let arcSize = abs(randomOffset4) + s(100);
arc(s(512), s(512), arcSize, arcSize, arcBegin, arcEnd);
}
if (floatingShape1 > 124 && floatingShape1 < 150 && bars_used == false) {
if (type == "based") {
blendMode(ADD);
}
worms_used = true;
let sourceWormsCircle;
let maskWormsCircle;
sourceWormsCircle = createGraphics(DIM, DIM);
sourceWormsCircle.background(255);
sourceWormsCircle.noFill();
sourceWormsCircle.strokeCap(ROUND);
sourceWormsCircle.strokeWeight(s(5));
sourceWormsCircle.stroke(0);
let worm_column = 0;
let worm_row = 0;
let worm_switch = 0;
let bezX1 = s(16);
let bezX2 = s(4);
let bezY1 = s(32);
while (worm_row < s(1224)) {
while (worm_column < DIM) {
sourceWormsCircle.beginShape();
sourceWormsCircle.curveVertex(s(int(random(0, 12) - bezX1)) + worm_row, s(int(random(0, 24)) - bezY1) + worm_column);
sourceWormsCircle.curveVertex(s(int(random(0, 24))) + worm_row, s(int(random(0, 24))) + worm_column);
sourceWormsCircle.curveVertex(s(int(random(0, 26))) + worm_row, s(int(random(0, 24))) + worm_column);
sourceWormsCircle.curveVertex(s(int(random(0, 32))) + worm_row, int(random(0, 24)) + worm_column);
sourceWormsCircle.curveVertex(s(int(random(0, 36))) + bezX2 + worm_row, s(int(random(0, 24))) + bezY1 + worm_column);
sourceWormsCircle.endShape();
worm_column = worm_column + s(24);
}
worm_column = worm_column + s(158);
worm_switch++;
worm_row = worm_row + s(32);
if (worm_switch % 2 == 0) {
worm_column = 0;
}
if (worm_switch % 2 != 0) {
worm_column = s(-79);
}
if (worm_switch % 3 == 0) {
worm_column = s(-128);
}
}
maskWormsCircle = createGraphics(DIM, DIM);
maskWormsCircle.ellipse(s(512) + randomOffset, s(512) + randomOffset, s(floatingShape1 * 2), s(floatingShape1 * 2));
applyMask(sourceWormsCircle, maskWormsCircle);
blendMode(BLEND);
}
if (floatingShape1 > 200 && floatingShape1 < 241 && bgType != "dots") {
floatingShapeType = "dots_circle";
let sourceDotsCircle;
let maskDotsCircle;
sourceDotsCircle = createGraphics(DIM, DIM);
let dots_circle_counter = 0;
let dots_height_counter = 0;
if (type == "light") {
sourceDotsCircle.background(255, 255, 255);
}
if (type == "dark") {
sourceDotsCircle.background(0, 0, 0);
}
if (type == "based") {
sourceDotsCircle.background(clrs[0]);
}
while (dots_height_counter < DIM) {
while (dots_circle_counter < DIM) {
sourceDotsCircle.noStroke();
sourceDotsCircle.fill(clrs[1]);
sourceDotsCircle.ellipse(dots_circle_counter, dots_height_counter, s(4), s(4));
dots_circle_counter = dots_circle_counter + s(8);
}
dots_height_counter = dots_height_counter + s(8);
dots_circle_counter = 0;
}
maskDotsCircle = createGraphics(DIM, DIM);
maskDotsCircle.ellipse(s(512) + randomOffset, s(512) + randomOffset, s(floatingShape1), s(floatingShape1));
applyMask(sourceDotsCircle, maskDotsCircle);
}
let curveWiggler1 = s(xx(16));
let curveWiggler2 = s(xx(18));
let curveWiggler4 = s(xx(20));
let curveWiggler5 = s(xx(22));
let curveType = xx(14);
if (curveType < 16) {
let sourceGradientCurve;
let maskGradientCurve;
sourceGradientCurve = createGraphics(DIM, DIM);
let x_lerp = 0;
let y_lerp = 0;
let w_lerp = DIM;
let h_lerp = DIM;
for (let i = y_lerp; i <= y_lerp + h_lerp; i++) {
let inter = map(i, y_lerp, y_lerp + h_lerp, 0, 1);
let c = lerpColor(clrs[0], clrs[1], inter);
sourceGradientCurve.strokeWeight(2);
sourceGradientCurve.stroke(c);
sourceGradientCurve.line(i, x_lerp, i, x_lerp + w_lerp);
}
maskGradientCurve = createGraphics(DIM, DIM);
if (curveWiggler1 > s(170)) {
curveWiggler1 = curveWiggler1 - s(100);
}
if (curveWiggler2 > s(120)) {
curveWiggler2 = curveWiggler2 - s(100);
}
if (curveWiggler4 > s(170)) {
curveWiggler4 = curveWiggler4 - s(100);
}
if (curveWiggler5 > s(170)) {
curveWiggler5 = curveWiggler5 - s(100);
}
let curveHeightInt = s(xx(24));
let curveHeightOffset = 0;
let curveOffset = s(xx(26));
curveHeightOffset = curveHeightInt;
curveHeightOffset = curveHeightOffset * (-2);
if (xx(26) > 63 && xx(26) < 100) {
curveOffset *= 4;
}
if (xx(26) < 64) {
curveOffset = curveOffset * (-1);
}
if (xx(26) > 100) {
curveOffset = curveOffset / 5;
}
if (xx(26) < 165) {
curveHeightOffset = curveHeightInt;
curveHeightOffset = curveHeightOffset * (-2);
}
maskGradientCurve.noFill();
maskGradientCurve.strokeWeight(s(8));
maskGradientCurve.stroke(255);
let failsafe_flourish_mover = 0;
maskGradientCurve.beginShape();
if ((s(64) + curveOffset * 4) < 1) {
failsafe_flourish_mover = s(200);
}
let flourishOffset = s(-320);
if (curveHeightOffset < s(-300)) {
curveHeightOffset += s(300);
}
maskGradientCurve.curveVertex(flourishOffset + s(120) + curveOffset * 4 + curveWiggler1 + failsafe_flourish_mover, s(256) + curveWiggler2 + curveOffset + curveHeightOffset);
maskGradientCurve.curveVertex(flourishOffset + s(360) + curveOffset * 4 + failsafe_flourish_mover, s(550) + curveWiggler2 + curveOffset + curveHeightOffset);
maskGradientCurve.curveVertex(flourishOffset + s(480) + curveOffset * 4 + curveWiggler2 + failsafe_flourish_mover, s(256) + curveWiggler1 + curveWiggler2 + curveOffset + curveHeightOffset);
maskGradientCurve.curveVertex(flourishOffset + s(520) + curveOffset * 4 + failsafe_flourish_mover, s(740) + curveWiggler4 + (curveWiggler2 / 2) + curveOffset + curveHeightOffset);
maskGradientCurve.curveVertex(flourishOffset + s(660) + curveOffset * 4 + curveWiggler1 + failsafe_flourish_mover, s(460) + curveWiggler5 + curveWiggler2 + 2 * curveOffset + curveHeightOffset);
maskGradientCurve.curveVertex(flourishOffset + s(860) + curveOffset * 4 + failsafe_flourish_mover, s(512) + curveWiggler5 + 4 * curveOffset + curveHeightOffset);
maskGradientCurve.curveVertex(flourishOffset + s(1060) + curveOffset * 4 + failsafe_flourish_mover, s(512) + curveWiggler1 + curveOffset + curveHeightOffset);
maskGradientCurve.curveVertex(flourishOffset + s(2400) + curveOffset * 4 + failsafe_flourish_mover, s(800) + curveWiggler4 + (curveWiggler2 / 2) + curveOffset + curveHeightOffset - s(600));
maskGradientCurve.endShape();
applyMask(sourceGradientCurve, maskGradientCurve);
}
if (curveType > 15 && curveType < 65) {
if (curveWiggler1 > s(170)) {
curveWiggler1 -= s(100);
}
if (curveWiggler2 > s(120)) {
curveWiggler2 -= s(100);
}
if (curveWiggler4 > s(170)) {
curveWiggler4 -= s(100);
}
if (curveWiggler5 > s(170)) {
curveWiggler5 -= s(100);
}
let curveHeightInt = s(xx(24));
let curveHeightOffset = 0;
let curveOffset = s(xx(26));
curveHeightOffset = curveHeightInt;