Bitcoin address: bc1qz25j3xkaza99c6jxps8rqkfvs9uzhms6arrv7u

SHOWING: First 60

<!DOCTYPE html>
<html>
<head>
<script src="/content/b6a50f5ba932b0ea7f652d9d28e59eced47bc6f8376c25e02d8b3457bb60ac8fi0"></script>
<style>
body {
    margin: 0;
    padding: 0;
    display: flex;
    flex-direction: column;
    justify-content: flex-start;
    align-items: flex-start;
    height: 100%;
    background-color: #f0f0f0;
    overflow: auto;
}
#controls {
    width: 100%;
    background-color: rgba(255, 255, 255, 0.8);
    box-sizing: border-box;
    z-index: 10;
    position: absolute;
    top: 0;
}
#canvas-container {
    flex: 1;
    width: 100%;
    height: 100%;
}
canvas {
    display: block;
}
</style>
</head>
<body>
<div id="controls">
    <input id="blockNumberInput" type="number" placeholder="Enter block number" style="display: none;" />
</div>
<div id="canvas-container"></div>
<script>
let canvas;
let blockNumber = 1;
let currentP5Instance = null;
let scaleFactor = 1;

const colors = [
    '#000000',
    '#c8b7e3',
    '#f5aab6',
    '#f4a261',
    '#fa8072',
    '#87ceeb',
    '#ffe082'
];

const balloonColors = [
    '#FFB6C1',
    '#FFDDC1',
    '#D3F9D8',
    '#B3E5FC',
    '#E1BEE7',
    '#FFAB91',
    '#FFE082',
    '#F48FB1'
];

function setup() {
    let canvasSize = min(windowWidth, windowHeight);
    canvas = createCanvas(canvasSize, canvasSize);
    canvas.parent('canvas-container');
    noLoop();
    generateColors();
    generateArt();
    document.getElementById('blockNumberInput').value = blockNumber;
    document.getElementById('blockNumberInput').addEventListener('input', updateArt);
    window.addEventListener('resize', resize, true);
    resize();

    let mintText = document.getElementById('preview').getAttribute('mint');
    if (mintText.includes('MINT_INSCRIPTION_ID')) {
        let input = document.getElementById('blockNumberInput');
        input.style.display = 'block';
        input.style.position = 'absolute';
        input.style.fontSize = '10px';
        input.style.margin = '1px';
        input.style.top = '0';
        input.value = blockNumber;
        input.addEventListener('input', () => {
            blockNumber = parseInt(input.value) || 1;
            updateArt();
        });
        updateArt();
    } else {
        const request = new XMLHttpRequest();
        try {
            request.open('GET', '/content/' + mintText);
            request.responseType = 'text';
            request.addEventListener('load', () => initialize(request.response));
            request.addEventListener('error', () => console.error('XHR error'));
            request.send();
        } catch (error) {
            console.error(`XHR error ${request.status}`);
        }
    }
}

function initialize(result) {
    if (result) {
        console.log('Result', result);
        const data = JSON.parse(result);
        blockNumber = data.blk;
    }
    updateArt();
}

function resize(event) {
    let canvasSize = min(windowWidth, windowHeight);
    canvas = createCanvas(canvasSize, canvasSize);

    const root = document.getElementById('canvas-container');
    root.style.width = window.innerWidth - 300 + 'px';
    root.style.height = window.innerHeight + 'px';
    const orgWidth = 300;
    const orgHeight = 300;
    let scaleW = window.innerWidth / orgWidth;
    let scaleH = window.innerHeight / orgHeight;
    let offsetX = 0;
    let offsetY = 0;
    if (scaleH < scaleW) {
        scaleW = scaleH;
        offsetX = (window.innerWidth - orgWidth * scaleW) / 2;
    } else {
        scaleH = scaleW;
        offsetY = (window.innerHeight - orgHeight * scaleH) / 2;
    }
    canvas.style.zoom = scaleW;
    scaleFactor = Math.min(width / 1000, height / 1000);
    redraw();
    updateArt();
}

function updateArt() {
    generateColors();
    generateArt();
}

function generateColors() {
    let colorIndex = (blockNumber - 1) % colors.length;
    background(colors[colorIndex]);

    balloons.forEach(balloon => {
        balloon.color = getRandomBalloonColor();
    });
}
	
function generateArt() {
    Stars();
    Rainbow();    
    updateBalloonColors();
    drawBalloons();
    BirthdayCard(width / 2, height / 1.15, min(width, height) * 0.3);
   
    let burgerWidth = width * 0.3; 
    let burgerHeight = height * 0.4; 
    let x = width / 1.5; 
    let y = height / 1.8;     
    drawDetailedBurger(x, y, burgerWidth, burgerHeight);  
}

function BirthdayCard(x, y, size) {
    let cardWidth = size;
    let cardHeight = size * 0.6;
    fill('#ff8c00'); 
    rectMode(CENTER);
    rect(x, y, cardWidth, cardHeight, 20);
    stroke(082, 193);
    strokeWeight(20);
    noFill();
    rect(x, y, cardWidth, cardHeight, 20);
    textAlign(CENTER, CENTER);
    textStyle(BOLD);
    fill(255);
    noStroke();
    let textSizeTop = cardWidth * 0.1;
    let textSizeMiddle = cardWidth * 0.15;
    let textSizeBottom = cardWidth * 0.1;
    textSize(textSizeTop);
    text("Bitcoin", x, y - cardHeight * 0.2);
    textSize(textSizeMiddle);
    text("Burger Day", x, y);
    textSize(textSizeBottom);
    text("2024-09-18", x, y + cardHeight * 0.2);
}

function updateBalloonColors() {
    balloons = [
        { x: 0.15, y: 0.2, size: 80, color: getRandomBalloonColor() },
        { x: 0.85, y: 0.2, size: 100, color: getRandomBalloonColor() },
        { x: 0.85, y: 0.7, size: 70, color: getRandomBalloonColor() },
        { x: 0.15, y: 0.7, size: 90, color: getRandomBalloonColor() }
    ];
}

function getRandomBalloonColor() {
    return balloonColors[Math.floor(Math.random() * balloonColors.length)];
}

let balloons = [
    { x: 0.15, y: 0.2, size: 80, color: getRandomBalloonColor() },
    { x: 0.85, y: 0.2, size: 100, color: getRandomBalloonColor() },
    { x: 0.85, y: 0.7, size: 70, color: getRandomBalloonColor() },
    { x: 0.15, y: 0.7, size: 90, color: getRandomBalloonColor() }
];

function drawBalloons() {
    for (let balloon of balloons) {
        let x = balloon.x * width;
        let y = balloon.y * height;
        let size = balloon.size * Math.min(width, height) / 1000;
        let color = balloon.color || getRandomBalloonColor();
        drawBalloon(x, y, size, color);
        drawBitcoinLogo3(x, y, size * 0.6);
    }
}

