0xa3e51498…25a5sent to0xa7d8d9ef…d270·#13,047,186·view on Etherscan
}
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;
curveHeightOffset = curveHeightOffset * (-2);
if (curveOffset > s(63) && curveOffset < s(100)) {
curveOffset = curveOffset * 4;
}
if (curveOffset < s(64)) {
curveOffset = curveOffset * (-1);
}
if (curveOffset > s(100)) {
curveOffset = curveOffset / 5;
}
if (curveOffset < s(165)) {
curveHeightOffset = curveHeightInt;
curveHeightOffset = curveHeightOffset * (-2);
}
noFill();
strokeWeight(s(8));
stroke(clrs[2]);
if (type == "dark" && clrs[2] == color('#000000')) {
stroke(clrs[4]);
}
let failsafe_flourish_mover = 0;
beginShape();
if ((s(64) + curveOffset * 4) < 1) {
failsafe_flourish_mover = s(200);
}
let flourishOffset = s(-320);
if (curveHeightOffset < s(-300)) {
curveHeightOffset = curveHeightOffset + s(300);
}
curveVertex(flourishOffset + s(120) + curveOffset * 4 + curveWiggler1 + failsafe_flourish_mover, s(256) + curveWiggler2 + curveOffset + curveHeightOffset);
curveVertex(flourishOffset + s(360) + curveOffset * 4 + failsafe_flourish_mover, s(550) + curveWiggler2 + curveOffset + curveHeightOffset);
curveVertex(flourishOffset + s(480) + curveOffset * 4 + curveWiggler2 + failsafe_flourish_mover, s(256) + curveWiggler1 + curveWiggler2 + curveOffset + curveHeightOffset);
curveVertex(flourishOffset + s(520) + curveOffset * 4 + failsafe_flourish_mover, s(740) + curveWiggler4 + (curveWiggler2 / 2) + curveOffset + curveHeightOffset);
curveVertex(flourishOffset + s(660) + curveOffset * 4 + curveWiggler1 + failsafe_flourish_mover, s(460) + curveWiggler5 + curveWiggler2 + 2 * curveOffset + curveHeightOffset);
curveVertex(flourishOffset + s(860) + curveOffset * 4 + failsafe_flourish_mover, s(512) + curveWiggler5 + 4 * curveOffset + curveHeightOffset);
curveVertex(flourishOffset + s(1060) + curveOffset * 4 + failsafe_flourish_mover, s(512) + curveWiggler1 + curveOffset + curveHeightOffset);
curveVertex(flourishOffset + s(2400) + curveOffset * 4 + failsafe_flourish_mover, s(800) + curveWiggler4 + (curveWiggler2 / 2) + curveOffset + curveHeightOffset - s(600));
endShape();
}
if (curveType > 64 && curveType < 128) {
let curveOffset = xxs(26);
let curveHeightOffset = 0;
if (curveOffset > s(63) && curveOffset < s(100)) {
curveOffset = curveOffset * 4;
}
if (curveOffset < s(64)) {
curveOffset = curveOffset * (-1);
}
if (curveOffset > s(100)) {
curveOffset = curveOffset / 5;
}
if (curveOffset < s(165)) {
curveHeightOffset = 0 - s(xx(24));
}
noFill();
strokeWeight(s(10));
stroke(clrs[2]);
if (type == "dark" && clrs[2] == color('#000000')) {
stroke(clrs[4]);
}
let failsafe_flourish_mover = 0;
beginShape();
if ((s(64) + curveOffset * 4) < 1) {
failsafe_flourish_mover = s(200);
}
curveVertex(s(64) + curveOffset * 4 + failsafe_flourish_mover, s(320) + curveWiggler1 + curveOffset + curveHeightOffset);
curveVertex(s(128) + curveOffset * 4 + failsafe_flourish_mover, s(640) + curveWiggler4 + curveOffset + curveHeightOffset);
curveVertex(s(160) + curveOffset * 4 + failsafe_flourish_mover, s(420) + curveWiggler2 + curveOffset + curveHeightOffset);
curveVertex(s(200) + curveOffset * 4 + failsafe_flourish_mover, s(600) + curveWiggler1 + curveOffset + curveHeightOffset);
curveVertex(s(260) + curveOffset * 4 + failsafe_flourish_mover, s(400) + curveWiggler5 + curveOffset + curveHeightOffset);
curveVertex(s(512) + curveOffset * 4 + failsafe_flourish_mover, s(560) + curveWiggler2 + curveOffset + curveHeightOffset);
curveVertex(s(768) + curveOffset * 4 + failsafe_flourish_mover, s(128) + curveWiggler1 + curveOffset + curveHeightOffset);
endShape();
}
if (curveType > 129 && curveType < 241) {
noFill();
strokeWeight(s(10));
stroke(nonBGColor(2));
let curveOffset = s(xx(26));
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 curveHeightOffset = 0;
if (curveOffset > s(63) && curveOffset < s(100)) {
curveOffset *= 4;
}
if (curveOffset < s(64)) {
curveOffset *= (-1);
}
if (curveOffset > s(100)) {
curveOffset /= 5;
}
if (curveOffset < s(165)) {
curveHeightOffset = s(xx(24) * -2);
}
noFill();
strokeWeight(s(8));
let failsafe_flourish_mover = 0;
beginShape();
if ((s(64) + curveOffset * 4) < 1) {
failsafe_flourish_mover = s(200);
}
curveVertex(DIM + curveOffset * 4 + failsafe_flourish_mover, 0 + curveWiggler1 + curveOffset + curveHeightOffset);
curveVertex(s(120) + curveOffset * 4 + curveWiggler1 + failsafe_flourish_mover, s(450) + curveWiggler2 + curveOffset + curveHeightOffset);
curveVertex(s(640) + curveOffset * 4 + failsafe_flourish_mover, s(550) + curveWiggler2 + curveOffset + curveHeightOffset);
curveVertex(s(200) + curveOffset * 4 + curveWiggler2 + failsafe_flourish_mover, s(650) + curveWiggler1 + curveWiggler2 + curveOffset + curveHeightOffset);
curveVertex(s(528) + curveOffset * 4 + failsafe_flourish_mover, s(740) + curveWiggler4 + (curveWiggler2 / 2) + curveOffset + curveHeightOffset);
curveVertex(s(128) + curveOffset * 4 + curveWiggler1 + failsafe_flourish_mover, s(875) + curveWiggler5 + curveWiggler2 + 2 * curveOffset + curveHeightOffset);
curveVertex(0 + curveOffset * 4 + failsafe_flourish_mover, s(912) + curveWiggler5 + 4 * curveOffset + curveHeightOffset);
endShape();
}
if (curveType > 240) {
let sourceCurve;
let maskCurve;
sourceCurve = 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);
sourceCurve.strokeWeight(2);
sourceCurve.stroke(c);
sourceCurve.line(x_lerp, i, x_lerp + w_lerp, i);
}
maskCurve = createGraphics(DIM, DIM);
maskCurve.noFill();
maskCurve.strokeWeight(s(10));
maskCurve.stroke(255);
let curveOffset = xxs(26);
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 curveHeightOffset = 0;
if (curveOffset > s(63) && curveOffset < s(100)) {
curveOffset = curveOffset * 4;
}
if (curveOffset < s(64)) {
curveOffset = curveOffset * (-1);
}
if (curveOffset > s(100)) {
curveOffset = curveOffset / 5;
}
if (curveOffset < s(165)) {
curveHeightOffset = xxs(24) * (-2);
}
maskCurve.noFill();
maskCurve.strokeWeight(s(8));
let failsafe_flourish_mover = 0;
maskCurve.beginShape();
if ((s(64) + curveOffset * 4) < 1) {
failsafe_flourish_mover = s(200);
}
maskCurve.curveVertex(DIM + curveOffset * 4 + failsafe_flourish_mover, 0 + curveWiggler1 + curveOffset + curveHeightOffset);
maskCurve.curveVertex(s(120) + curveOffset * 4 + curveWiggler1 + failsafe_flourish_mover, s(450) + curveWiggler2 + curveOffset + curveHeightOffset);
maskCurve.curveVertex(s(640) + curveOffset * 4 + failsafe_flourish_mover, s(550) + curveWiggler2 + curveOffset + curveHeightOffset);
maskCurve.curveVertex(s(200) + curveOffset * 4 + curveWiggler2 + failsafe_flourish_mover, s(650) + curveWiggler1 + curveWiggler2 + curveOffset + curveHeightOffset);
maskCurve.curveVertex(s(528) + curveOffset * 4 + failsafe_flourish_mover, s(740) + curveWiggler4 + (curveWiggler2 / 2) + curveOffset + curveHeightOffset);
maskCurve.curveVertex(s(128) + curveOffset * 4 + curveWiggler1 + failsafe_flourish_mover, s(875) + curveWiggler5 + curveWiggler2 + 2 * curveOffset + curveHeightOffset);
maskCurve.curveVertex(0 + curveOffset * 4 + failsafe_flourish_mover, s(912) + curveWiggler5 + 4 * curveOffset + curveHeightOffset);
maskCurve.endShape();
applyMask(sourceCurve, maskCurve);
}
let floatingShape2 = xx(18);
if (floatingShape2 > 128 && floatingShape2 < 156) {
let bar_triangle;
bar_triangle = createGraphics(DIM, DIM);
let barp = 0;
bar_triangle.stroke(getColor(2));
bar_triangle.strokeWeight(s(10));
bar_triangle.noFill();
while (barp < s(1424)) {
bar_triangle.line(s(-100), s(-400) + barp, s(3400), s(800) + barp);
barp += s(16);
}
let bar_triangle_mask;
bar_triangle_mask = createGraphics(DIM, DIM);
bar_triangle_mask.triangle(
xsBetween(8, 100, 400), xsBetween(18, 100, 400),
xsBetween(7, 400, 550), xsBetween(19, 400, 550),
xsBetween(17, 750, 950), s(512) - xsBetween(9, 100, 120));
applyMask(bar_triangle, bar_triangle_mask);
}
if (floatingShape2 < 7) {
noStroke();
fill(clrs[2]);
rect(s(512) - randomOffset, s(300) - randomOffset / 2, s(floatingShape2 + 16), s(floatingShape2 + 16) * 8);
rect(s(512) - randomOffset + s(64), s(300) - randomOffset / 2 - s(64), s(floatingShape2 + 16), s(floatingShape2 + 16) * 8);
rect(s(512) - randomOffset + s(128), s(300) - randomOffset / 2 - s(128), s(floatingShape2 + 16), s(floatingShape2 + 16) * 8);
}
if (floatingShape2 > 7 && floatingShape2 < 17 && bars_used == false && bgType != "horizon") {
strokeCap(ROUND);
strokeWeight(s(4));
stroke(nonBGColor(3));
bars_used = true;
let halfway_point = false;
let line_circle_var = s(Math.floor(floatingShape2 / 2));
let line_circle_height = s(floatingShape2);
let line_circle_counter = 0;
let height_adder = 0;
let line_anchorX = s(512) + randomOffset;
let line_anchorY = s(128) + randomOffset2;
let line_triangle_height_failsafe = 0;
if ((line_anchorY + (line_circle_counter + height_adder) * line_circle_height) < s(128)) {
line_triangle_height_failsafe = s(256);
}
while (line_circle_counter < 16 && line_circle_counter > -1 && height_adder < 16) {
if (halfway_point == false) {
line(line_anchorX - line_circle_counter * line_circle_var, line_anchorY + (line_circle_counter + height_adder) * line_circle_height + line_triangle_height_failsafe, line_anchorX + line_circle_counter * line_circle_var, line_anchorY + (line_circle_counter + height_adder) * line_circle_height + line_triangle_height_failsafe);
line_circle_counter++;
}
}
}
if (floatingShape2 > 16 && floatingShape2 < 32) {
noStroke();
fill(clrs[2]);
rect(s(512) - randomOffset, s(300) - randomOffset / 2, s(floatingShape2), s(floatingShape2) * 8);
rect(s(512) - randomOffset + s(64), s(300) - randomOffset / 2 + s(64), s(floatingShape2), s(floatingShape2) * 8);
rect(s(512) - randomOffset + s(128), s(300) - randomOffset / 2 + s(128), s(floatingShape2), s(floatingShape2) * 8);
}
if (floatingShape2 < 50 && type == "dark" && clrs[2] != color('#000000') && clrs[3] != color('#000000')) {
let sourceGradient;
let maskGradient;
sourceGradient = createGraphics(DIM, DIM);
let x_lerp = 0;
let y_lerp = 0;
let gradientShapePosX = int(srandom(128, 824));
let gradientShapePosY = int(srandom(128, 824));
let w_lerp = gradientShapePosX + gradientShapePosX;
let h_lerp = gradientShapePosY + gradientShapePosY;
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[2], clrs[3], inter);
sourceGradient.strokeWeight(2);
sourceGradient.stroke(c);
sourceGradient.line(x_lerp, i, x_lerp + w_lerp, i);
}
maskGradient = createGraphics(DIM, DIM);
maskGradient.triangle(gradientShapePosX, gradientShapePosY + s(128),
gradientShapePosX - gradientShapePosX * (0.5),
Math.floor(gradientShapePosY / 3) + s(128),
gradientShapePosX + gradientShapePosX * (0.25), Math.floor(gradientShapePosY / 2) + s(128));
applyMask(sourceGradient, maskGradient);
}
if (floatingShape2 > 50 && type == "dark" && clrs[2] != color('#000000') && clrs[3] != color('#000000')) {
let sourceGradient;
let maskGradient;
sourceGradient = createGraphics(DIM, DIM);
let x_lerp = 0;
let y_lerp = 0;
let gradientShapePosX = int(srandom(228, 724));
let gradientShapePosY = int(srandom(228, 724));
if (floatingShapeType == "dots_circle" && (s(512) + randomOffset) < s(500)) {
gradientShapePosX += s(300);
}
if (ss_circle == true && (s(512) + randomOffset) < s(500)) {
shift_gEllipse = gradientShapePosX += s(300);
}
if (gradientShapePosX > s(700)) {
gradientShapePosX -= s(200);
}
let w_lerp = gradientShapePosX + s(340);
let h_lerp = gradientShapePosY + s(340);
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[2], clrs[3], inter);
sourceGradient.strokeWeight(2);
sourceGradient.stroke(c);
sourceGradient.line(x_lerp, i, x_lerp + w_lerp, i);
}
maskGradient = createGraphics(DIM, DIM);
maskGradient.fill('#000000');
maskGradient.ellipse(gradientShapePosX, gradientShapePosY, s(340), s(340));
applyMask(sourceGradient, maskGradient);
}
if (floatingShape2 > 50 && floatingShape2 < 75) {
let arc_counter = 0;
let arcPosx = 0;
let shiftNoodle = s(-512);
let arcPosy = s(-712);
let ellipse_constant = s(15);
let noodleWaveOffset = srandom(-128, 128);
let noodleWaveOffset2 = srandom(-100, 100);
strokeWeight(s(6));
strokeCap(SQUARE);
stroke(clrs[4]);
noFill();
let rotateRAD = (3 * PI / 4.0);
rotate(rotateRAD);
while (arc_counter <= (6)) {
stroke(clrs[4]);
while (arcPosx < s(512)) {
arc(arcPosx + shiftNoodle + noodleWaveOffset, arcPosy + noodleWaveOffset2, ellipse_constant, ellipse_constant - s(6), PI, TWO_PI, OPEN);
arc(arcPosx + ellipse_constant + shiftNoodle + noodleWaveOffset, (arcPosy - 3) + noodleWaveOffset2, ellipse_constant, ellipse_constant - s(6), 0, PI, OPEN);
arcPosx = arcPosx + 2 * ellipse_constant;
}
arcPosx = 0;
arcPosy = arcPosy - s(15);
arc_counter += 1;
}
rotate(-rotateRAD);
}
if (floatingShape2 > 74 && floatingShape2 < 101) {
noStroke();
fill(clrs[4]);
let zotOffset = srandom(-128, 128);
let zotOffset2 = srandom(-100, 100);
beginShape();
vertex(s(728) + zotOffset, s(240) + zotOffset2);
vertex(s(800) + zotOffset, s(240) + zotOffset2);
vertex(s(768) + zotOffset, s(320) + zotOffset2);
vertex(s(820) + zotOffset, s(320) + zotOffset2);
vertex(s(778) + zotOffset, s(400) + zotOffset2);
vertex(s(820) + zotOffset, s(400) + zotOffset2);
vertex(s(738) + zotOffset, s(540) + zotOffset2);
vertex(s(768) + zotOffset, s(440) + zotOffset2);
vertex(s(720) + zotOffset, s(440) + zotOffset2);
vertex(s(748) + zotOffset, s(360) + zotOffset2);
vertex(s(680) + zotOffset, s(360) + zotOffset2);
vertex(s(728) + zotOffset, s(240) + zotOffset2);
endShape();
}
if (floatingShape2 > 100 && floatingShape2 < 128) {
two_straight = true;
noFill();
stroke(clrs[1]);
strokeWeight(s(16));
strokeCap(SQUARE);
let straightLineLength = abs(randomOffset3) * 2;
let shift_right = 0;
if (straightLineLength > s(300)) {
straightLineLength = straightLineLength / 3;
}