function drawBalloon(x, y, size, color) {
    fill(color);
    noStroke();
    ellipse(x, y, size, size * 1.2);
    fill('#333');
    ellipse(x, y + size * 1.2 / 2, size * 0.2, size * 0.2);
    stroke('#333');
    strokeWeight(2);
    line(x, y + size * 1.2 / 2, x, y + size * 1.2 + 50 * Math.min(width, height) / 1000);
}

function drawDetailedBurger(x, y, w, h) {
  // Colors for the burger layers
  let bunTopColor = color(242, 187, 114); 
  let bunBottomColor = color(242, 187, 114); 
  let pattyColor = color(93, 64, 55); 
  let lettuceColor = color(34, 139, 34); 
  let tomatoColor = color(255, 99, 71); 
  let cheeseColor = color(255, 204, 0); 

  // Thickness of each layer
  let bunThickness = h * 0.07;
  let pattyThickness = h * 0.08;
  let cheeseThickness = h * 0.04;
  let lettuceThickness = h * 0.025;
  let tomatoThickness = h * 0.04;
  let topBunWidth = w * 1; 
  let lettuceWidth = w * 1;   
  let topBunHeight = bunThickness; 
  let lettuceHeight = lettuceThickness * 3;   
  let moveLeft = w * 0.5;   
  let bottomBunY = y + h * 0.2;
  let pattyY = bottomBunY - pattyThickness;
  let cheeseY = pattyY - cheeseThickness;
  let tomatoY = cheeseY - tomatoThickness;
  let lettuceY = tomatoY - lettuceThickness; 
  let topBunY = lettuceY - topBunHeight; 
  
  fill(bunBottomColor);
  rect(x - w / 2, bottomBunY, w, bunThickness, 10); 
  fill(pattyColor);
  rect(x - w / 2, pattyY, w, pattyThickness, 10);  
  fill(cheeseColor);
  rect(x - w / 2, cheeseY, w, cheeseThickness, 10);  
  fill(tomatoColor);
  rect(x - w / 2, tomatoY, w, tomatoThickness, 10);  
  fill(lettuceColor);
  arc(x - moveLeft, lettuceY, lettuceWidth, lettuceHeight, PI, TWO_PI, OPEN);
  fill(bunTopColor);
  ellipse(x - moveLeft, topBunY, topBunWidth, topBunHeight);
}

function Rainbow() {
  let colors = [
    color(148, 0, 211),
    color(75, 0, 130),
    color(0, 0, 255),
    color(0, 255, 0),
    color(255, 255, 0),
    color(255, 127, 0),
    color(255, 0, 0)
  ];
  let startX = width / 2;
  let startY = height * 0.9;
  let radius = Math.min(width, height) * 0.6;
  let arcWidth = radius * 0.015;
  noStroke();
  for (let i = 0; i < colors.length; i++) {
    stroke(colors[i]);
    strokeWeight(arcWidth);
    noFill();
    arc(startX, startY, radius * 2, radius * 2, PI, 0, OPEN);
    radius -= arcWidth;
  }
}

function Stars() {
  fill(255);
  noStroke();
  for (let i = 0; i < 100; i++) {
    let x = random(width);
    let y = random(height);
    ellipse(x, y, 2, 2);
  }
}

function drawBitcoinLogo3(x, y, size) {
  noStroke();
  fill('#f7931a');
  ellipse(x, y, size, size);

  fill(255);
  textSize(size * 0.6);
  textAlign(CENTER, CENTER);
  text('\u20BF', x, y);
}       
        window.addEventListener('load', setup);
    </script>
    <script id="preview" mint="MINT_INSCRIPTION_ID"></script>
</body>
</html>

#75,913,181text dmt-mint.magic#75,912,915tap bitcoinburgerday.20240918.16.element#75,912,914text

<!DOCTYPE html>
<html>
<head>
<script src="/content/b6a50f5ba932b0ea7f652d9d28e59eced47bc6f8376c25e02d8b3457bb60ac8fi0"></script>
<!-- artwork by @dmtbillythecats -->
<style>
body {
   margin: 0;
   padding: 0;
   display: flex;
   flex-direction: column;
   justify-content: flex-start;
   align-items: flex-start;
   height: 100%;
   background-color: #f0f0f0;
   overflow: auto;
}
#controls {
   width: 100%;
   background-color: rgba(255, 255, 255, 0.8);
   box-sizing: border-box;
   z-index: 10;
   position: absolute;
   top: 0;
}
#canvas-container {
   flex: 1;
   width: 100%;
   height: 100%;
   }
   canvas {
   display: block;
   }
</style>
</head>
<body>
<div id="controls">
<input id="blk" type="number" placeholder="Enter block number" style="display: none;" />
</div>
<div id="canvas-container"></div>
<script>
let canvas;
let blockNumber = 1;
let scaleFactor = 1;

const skyColors = [
    '#87ceeb', 
    '#00bfff', 
    '#1e90ff', 
    '#4682b4', 
    '#4169e1', 
    '#000000'  
];
const beetleColors = [
  '#008000', 
  '#0000FF', 
  '#FFFF00', 
  '#FFA500', 
  '#800080', 
  '#8B4513', 
  '#FF0000'  
]
function containsSequence(number, sequence) {
   return number.toString().includes(sequence);
}
function containsQuadruple(blockNumber) {
   return /(\d)\1{3}/.test(blockNumber);
}
function containsTripleSequence(num) {
   let numStr = num.toString();
   for (let i = 0; i <= 9; i++) {
   let sequence = i.toString().repeat(3);
   if (numStr.includes(sequence)) {
   return true;
   }
   }
   return false;
}
function m12(number) {
    return number % 12 === 0
}
function m11(number) {
    return number % 11 === 0
}  
function m13(number) {
    return number % 13 === 0
}  
function m14(number) {
    return number % 14 === 0
}  
function m15(number) {
    return number % 15 === 0
}  
function m16(number) {
    return number % 16 === 0
}  
function m10(number) {
    return number % 10 === 0
}  
function m9(number) {
    return number % 9 === 0
}  
function m8(number) {
    return number % 8 === 0
}
function m7(number) {
    return number % 7 === 0
}  
function m6(number) {
    return number % 6 === 0
}  
function m5(number) {
    return number % 5 === 0
}
 
function setup() {
   let canvasSize = min(windowWidth, windowHeight);
   canvas = createCanvas(canvasSize, canvasSize);
   canvas.parent('canvas-container');
   noLoop();
   generateColors();
   generateArt();
   document.getElementById('blk').value = blockNumber;
   document.getElementById('blk').addEventListener('input', updateArt);
   window.addEventListener('resize', resize, true);
   resize();

   let mintText = document.getElementById('preview').getAttribute('mint');
   if (mintText.includes('MINT_INSCRIPTION_ID')) {
   let input = document.getElementById('blk');
   input.style.display = 'block';
   input.style.position = 'absolute';
   input.style.fontSize = '10px';
   input.style.margin = '1px';
   input.style.top = '0';
   input.value = blockNumber;
   input.addEventListener('input', () => {
   blockNumber = parseInt(input.value) || 1;
   updateArt();
   });
   updateArt();
   } else {
   const request = new XMLHttpRequest();
   try {
   request.open('GET', '/content/' + mintText);
   request.responseType = 'text';
   request.addEventListener('load', () => initialize(request.response));
   request.addEventListener('error', () => console.error('XHR error'));
   request.send();
   } catch (error) {
   console.error(`XHR error ${error}`);
   }
}
}

function initialize(result) {
   if (result) {
   try {
   console.log('Result', result);
   const data = JSON.parse(result);
   blockNumber = data.blk;
   updateArt();
   } catch (error) {
   console.error('JSON parsing error', error);
   }
 }
}

 function updateArt() {
 generateColors();
 generateArt();
 }

 function resize() {
    let canvasSize = min(windowWidth, windowHeight);
    resizeCanvas(canvasSize, canvasSize);

    const root = document.getElementById('canvas-container');
    root.style.width = window.innerWidth - 300 + 'px';
    root.style.height = window.innerHeight + 'px';

    const orgWidth = 300;
    const orgHeight = 300;
    let scaleW = window.innerWidth / orgWidth;
    let scaleH = window.innerHeight / orgHeight;
    let offsetX = 0;
    let offsetY = 0;

    if (scaleH < scaleW) {
    scaleW = scaleH;
    offsetX = (window.innerWidth - orgWidth * scaleW) / 2;
    } else {
    scaleH = scaleW;
    offsetY = (window.innerHeight - orgHeight * scaleH) / 2;
    }

    canvas.style.zoom = scaleW;
    scaleFactor = Math.min(width / 1000, height / 1000);
    redraw();
    updateArt();
}

function generateColors() {
let colorIndex = (blockNumber - 1) % skyColors.length;
return skyColors[colorIndex];
}

function generateArt() {
    clear(); 
    let skyColor = generateColors();
    let grassColor = color(34, 139, 34); 
    background(skyColor); 
    Hills();
    Fence();
    if (blockNumber % 2 === 0) { //even
        Stars();
        Moon();
        Tree(width * 0.2, height * 0.55, 'oak', 1);
        Tree(width * 0.6, height * 0.55, 'maple', 1);
    }
    else {
        Sun();
        Cloud(width * 0.28, height * 0.22, width * 0.1); 
        Cloud(width * 0.6, height * 0.21, width * 0.08); 
        Cloud(width * 0.91, height * 0.09, width * 0.1); 
        Tree(width * 0.2, height * 0.55, 'pine', 1);
        Tree(width * 0.6, height * 0.55, 'birch', 1);
    }
  
    if (blockNumber.toString().includes('21')) {
    Rainbow();
    }
    if (blockNumber.toString().includes('99')) 
    Aurora(width * 0.8, height * 0.3, width * 0.25); 
    if (containsSequence(blockNumber, '88'))  
    Rain();  
    if (containsSequence(blockNumber, '77'))  
    Snow(); 
    if (containsSequence(blockNumber, '66'))  
    Lightning();
    if (m11(blockNumber))
    RLilies();
    if (m12(blockNumber))
    RDaisy();
    if (m13(blockNumber))
    RSunF();
    if (m14(blockNumber))
    RTulip();
    if (m15(blockNumber))
    ROrchid();
    if (m16(blockNumber))
    RPoppy();
    if (m10(blockNumber))
    RCherry();
    if (m9(blockNumber))
    RLupine();
    if (m8(blockNumber))
    RDandelion();
    if (m7(blockNumber))
    RMarigold();
    if (m6(blockNumber))
    RBluebell();
    if (m5(blockNumber))
    RRose();
  
    if (blockNumber.toString().includes('42')) {
        let shuffledColors = shuffle(beetleColors);
        for (let i = 0; i < 5; i++) {
            let x = random(width);
            let y = random(height / 2, height);  
            let color = shuffledColors[i % shuffledColors.length];
            Beetle(x, y, color);
        }
    }

  for (let i = 0; i < 5; i++) {
    let x = random(width);        
    let y = random(height * 0.5, height * 0.9); 
    Butterfly(x, y);
  }
    
    let bottomHeight = height * 0.3;
    let flowerYMin = height - bottomHeight;
    let flowerCount = (blockNumber % 10) + 600; 
    for (let i = 0; i < flowerCount; i++) {        
        let x = random(width);
        let y = random(flowerYMin, height);
        let size = random(30, 100) * scaleFactor;
        let flowerType = floor(random(12));       
        if (y >= flowerYMin) {
            if (flowerType === 0) {
                DaisyF(x, y, size);
            } else if (flowerType === 1) {
                RoseF(x, y, size);
            } else if (flowerType === 2) {
                SunF(x, y, size);
            } else if (flowerType === 3) {
                TulipF(x, y, size);
            } else if (flowerType === 4) {
                LilyF(x, y, size);
            } else if (flowerType === 5) {
                OrchidF(x, y, size);
            } else if (flowerType === 6) {
                PoppyF(x, y, size);
            } else if (flowerType === 7) {
                CherryF(x, y, size); 
            } else if (flowerType === 8) {
                LupineF(x, y, size); 
            } else if (flowerType === 9) {
                Dandelion(x, y, size); 
            } else if (flowerType === 10) {
                Marigold(x, y, size); 
            } else {
                Bluebell(x, y, size); 
            }
        }
    }
}

function RRose() {
    let roseCount = max(width, height) / 60; 
    for (let i = 0; i < roseCount; i++) {
        let x = random(width);
        let y = random(height);
        let size = min(width, height) * random(0.015, 0.03); 
        RoseF(x, y, size);
    }
}
function RBluebell() {
    let bluebellCount = max(width, height) / 50; 
    for (let i = 0; i < bluebellCount; i++) {
        let x = random(width);
        let y = random(height);
        let size = min(width, height) * random(0.02, 0.05);
        Bluebell(x, y, size);
    }
}
function RMarigold() {
    let marigoldCount = max(width, height) / 50; 
    for (let i = 0; i < marigoldCount; i++) {
        let x = random(width);
        let y = random(height);
        let size = min(width, height) * random(0.02, 0.05);
        Marigold(x, y, size);
    }
}
function RDandelion() {
    let dandelionCount = max(width, height) / 50; 
    for (let i = 0; i < dandelionCount; i++) {
        let x = random(width);
        let y = random(height);
        let size = min(width, height) * random(0.02, 0.05);
        Dandelion(x, y, size);
    }
}
function RLupine() {
    let lupineCount = max(width, height) / 50; 
    for (let i = 0; i < lupineCount; i++) {
        let x = random(width);
        let y = random(height);
        let size = min(width, height) * random(0.02, 0.05);
        LupineF(x, y, size);
    }
}
function RCherry() {
    let cherryCount = max(width, height) / 50; 
    for (let i = 0; i < cherryCount; i++) {
        let x = random(width);
        let y = random(height);
        let size = min(width, height) * random(0.02, 0.05);
        CherryF(x, y, size);
    }
}
function ROrchid() {
    let orchidCount = max(width, height) / 50; 
    for (let i = 0; i < orchidCount; i++) {
        let x = random(width);
        let y = random(height);
        let size = min(width, height) * random(0.02, 0.05);
        OrchidF(x, y, size);
    }
}
function RPoppy() {
    let poppyCount = max(width, height) / 50; 
    for (let i = 0; i < poppyCount; i++) {
        let x = random(width);
        let y = random(height);
        let size = min(width, height) * random(0.02, 0.05);
        PoppyF(x, y, size);
    }
}
function RTulip() {
    let tulipCount = max(width, height) / 50; 
    for (let i = 0; i < tulipCount; i++) {
        let x = random(width);
        let y = random(height);
        let size = min(width, height) * random(0.02, 0.05);
        TulipF(x, y, size);
    }
}
function RSunF() {
    let sunfCount = max(width, height) / 50; 
    for (let i = 0; i < sunfCount; i++) {
        let x = random(width);
        let y = random(height);
        let size = min(width, height) * random(0.02, 0.05);
        SunF(x, y, size);
    }
}
function RDaisy() {
    let daisyCount = max(width, height) / 50; 
    for (let i = 0; i < daisyCount; i++) {
        let x = random(width);
        let y = random(height);
        let size = min(width, height) * random(0.02, 0.05);
        DaisyF(x, y, size);
    }
}
function RLilies() {
    let lilyCount = max(width, height) / 50; 
    for (let i = 0; i < lilyCount; i++) {
        let x = random(width);
        let y = random(height);
        let size = min(width, height) * random(0.02, 0.05);
        LilyF(x, y, size);
    }
}
function Butterfly(x, y) {
    noStroke();
    let wingWidthUpper = width * 0.0135;
    let wingHeightUpper = height * 0.0216;
    let wingWidthLower = width * 0.0126;
    let wingHeightLower = height * 0.0190;
    let bodyWidth = width * 0.0054;
    let bodyHeight = height * 0.027;
    let spotWidthUpper = width * 0.00675;
    let spotHeightUpper = height * 0.0108;
    let spotWidthLower = width * 0.0054;
    let spotHeightLower = height * 0.0081;
    let antennaLength = height * 0.0108;

    fill(255, 255, 224);
    ellipse(x - wingWidthUpper * 0.4, y - wingHeightUpper * 0.4, wingWidthUpper, wingHeightUpper);
    ellipse(x + wingWidthUpper * 0.4, y - wingHeightUpper * 0.4, wingWidthUpper, wingHeightUpper);

    fill(255, 223, 186);
    ellipse(x - wingWidthLower * 0.4, y + wingHeightLower * 0.4, wingWidthLower, wingHeightLower);
    ellipse(x + wingWidthLower * 0.4, y + wingHeightLower * 0.4, wingWidthLower, wingHeightLower);

    fill(255, 140, 0);
    ellipse(x - wingWidthUpper * 0.4, y - wingHeightUpper * 0.4, spotWidthUpper, spotHeightUpper);
    ellipse(x + wingWidthUpper * 0.4, y - wingHeightUpper * 0.4, spotWidthUpper, spotHeightUpper);

    fill(255, 0, 0);
    ellipse(x - wingWidthLower * 0.4, y + wingHeightLower * 0.4, spotWidthLower, spotHeightLower);
    ellipse(x + wingWidthLower * 0.4, y + wingHeightLower * 0.4, spotWidthLower, spotHeightLower);

    fill(0, 100, 0);
    rect(x - bodyWidth * 0.4, y - bodyHeight * 0.4, bodyWidth, bodyHeight);

    stroke(0, 100, 0);
    strokeWeight(0.55);
    line(x - bodyWidth * 0.5, y - bodyHeight * 0.45, x - bodyWidth * 1, y - bodyHeight * 1);
    line(x + bodyWidth * 0.5, y - bodyHeight * 0.45, x + bodyWidth * 1, y - bodyHeight * 1);
    noStroke();

    fill(255, 255, 255);
    ellipse(x - wingWidthUpper * 0.23, y - wingHeightUpper * 0.23, spotWidthUpper * 0.4, spotHeightUpper * 0.4);
    ellipse(x + wingWidthUpper * 0.23, y - wingHeightUpper * 0.23, spotWidthUpper * 0.4, spotHeightUpper * 0.4);

    fill(255, 182, 193);
    ellipse(x - wingWidthLower * 0.23, y + wingHeightLower * 0.23, spotWidthLower * 0.4, spotHeightLower * 0.4);
    ellipse(x + wingWidthLower * 0.23, y + wingHeightLower * 0.23, spotWidthLower * 0.4, spotHeightLower * 0.4);
}
function Butterflies() {
    for (let i = 0; i < 5; i++) {
        let x = random(width);
        let y = random(height);
        Butterfly(x, y);
    }
}
function Beetle(x, y, color) {
  noStroke(); 
  const canvasWidth = width;
  const canvasHeight = height;
  const scaleFactor = 0.6; 
  const bodyWidth = canvasWidth * 0.06 * scaleFactor;  
  const bodyHeight = canvasHeight * 0.05 * scaleFactor; 
  const headWidth = bodyWidth * 0.5;   
  const headHeight = bodyHeight * 0.38; 
  const spotSize = bodyWidth * 0.15;   
  fill(color); 
  ellipse(x, y, bodyWidth, bodyHeight);   
  fill('#000000'); 
  ellipse(x - bodyWidth * 0.25, y - bodyHeight * 0.15, spotSize, spotSize); 
  ellipse(x + bodyWidth * 0.17, y - bodyHeight * 0.15, spotSize, spotSize); 
  ellipse(x - bodyWidth * 0.17, y + bodyHeight * 0.1, spotSize, spotSize); 
  ellipse(x + bodyWidth * 0.25, y + bodyHeight * 0.1, spotSize, spotSize); 
  fill(0, 0, 0); 
  ellipse(x, y - bodyHeight * 0.45, headWidth, headHeight); 
  fill(0, 0, 0);  
  beginShape();
  vertex(x - bodyWidth * 0.42, y + bodyHeight * 0.25);
  vertex(x - bodyWidth * 0.58, y + bodyHeight * 0.35);
  vertex(x - bodyWidth * 0.17, y + bodyHeight * 0.3);
  endShape(CLOSE);
  beginShape();
  vertex(x + bodyWidth * 0.42, y + bodyHeight * 0.25);
  vertex(x + bodyWidth * 0.58, y + bodyHeight * 0.35);
  vertex(x + bodyWidth * 0.17, y + bodyHeight * 0.3);
  endShape(CLOSE);
  beginShape();
  vertex(x - bodyWidth * 0.42, y - bodyHeight * 0.2);
  vertex(x - bodyWidth * 0.58, y - bodyHeight * 0.3);
  vertex(x - bodyWidth * 0.17, y - bodyHeight * 0.25);
  endShape(CLOSE);
  beginShape();
  vertex(x + bodyWidth * 0.42, y - bodyHeight * 0.2);
  vertex(x + bodyWidth * 0.58, y - bodyHeight * 0.3);
  vertex(x + bodyWidth * 0.17, y - bodyHeight * 0.25);
  endShape(CLOSE);
  stroke(0); 
  strokeWeight(width * 0.01 * scaleFactor); 
  noFill();
  line(x - bodyWidth * 0.1, y - bodyHeight * 0.45, x - bodyWidth * 0.15, y - bodyHeight * 0.6);
  line(x - bodyWidth * 0.15, y - bodyHeight * 0.6, x - bodyWidth * 0.1, y - bodyHeight * 0.65);   
  line(x + bodyWidth * 0.1, y - bodyHeight * 0.45, x + bodyWidth * 0.15, y - bodyHeight * 0.6);
  line(x + bodyWidth * 0.15, y - bodyHeight * 0.6, x + bodyWidth * 0.1, y - bodyHeight * 0.65); 
}
function Cloud(x, y, size) {
noStroke();
fill(255);
ellipse(x, y, size, size * 0.45);
ellipse(x - size * 0.4, y, size * 0.8, size * 0.6);
ellipse(x + size * 0.4, y, size * 0.8, size * 0.6);
ellipse(x - size * 0.2, y - size * 0.4, size * 0.7, size * 0.5);
ellipse(x + size * 0.2, y - size * 0.4, size * 0.7, size * 0.5);
}  
function Lightning() {
    let x1 = random(width * 0.1, width * 0.3);
    let y1 = random(height * 0.1, height * 0.3);
    let x2 = random(width * 0.7, width * 0.9);
    let y2 = random(height * 0.7, height * 0.9);
    let boltWidth = random(width * 0.005, width * 0.015);    
    drawingContext.shadowBlur = boltWidth * 2;
    drawingContext.shadowColor = color(255, 255, 200, 150);    
    stroke(255, 255, 200);
    strokeWeight(boltWidth);
    noFill();
    drawBolt(x1, y1, x2, y2, 0);   
    let numBranches = random(2, 5);
    for (let i = 0; i < numBranches; i++) {
        let branchStart = random(0.3, 0.7);
        let bx1 = lerp(x1, x2, branchStart);
        let by1 = lerp(y1, y2, branchStart);
        let bx2 = bx1 + random(-width * 0.2, width * 0.2);
        let by2 = by1 + random(height * 0.1, height * 0.3);
        strokeWeight(boltWidth * 0.6);
        drawBolt(bx1, by1, bx2, by2, 1);
    }    
    drawingContext.shadowBlur = 0;
}
function drawBolt(x1, y1, x2, y2, branchLevel) {
    beginShape();
    vertex(x1, y1);
    let numSteps = int(random(5, 15));
    let prevX = x1;
    let prevY = y1;
    for (let i = 1; i <= numSteps; i++) {
        let x = lerp(x1, x2, i / numSteps);
        let y = lerp(y1, y2, i / numSteps);
        let offsetX = random(-width * 0.03, width * 0.03) * (1 - i / numSteps);
        let offsetY = random(-height * 0.03, height * 0.03) * (1 - i / numSteps);
        x += offsetX;
        y += offsetY;        
        if (i > 1 && i < numSteps) {
            let midX = (prevX + x) / 2 + random(-width * 0.01, width * 0.01);
            let midY = (prevY + y) / 2 + random(-height * 0.01, height * 0.01);
            vertex(midX, midY);
        }        
        vertex(x, y);
        prevX = x;
        prevY = y;        
        if (branchLevel === 0 && random() < 0.2) {
            let bx2 = x + random(-width * 0.1, width * 0.1);
            let by2 = y + random(height * 0.05, height * 0.15);
            push();
            strokeWeight(strokeWeight() * 0.5);
            drawBolt(x, y, bx2, by2, branchLevel + 1);
            pop();
        }
    }
    endShape();
}
function Snow() {
  noStroke(); 
  fill(255);   
 
  let numSnowflakes = 200; 
  for (let i = 0; i < numSnowflakes; i++) {
    let x = random(width); 
    let y = random(height); 
    let size = random(2, 6); 
    ellipse(x, y, size, size); 
  }
}
function Rain() {
  noStroke();   
  fill(173, 216, 230); 
 
  let numRaindrops = 200; 
  for (let i = 0; i < numRaindrops; i++) {
    let x = random(width); 
    let y = random(height); 
    let length = random(10, 15); 
    rect(x, y, 1.2, length); 
  }
}
function Aurora(x, y, radius) {
    noStroke();
    let auroraColors = [
        color(0, 255, 0, 100),
        color(0, 255, 255, 100),
        color(255, 0, 255, 100),
        color(255, 255, 0, 100),
        color(255, 69, 0, 100),
        color(255, 105, 180, 100),
        color(135, 206, 250, 100),
        color(123, 104, 238, 100)
    ];
    drawingContext.filter = 'blur(1px)';
    for (let i = auroraColors.length - 1; i >= 0; i--) {
        let gradientRadius = radius * (i + 1) * 0.5;
        let gradientOpacity = map(i, 0, auroraColors.length - 1, 100, 50);
        fill(auroraColors[i].levels[0], auroraColors[i].levels[1], auroraColors[i].levels[2], gradientOpacity);
        ellipse(x, y, gradientRadius, gradientRadius * 0.6);
    }
    drawingContext.filter = 'none';
}
function Rainbow() {
  noStroke();
  let colors = [
    color(148, 0, 211),
    color(75, 0, 130),
    color(0, 0, 255),
    color(0, 255, 0),
    color(255, 255, 0),
    color(255, 127, 0),
    color(255, 0, 0)
  ];
  let startX = width / 2;
  let startY = height * 1.05;
  let radius = Math.min(width, height);
  let arcWidth = radius * 0.01;
  for (let i = 0; i < colors.length; i++) {
    stroke(colors[i]);
    strokeWeight(arcWidth);
    noFill();
    arc(startX, startY, radius * 1.8, radius * 2, PI, 0, OPEN);
    radius -= arcWidth;
  }
}
function Sun() {
    let x = width * 0.06;
    let y = height * 0.06;
    let diameter = width * 0.06;
    let sunColor = color(255, 223, 0);
    let rayColor = color(255, 204, 0, 150);
    let glowColor = color(255, 150, 0, 50);  
    noStroke();
    for (let i = 5; i > 0; i--) {
        fill(glowColor.levels[0], glowColor.levels[1], glowColor.levels[2], map(i, 0, 5, 0, 50));
        ellipse(x, y, diameter + i * 15);
    }   
    fill(sunColor);
    ellipse(x, y, diameter);    
    for (let i = 0; i < 20; i++) {
        let r = random(diameter / 2);
        let angle = random(TWO_PI);
        fill(255, 255, 200, random(100, 150));
        ellipse(x + r * cos(angle), y + r * sin(angle), random(2, 5));
    }   
    let numRays = 12;
    for (let i = 0; i < numRays; i++) {
        let angle = TWO_PI / numRays * i + frameCount * 0.01; 
        let rayLength = diameter * random(0.5, 0.7);
        let x1 = x + cos(angle) * (diameter / 2);
        let y1 = y + sin(angle) * (diameter / 2);
        let x2 = x + cos(angle) * (diameter / 2 + rayLength);
        let y2 = y + sin(angle) * (diameter / 2 + rayLength);       
        push();
        translate(x, y);
        rotate(angle);
        noFill();
        stroke(rayColor);
        strokeWeight(diameter * 0.03);
        beginShape();
        for (let j = diameter / 2; j < diameter / 2 + rayLength; j += 5) {
            let xoff = sin(j * 0.1 + frameCount * 0.1) * 5;
            vertex(j, xoff);
        }
        endShape();
        pop();
    }    
    let centerGlow = drawingContext.createRadialGradient(x, y, 0, x, y, diameter / 2);
    centerGlow.addColorStop(0, 'rgba(255, 255, 255, 0.5)');
    centerGlow.addColorStop(1, 'rgba(255, 255, 255, 0)');
    drawingContext.fillStyle = centerGlow;
    ellipse(x, y, diameter);
}
function Moon() {
    let x = width * 0.06;
    let y = height * 0.06;
    let diameter = width * 0.06;
    let moonColor = color(255, 255, 220); 
    let glowColor = color(255, 255, 180, 50); 
    let shadowColor = color(180, 180, 200);    
    for (let i = 5; i > 0; i--) {
        let alpha = map(i, 0, 5, 0, 50);
        fill(glowColor.levels[0], glowColor.levels[1], glowColor.levels[2], alpha);
        ellipse(x, y, diameter + i * 10);
    }   
    fill(moonColor);
    noStroke();
    ellipse(x, y, diameter);   
    fill(shadowColor);
    ellipse(x + diameter * 0.1, y - diameter * 0.1, diameter * 0.7);
    ellipse(x - diameter * 0.25, y + diameter * 0.2, diameter * 0.3);
    ellipse(x + diameter * 0.3, y + diameter * 0.25, diameter * 0.2);    
    fill(255);
    ellipse(x - diameter * 0.1, y - diameter * 0.1, diameter * 0.1);
    ellipse(x + diameter * 0.2, y + diameter * 0.2, diameter * 0.05);    
    for (let i = 0; i < 20; i++) {
        let rx = random(-diameter/2, diameter/2);
        let ry = random(-diameter/2, diameter/2);
        if (rx*rx + ry*ry < (diameter/2)*(diameter/2)) {
            fill(random(200, 255), random(200, 255), random(180, 220), random(20, 50));
            ellipse(x + rx, y + ry, random(1, 3));
        }
    }
}
function Stars() {
   fill(255);
   noStroke();
   const skyHeight = height * 0.5;
   const starCount = Math.floor(width * height * 0.0001);
   const starSize = width * 0.002;
   for (let i = 0; i < starCount; i++) {
      let x = random(width);
      let y = random(skyHeight);
      ellipse(x, y, starSize, starSize);
   }
}
function Fence() {
    let fenceHeight = height * 0.16; 
    let postWidth = width * 0.02;   
    let postSpacing = width * 0.06;    
    stroke(139, 69, 19); 
    strokeWeight(5);
    line(0, height * 0.8, width, height * 0.8);  
    for (let x = 0; x <= width; x += postSpacing) {   
        fill(139, 69, 19);
        noStroke();
        rect(x, height * 0.8 - fenceHeight, postWidth, fenceHeight);        
        fill(139, 69, 19); 
        noStroke();
        let railHeight = fenceHeight * 0.5;
        rect(x - postWidth * 0.5, height * 0.8 - railHeight * 1.5, postWidth * 2, railHeight);
        rect(x - postWidth * 0.5, height * 0.8 - railHeight, postWidth * 2, railHeight); 
    }
}
function Tree(x, y, treeType) {
    noStroke(); 
    const trunkWidth = width * 0.02;
    const trunkHeight = height * 0.1;
    const foliageSize = width * 0.1;
    const trunkX = x - trunkWidth / 2;
    const trunkY = y - trunkHeight;
    const foliageY = trunkY - foliageSize / 2;    

    Trunk(trunkX, trunkY, trunkWidth, trunkHeight);
    switch (treeType) {
        case 'oak':
            OakFoliage(x, foliageY, foliageSize);
            break;
        case 'pine':
            PineFoliage(x, trunkY, foliageSize);
            break;
        case 'maple':
            MapleFoliage(x, foliageY, foliageSize);
            break;
        case 'birch':
            BirchTree(trunkX, trunkY, trunkWidth, trunkHeight, foliageSize);
            break;
        default:
            console.warn(`Unknown tree type: ${treeType}`);
    }
}
function Trunk(x, y, width, height) {
    noStroke();
    fill(101, 67, 33); 
    rect(x, y, width, height);
    for (let i = 0; i < 10; i++) {
        fill(81, 47, 13, 100); 
        let barkX = x + random(width);
        let barkY = y + random(height);
        let barkW = random(1, width / 2);
        let barkH = random(3, height / 4);
        rect(barkX, barkY, barkW, barkH, 1);
    }
}
function OakFoliage(x, y, size) {
    let leafColor = color(34, 139, 34); 
    let shadowColor = color(25, 100, 25);    
    for (let i = 0; i < 3; i++) {
        let s = size - i * (size / 8);
        fill(shadowColor);
        ellipse(x + size/20, y + size/20, s, s * 0.9);
        fill(leafColor);
        ellipse(x, y, s, s * 0.9);
    }
    for (let i = 0; i < 15; i++) {
        push();
        translate(x + random(-size/2, size/2), y + random(-size/2, size/2));
        rotate(random(TWO_PI));
        fill(leafColor);
        beginShape();
        vertex(0, -5);
        bezierVertex(2, -2, 5, 0, 0, 5);
        bezierVertex(-5, 0, -2, -2, 0, -5);
        endShape(CLOSE);
        pop();
    }
}
function PineFoliage(x, y, size) {
    let green = color(0, 100, 0);
    let darkGreen = color(0, 70, 0);    
    for (let i = 0; i < 5; i++) {
        let triangleHeight = size * (1 - i * 0.15);
        let triangleWidth = size * (1 - i * 0.1);
        fill(lerpColor(green, darkGreen, i / 5));
        triangle(
            x - triangleWidth / 2, y - i * size / 5,
            x + triangleWidth / 2, y - i * size / 5,
            x, y - triangleHeight - i * size / 5
        );
    }   
    fill(255, 255, 255, 150);
    arc(x, y - size, size * 0.8, size * 0.2, PI, TWO_PI);
}

function MapleFoliage(x, y, size) {
    let colors = [
        color(255, 0, 0),    
        color(255, 69, 0),   
        color(255, 165, 0),  
        color(255, 215, 0)   
    ];    
    for (let i = 0; i < 5; i++) {
        fill(random(colors));
        MapleLeaf(x + random(-size/4, size/4), (y + 10) + random(-size/4, size/4), size * 0.7);
    }
}
function MapleLeaf(x, y, size) {
    push();
    translate(x, y);
    rotate(random(TWO_PI));
    scale(size / 75);    
    beginShape();
    vertex(0, -50);
    bezierVertex(25, -45, 40, -20, 50, 0);
    bezierVertex(50, 20, 30, 40, 20, 50);
    bezierVertex(10, 40, 0, 45, 0, 50);
    bezierVertex(0, 45, -10, 40, -20, 50);
    bezierVertex(-30, 40, -50, 20, -50, 0);
    bezierVertex(-40, -20, -25, -45, 0, -50);
    endShape(CLOSE);   
    stroke(139, 69, 19, 100);
    line(0, -50, 0, 50);
    line(0, 0, 50, 0);
    line(0, 0, -50, 0);
    line(0, 0, 35, 35);
    line(0, 0, -35, 35);
    pop();
}
function BirchTree(x, y, width, height, foliageSize) {
    fill(245, 245, 245);
    rect(x, y, width, height);    
    for (let i = 0; i < 8; i++) {
        fill(0);
        let markX = x + random(width);
        let markY = y + random(height);
        let markW = random(1, 3);
        let markH = random(5, 15);
        rect(markX, markY, markW, markH);
    }  
    let leafColor = color(144, 238, 144);
    for (let i = 0; i < 3; i++) {
        fill(leafColor);
        ellipse(x + width/2, y - height/4 - i * foliageSize/4, foliageSize - i * foliageSize/4, foliageSize - i * foliageSize/4);
    }
}
function Hills() {
    fill(34, 139, 34); 
    noStroke();
    beginShape();
    vertex(0, height * 0.6);
    bezierVertex(width * 0.25, height * 0.5, width * 0.75, height * 0.5, width, height * 0.6);
    vertex(width, height);
    vertex(0, height);
    endShape(CLOSE);
}
function CherryF(x, y, size) {
    let petalCount = 5;
    let petalLength = size * 0.4;
    let petalWidth = size * 0.2;
    noStroke();   
    fill(255, 182, 193);
    for (let i = 0; i < petalCount; i++) {
        let angle = TWO_PI / petalCount * i;
        push();
        translate(x, y);
        rotate(angle);
        beginShape();
        vertex(0, 0);
        bezierVertex(petalLength * 0.2, -petalWidth * 0.5,
                      petalLength * 0.6, -petalWidth * 0.5,
                      petalLength, 0);
        bezierVertex(petalLength * 0.6, petalWidth * 0.5,
                      petalLength * 0.2, petalWidth * 0.5,
                      0, 0);
        endShape(CLOSE);
        pop();
    }   
    fill(255, 255, 255); // White color
    ellipse(x, y, size * 0.3, size * 0.3);
}
function LupineF(x, y, size) {
    let petalCount = 10;
    let petalLength = size * 0.4;
    let petalWidth = size * 0.1;
    noStroke();    
    fill(100, 149, 237); 
    for (let i = 0; i < petalCount; i++) {
        let angle = TWO_PI / petalCount * i;
        push();
        translate(x, y);
        rotate(angle);
        beginShape();
        vertex(0, 0);
        bezierVertex(petalLength * 0.2, -petalWidth * 0.7,
                      petalLength * 0.4, -petalWidth * 0.7,
                      petalLength, 0);
        bezierVertex(petalLength * 0.4, petalWidth * 0.7,
                      petalLength * 0.2, petalWidth * 0.7,
                      0, 0);
        endShape(CLOSE);
        pop();
    }    
    fill(255, 255, 255); // White color
    ellipse(x, y, size * 0.3, size * 0.3);
}
function Dandelion(x, y, size) {
    let petalCount = 20;
    let petalLength = size * 0.3;
    let petalWidth = size * 0.1;
    noStroke(); 
    fill(255, 255, 0); 
    for (let i = 0; i < petalCount; i++) {
        let angle = TWO_PI / petalCount * i;
        push();
        translate(x, y);
        rotate(angle);
        ellipse(petalLength / 2, 0, petalLength, petalWidth);
        pop();
    }    
    fill(255, 215, 0); 
    ellipse(x, y, size * 0.2, size * 0.2);
}
function Marigold(x, y, size) {
    let petalCount = 12;
    let petalLength = size * 0.5;
    let petalWidth = size * 0.2;
    noStroke();
    fill(255, 165, 0); 
    for (let i = 0; i < petalCount; i++) {
        let angle = TWO_PI / petalCount * i;
        push();
        translate(x, y);
        rotate(angle);
        beginShape();
        vertex(0, 0);
        bezierVertex(petalLength * 0.3, -petalWidth * 0.5,
                      petalLength * 0.7, -petalWidth * 0.5,
                      petalLength, 0);
        bezierVertex(petalLength * 0.7, petalWidth * 0.5,
                      petalLength * 0.3, petalWidth * 0.5,
                      0, 0);
        endShape(CLOSE);
        pop();
    }
    fill(255, 215, 0); 
    ellipse(x, y, size * 0.3, size * 0.3);
}
function Bluebell(x, y, size) {
    let petalCount = 6;
    let petalLength = size * 0.4;
    let petalWidth = size * 0.2;
    noStroke();
    fill(0, 0, 255); 
    for (let i = 0; i < petalCount; i++) {
        let angle = TWO_PI / petalCount * i;
        push();
        translate(x, y);
        rotate(angle);
        beginShape();
        vertex(0, 0);
        bezierVertex(petalLength * 0.2, -petalWidth * 0.5,
                      petalLength * 0.5, -petalWidth * 0.5,
                      petalLength, 0);
        bezierVertex(petalLength * 0.5, petalWidth * 0.5,
                      petalLength * 0.2, petalWidth * 0.5,
                      0, 0);
        endShape(CLOSE);
        pop();
    }    
    fill(255, 255, 255); 
    ellipse(x, y, size * 0.2, size * 0.2);
}    
function PoppyF(x, y, size) {
    let petalCount = 6;
    let petalLength = size * 0.4;
    let petalWidth = size * 0.2;
    noStroke();
    fill(255, 0, 0); 
    for (let i = 0; i < petalCount; i++) {
        let angle = TWO_PI / petalCount * i;
        push();
        translate(x, y);
        rotate(angle);
        beginShape();
        vertex(0, 0);
        bezierVertex(petalLength * 0.3, -petalWidth * 0.7,
                      petalLength * 0.6, -petalWidth * 0.7,
                      petalLength, 0);
        bezierVertex(petalLength * 0.6, petalWidth * 0.7,
                      petalLength * 0.3, petalWidth * 0.7,
                      0, 0);
        endShape(CLOSE);
        pop();
    }
    fill(0, 0, 0); 
    ellipse(x, y, size * 0.3, size * 0.3);
}
function OrchidF(x, y, size) {
    let petalCount = 5;
    let petalLength = size * 0.5;
    let petalWidth = size * 0.3;
    noStroke();
    fill(238, 130, 238); 
    for (let i = 0; i < petalCount; i++) {
        let angle = TWO_PI / petalCount * i;
        push();
        translate(x, y);
        rotate(angle);
        beginShape();
        vertex(0, 0);
        bezierVertex(petalLength * 0.2, -petalWidth * 0.6,
                      petalLength * 0.5, -petalWidth * 0.5,
                      petalLength, 0);
        bezierVertex(petalLength * 0.5, petalWidth * 0.5,
                      petalLength * 0.2, petalWidth * 0.6,
                      0, 0);
        endShape(CLOSE);
        pop();
    }
    fill(255, 250, 250); 
    ellipse(x, y, size * 0.3, size * 0.3);
}  
function LilyF(x, y, size) {
    let petalCount = 6;
    let petalLength = size * 0.5;
    let petalWidth = size * 0.2;
    noStroke();  
    fill(255, 182, 193); 
    for (let i = 0; i < petalCount; i++) {
        let angle = TWO_PI / petalCount * i;
        push();
        translate(x, y);
        rotate(angle);
        beginShape();
        vertex(0, 0);
        bezierVertex(petalLength * 0.3, -petalWidth * 0.7,
                      petalLength * 0.6, -petalWidth * 0.7,
                      petalLength, 0);
        bezierVertex(petalLength * 0.6, petalWidth * 0.7,
                      petalLength * 0.3, petalWidth * 0.7,
                      0, 0);
        endShape(CLOSE);
        pop();
    }
    fill(255, 255, 0); 
    ellipse(x, y, size * 0.3, size * 0.3);
}  
function TulipF(x, y, size) {
    let petalCount = 6;
    let petalLength = size * 0.6;
    let petalWidth = size * 0.3;
    noStroke();
    fill(255, 105, 180); 
    for (let i = 0; i < petalCount; i++) {
        let angle = TWO_PI / petalCount * i;
        push();
        translate(x, y);
        rotate(angle);
        beginShape();
        vertex(0, 0);
        bezierVertex(petalLength * 0.2, -petalWidth * 0.5, 
                      petalLength * 0.6, -petalWidth * 0.6, 
                      petalLength, 0);
        bezierVertex(petalLength * 0.6, petalWidth * 0.6, 
                      petalLength * 0.2, petalWidth * 0.5, 
                      0, 0);
        endShape(CLOSE);
        pop();
    }
    fill(255, 255, 0); 
    ellipse(x, y, size * 0.3, size * 0.3);
}
function DaisyF(x, y, size) {
    let numPetals = 12;
    let petalLength = size * 0.4;
    let petalWidth = size * 0.15;
    noStroke();
    fill(255);
    for (let i = 0; i < numPetals; i++) {
        let angle = TWO_PI / numPetals * i;
        push();
        translate(x, y);
        rotate(angle);
        ellipse(petalLength / 2, 0, petalLength, petalWidth);
        pop();
    }
    fill(255, 220, 0);
    ellipse(x, y, size * 0.3, size * 0.3);
}
function RoseF(x, y, size) {
    size *= 0.75; 
    let numPetals = floor(map(size, 0, 75, 15, 30)); 
    let hue = random(340, 360);     
    push();
    translate(x, y);    
    noStroke();
    for (let i = 0; i < numPetals; i++) {
        let petalSize = map(i, 0, numPetals, size * 0.1, size);
        let angle = TWO_PI / numPetals * i;
        let petalX = cos(angle) * petalSize * 0.3;
        let petalY = sin(angle) * petalSize * 0.3;       
        let petalHue = hue + random(-10, 10);
        let petalSaturation = random(70, 100);
        let petalBrightness = random(50, 80);
        let petalAlpha = map(i, 0, numPetals, 150, 255);        
        fill(color(petalHue, petalSaturation, petalBrightness, petalAlpha));        
        push();
        translate(petalX, petalY);
        rotate(angle + PI / 2);        
        beginShape();
        vertex(0, 0);
        bezierVertex(petalSize * 0.3, -petalSize * 0.4, 
                     petalSize * 0.7, -petalSize * 0.5, 
                     petalSize, -petalSize * 0.3);
        bezierVertex(petalSize * 1.1, -petalSize * 0.1, 
                     petalSize * 1.1, petalSize * 0.1, 
                     petalSize, petalSize * 0.3);
        bezierVertex(petalSize * 0.7, petalSize * 0.5, 
                     petalSize * 0.3, petalSize * 0.4, 
                     0, 0);
        endShape(CLOSE);
        pop();
    }
    fill(hue - 20, 100, 30);
    ellipse(0, 0, size * 0.2, size * 0.2);    
    pop();
}
function SunF(x, y, size) {
    let numPetals = 24;
    let petalLength = size * 0.4;
    let petalWidth = size * 0.1;
    noStroke(); 
    fill(255, 200, 0);
    for (let i = 0; i < numPetals; i++) {
        let angle = TWO_PI / numPetals * i;
        push();
        translate(x, y);
        rotate(angle);
        ellipse(petalLength / 2, 0, petalLength, petalWidth);
        pop();
    }   
    fill(100, 70, 0);
    ellipse(x, y, size * 0.4, size * 0.4);    
    fill(60, 40, 0);
    for (let i = 0; i < 100; i++) {
        let angle = random(TWO_PI);
        let radius = random(size * 0.05, size * 0.18);
        let seedX = x + cos(angle) * radius;
        let seedY = y + sin(angle) * radius;
        ellipse(seedX, seedY, 3, 3);
    }
}
window.addEventListener('load', setup);
</script>
<script id="preview" mint="MINT_INSCRIPTION_ID"></script>
</body>
</html>