☰

Flowr QoL

A QoL script for Flowr!

  1. // ==UserScript==
  2. // @name         Flowr QoL
  3. // @namespace    http://tampermonkey.net/
  4. // @version      1.0.0
  5. // @description  A QoL script for Flowr!
  6. // @author       Suprinister
  7. // @match        https://flowr.fun/*
  8. // @icon         data:image/gif;base64,R0lGODlhAQABAAAAACH5BAEKAAEALAAAAAABAAEAAAICTAEAOw==
  9. // @license      Apache-2.0
  10. // @grant        none
  11. // ==/UserScript==
  12.  
  13. (function() {
  14.     'use strict';
  15.  
  16.     Colors.rarities[9] = {"name":"Fabled","color":"#ff5500","border":"#cf4500","fancy":{"border":"#cf4500","hue":10,"light":60,"sat":95,"spread":20,"period":1.5}};
  17.  
  18.     const ogColors = JSON.parse(JSON.stringify(Colors.rarities));
  19.  
  20.     let pressedG = false;
  21.  
  22.     window.addEventListener('keydown', event => {
  23.         if (event.code === 'KeyG') {
  24.             pressedG = true;
  25.         };
  26.     });
  27.  
  28.     window.addEventListener('keyup', event => {
  29.         if (event.code === 'KeyG') {
  30.             pressedG = false;
  31.         };
  32.     });
  33.  
  34.     let performanceMode = (localStorage.getItem('performanceMode') ?? 'false') === 'false' ? false : true;
  35.  
  36.     if (performanceMode) {
  37.         for (let i = 0; i < Colors.rarities.length; i++) {
  38.             delete Colors.rarities[i].fancy;
  39.         };
  40.  
  41.         blendAmount = function(p) {
  42.             return 0;
  43.         };
  44.     };
  45.  
  46.     for (let i = 7; i <= 12; i++) {
  47.         settingsMenu.options[i].screenPosition.y += 50;
  48.     };
  49.  
  50.     settingsMenu.options.splice(7, 0, {
  51.         changeTime: 0,
  52.         name: 'Performance mode',
  53.         screenPosition: {
  54.             x: 125,
  55.             y: 386,
  56.             w: 28,
  57.             h: 28
  58.         },
  59.         state: performanceMode,
  60.         toggleFn(state) {
  61.             performanceMode = state;
  62.             localStorage.setItem('performanceMode', state);
  63.  
  64.             if (state) {
  65.                 for (let i = 0; i < Colors.rarities.length; i++) {
  66.                     delete Colors.rarities[i].fancy;
  67.                 };
  68.  
  69.                 blendAmount = function(p) {
  70.                     return 0;
  71.                 };
  72.             } else {
  73.                 Colors.rarities = JSON.parse(JSON.stringify(ogColors));
  74.  
  75.                 blendAmount = function(p) {
  76.                     return Math.max(0, 1 - p.ticksSinceLastDamaged / 166.5);
  77.                 };
  78.             };
  79.         },
  80.         type: 'toggle'
  81.     });
  82.  
  83.     settingsMenu.h += 50;
  84.     settingsMenu.offset = -settingsMenu.h - 40;
  85.     settingsMenu.targetOffset = -settingsMenu.h - 40;
  86.  
  87.     Flower.prototype.draw = function() {
  88.         if(this.id !== window.selfId){
  89.             this.updateInterpolate();
  90.         }
  91.  
  92.         this.updatePetsAndProjectiles();
  93.  
  94.         for(let i = 0; i < this.deadProjectiles.length; i++){
  95.             if(toRender({x: this.deadProjectiles[i].render.x, y: this.deadProjectiles[i].render.y, radius: this.deadProjectiles[i].radius}, window.camera) === true){
  96.                 this.deadProjectiles[i].draw();
  97.             }
  98.             this.deadProjectiles[i].updateTimer();
  99.         }
  100.  
  101.         
  102.  
  103.         this.ticksSinceLastDamaged += dt;
  104.         if(this.ticksSinceLastDamaged > 666){
  105.             this.beforeStreakHp = this.hp;
  106.         }
  107.         
  108.         renderHpBar({
  109.             x: this.render.headX,
  110.             y: this.render.headY - this.render.radius / 3,
  111.             radius: this.render.radius,
  112.             hp: this.render.hp,
  113.             maxHp: this.maxHp,
  114.             shield: this.render.shield,
  115.             beforeStreakHp: this.render.beforeStreakHp,
  116.             flowerName: this.name,
  117.             flowerUsername: this.username
  118.         },this);
  119.  
  120.         if(this.petalAlpha !== undefined){
  121.             ctx.globalAlpha = this.petalAlpha;
  122.         }
  123.  
  124.         if (this.id == window.selfId){
  125.             petalReloadData = {};
  126.             petalHpData = {};
  127.         }
  128.         for(let i = 0; i < this.petals.length; i++){
  129.             let petal = this.petals[i];
  130.             if(toRender({x: petal.render.x, y: petal.render.y, radius: petal.radius}, window.camera) === true){
  131.                 if (!petal.dead && pressedG) {
  132.                     ctx.beginPath();
  133.  
  134.                     ctx.font = '900 12px Ubuntu';
  135.                     ctx.lineWidth = 5;
  136.                     ctx.globalAlpha = 1;
  137.                     ctx.fillStyle = Colors.rarities[petal.rarity].color;
  138.                     ctx.strokeStyle = 'black';
  139.                     ctx.strokeText(Colors.rarities[petal.rarity].name, petal.render.x, petal.render.y + petal.radius * 1.75 + 7);
  140.                     ctx.fillText(Colors.rarities[petal.rarity].name, petal.render.x, petal.render.y + petal.radius * 1.75 + 7);
  141.  
  142.                     ctx.globalAlpha = 0.5;
  143.                     ctx.arc(petal.render.x, petal.render.y, petal.radius * 1.75, 0, 2 * Math.PI);
  144.                     ctx.fill();
  145.  
  146.                     ctx.globalAlpha = 1;
  147.  
  148.                     ctx.closePath();
  149.                 };
  150.                 
  151.                 petal.draw();
  152.             }
  153.             if (this.id == window.selfId){
  154.                 let containerId = petal.petalContainerId;
  155.                 if (!petalReloadData[containerId]){
  156.                     if (petal.dead){
  157.                         petalReloadData[containerId] = {
  158.                             reload: petal.render.reload/petal.maxReload
  159.                         }
  160.                     }
  161.                 }
  162.                 else{
  163.                     if (petalReloadData[containerId].reload < petal.render.reload/petal.maxReload && petal.dead){
  164.                         petalReloadData[containerId].reload = petal.render.reload/petal.maxReload;
  165.                     }
  166.                 }
  167.  
  168.                 if (!petalHpData[containerId]){
  169.                     if (!petal.dead){
  170.                         petalHpData[containerId] = {
  171.                             hp: petal.render.hp/petal.maxHp,
  172.                             count: 1
  173.                         }
  174.                     }
  175.                 }
  176.                 else{
  177.                     if(!petal.dead){
  178.                         petalHpData[containerId].hp = (petalHpData[containerId].count * petalHpData[containerId].hp + petal.render.hp/petal.maxHp)/(petalHpData[containerId].count+1);
  179.                         petalHpData[containerId].count++;
  180.                     }
  181.                 }
  182.             }
  183.             petal.updateTimer();
  184.         }
  185.         ctx.globalAlpha = 1;
  186.         
  187.         if(toRender({x: this.render.headX, y: this.render.headY, radius: this.render.radius}, window.camera) === true){
  188.             this.drawFlower(this.render.headX, this.render.headY, this.radius);
  189.         }
  190.         if (this.lightnings){
  191.             if (this.lightnings.length > 0){
  192.                 this.lightnings = this.lightnings.filter((e) => time < (e.time+600))
  193.                 ctx.strokeStyle = "#97f0ea";
  194.                 ctx.lineWidth = 3;
  195.                 for(let i of this.lightnings){
  196.                     ctx.globalAlpha = (1-(time-i.time)/700);
  197.                     ctx.beginPath();
  198.                     for(let j = 0; j < i.renderData.length; j++){
  199.                         ctx.lineTo(i.renderData[j].x, i.renderData[j].y);
  200.                     }
  201.                     ctx.stroke();
  202.                     ctx.closePath();
  203.                 }
  204.             }     
  205.         }
  206.     }
  207.  
  208.     PetalContainer.prototype.draw = function(inGame, number, crafting = false) {
  209.         this.updateInterpolate();
  210.  
  211.         if(this.toOscillate === true && toRender({x: this.render.x, y: this.render.y, radius: this.radius}, window.camera) === false && this.toSkipCulling !== true){
  212.             return;
  213.         }
  214.  
  215.         const renderAnimationTimer = smoothstep(this.spawnAnimation);
  216.  
  217.         let scale = 1;
  218.         let rotation = 0;
  219.  
  220.         ctx.lastTransform = ctx.getTransform();
  221.         ctx.translate(this.render.x, this.render.y);
  222.         scale *= renderAnimationTimer * this.render.w / 50;
  223.  
  224.         rotation -= (1 - renderAnimationTimer) * Math.PI * 3;
  225.         if(this.isDraggingPetalContainer === true){
  226.             if(this.draggingTimer === undefined)this.draggingTimer = 0;
  227.             this.draggingTimer += 1000 / 30 * dt/16.66;
  228.             rotation += Math.sin(this.draggingTimer / 280) * 0.28;
  229.             if(this !== draggingPetalContainer){
  230.                 this.isDraggingPetalContainer = false;
  231.                 this.undraggingPetalContainerTimer = 30;
  232.                 this.lastDraggingAngle = Math.sin(this.draggingTimer / 280) * 0.28;
  233.             }
  234.         } else if(this.undraggingPetalContainerTimer !== undefined){
  235.             if(this.interval === undefined){
  236.                 this.lastDraggingAngle = interpolate(this.lastDraggingAngle, 0, 0.15);
  237.                 rotation += this.lastDraggingAngle;
  238.                 this.undraggingPetalContainerTimer--;
  239.                 if(this.undraggingPetalContainerTimer < 0){
  240.                     delete this.undraggingPetalContainerTimer;
  241.                     delete this.lastDraggingAngle;
  242.                     delete this.draggingTimer;
  243.                 }
  244.             }
  245.         }
  246.  
  247.         if(this.toOscillate === true){
  248.             scale *= 1+Math.sin(performance.now()/ 1000 / .076)/52;
  249.             rotation += this.angleOffset;
  250.         }
  251.  
  252.         if(rotation !== 0)ctx.rotate(rotation);
  253.         if(scale !== 1)ctx.scale(scale, scale);
  254.         if(this.toOscillate === true && this.isDisplayPetalContainer !== true){
  255.             ctx.globalAlpha = 0.3;
  256.             ctx.fillStyle = 'black';
  257.             ctx.beginPath();
  258.             ctx.roundRect(-30, -30, 60, 60, 5);
  259.             ctx.fill();
  260.             ctx.closePath();
  261.             ctx.globalAlpha = 1;
  262.         }
  263.  
  264.         ctx.lineWidth = 4.5;
  265.  
  266.         currentBiome = biomeManager.getCurrentBiome();
  267.         this.greyed = (this.customBiome !== undefined && window.officialBiomes.includes(currentBiome) === true) || (crafting && this.amount < 5);
  268.         if(this.type === 'soccer petal' && currentBiome !== 'Soccer!') this.greyed = true;
  269.         if(this.greyed){
  270.             ctx.globalAlpha = 0.3;
  271.             ctx.fillStyle = "#525252";
  272.             ctx.strokeStyle = "#404040";
  273.         } else {
  274.             ctx.fillStyle = Colors.rarities[this.rarity].color;
  275.             ctx.strokeStyle = Colors.rarities[this.rarity].border;
  276.         }
  277.  
  278.         if((currentBiome === '1v1' && this.generatedIn1v1 === false) || (currentBiome !== '1v1' && this.generatedIn1v1 === true)){
  279.             if(pregeneratedPvpStats === undefined) generatePvpStats();
  280.             let statsToTake;
  281.             if(currentBiome === '1v1'){
  282.                 statsToTake = pregeneratedPvpStats;
  283.             } else {
  284.                 statsToTake = Stats;
  285.             }
  286.  
  287.             if(this.petals.length !== 0 && this.petals[0].team !== undefined){
  288.                 statsToTake = statsToTake.enemies;
  289.             } else {
  290.                 statsToTake = statsToTake.petals;
  291.             }
  292.  
  293.             let petalAmount = 0;
  294.             if(statsToTake[this.type] !== undefined && statsToTake[this.type][this.rarity] !== undefined){
  295.                 const petalLayout = statsToTake[this.type][this.rarity].petalLayout;
  296.                 if(petalLayout === undefined) petalAmount = 1;
  297.                 else {
  298.                     for(let i = 0; i < petalLayout.length; i++){
  299.                         for(let j = 0; j < petalLayout[i].length; j++){
  300.                             petalAmount++;
  301.                         }
  302.                     }
  303.                 }
  304.             } else {
  305.                 petalAmount = 1;
  306.             }
  307.  
  308.             if(petalAmount < this.petals.length){
  309.                 this.petals.length = petalAmount;
  310.             } else {
  311.                 while(this.petals.length < petalAmount){
  312.                     this.petals.push(new Petal(this.petals[Math.floor(Math.random() * this.petals.length)]));
  313.                 }
  314.             }
  315.             this.generatedIn1v1 = !this.generatedIn1v1;
  316.         }
  317.  
  318.         if (Colors.rarities[this.rarity].fancy !== undefined){
  319.             const gradientFill = ctx.createLinearGradient(-30, -30, 30, 30);
  320.             createFancyGradient(gradientFill, this.rarity);
  321.             ctx.fillStyle = gradientFill;
  322.             ctx.strokeStyle = Colors.rarities[this.rarity].fancy.border;
  323.         }
  324.  
  325.         ctx.beginPath();
  326.         ctx.roundRect(-25, -25, 50, 50, .25);
  327.         ctx.fill();
  328.         ctx.stroke();
  329.         ctx.closePath();
  330.  
  331.         if(Colors.rarities[this.rarity].fancy !== undefined && Colors.rarities[this.rarity].fancy.stars !== undefined){
  332.             ctx.save();
  333.             if(!this.stars){
  334.                 this.stars = [];
  335.                 for(let starnum = 0; starnum < Colors.rarities[this.rarity].fancy.stars; starnum++){
  336.                     this.stars.push({x: Math.random()*50 - 25, y: Math.random()*50 - 25})
  337.                 }
  338.             }
  339.             ctx.shadowBlur = 20;
  340.             ctx.shadowColor = "white";
  341.             ctx.fillStyle = "#ffffff";
  342.             for(let star of this.stars){
  343.                 star.x+=0.1;
  344.                 star.y+=0.1;
  345.                 if(star.x >30 || star.y >30){
  346.                     star.x = Math.random()*800 - 20 - 30;
  347.                     star.y = -30;
  348.  
  349.                 }
  350.  
  351.                 if(star.x < -30 || star.x > 30 || star.y < -30 || star.y > 30){
  352.                     continue;
  353.                 }
  354.                 ctx.beginPath();
  355.  
  356.                 var grad = ctx.createRadialGradient(star.x, star.y,15,star.x, star.y,0);
  357.                 grad.addColorStop(0,"transparent");
  358.                 grad.addColorStop(0.8,`rgba(255,255,255,${(Math.cos(Date.now()/600+ star.x/30 + star.y/30) + 1)*0.8})`);
  359.                 grad.addColorStop(1,"white");
  360.  
  361.                 ctx.fillStyle = grad;
  362.                 ctx.globalAlpha = 0.3;
  363.  
  364.                 ctx.fillRect(-20.5, -20.5, 41,41);
  365.                 ctx.globalAlpha = 1;
  366.                 if(star.x < 20.5 && star.x > -20.5 && star.y < 20.5 && star.y > -20.5){
  367.  
  368.                     ctx.fillStyle = "#fff";
  369.  
  370.                     ctx.arc(star.x, star.y, 1, 0, 2*Math.PI);
  371.                     ctx.fill();
  372.                 }
  373.                 ctx.closePath();
  374.             }
  375.             ctx.restore();
  376.         }
  377.  
  378.         if (inGame){
  379.             if (petalReloadData[number]){
  380.                 if (petalReloadData[number].reload > 0.001 && petalReloadData[number].reload < 0.999){
  381.                     ctx.save();
  382.                     ctx.beginPath();
  383.                     ctx.roundRect(-25, -25, 50, 50, .25);
  384.                     ctx.clip();
  385.  
  386.                     ctx.globalAlpha = 0.3;
  387.                     ctx.lineCap = "butt";
  388.  
  389.                     let offset = (1-Math.pow(petalReloadData[number].reload, 0.7))*Math.PI*6 + this.randomAngle;
  390.  
  391.                     ctx.strokeStyle = "#000000";
  392.                     ctx.lineWidth = 50;
  393.                     ctx.beginPath();
  394.                     ctx.arc(0, 0, 25, offset - Math.PI * 2 * smoothstep(petalReloadData[number].reload), offset);
  395.                     ctx.stroke();
  396.                     ctx.closePath();
  397.  
  398.                     ctx.restore();
  399.                 }
  400.             }else if(petalHpData[number]){
  401.                 if (petalHpData[number].hp > 0.001 && petalHpData[number].hp < 0.999){
  402.                     ctx.save();
  403.                     ctx.beginPath();
  404.                     ctx.roundRect(-23, -23, 46, 46, .25);
  405.                     ctx.clip();
  406.  
  407.                     ctx.globalAlpha = 0.3;
  408.                     ctx.lineCap = "butt";
  409.  
  410.                     ctx.fillStyle = "#000000";
  411.                     ctx.beginPath();
  412.                     ctx.rect(-25, -25, 50, 50 * (1-petalHpData[number].hp));
  413.                     ctx.fill();
  414.                     ctx.closePath();
  415.  
  416.                     ctx.restore();
  417.                 }
  418.  
  419.             }
  420.         }
  421.  
  422.         if(this.greyed)ctx.globalAlpha = 1;
  423.  
  424.         if(this.toRenderText === false){
  425.             ctx.translate(0, 3.5);
  426.         }
  427.  
  428.         if(this.type === 'Wing'){
  429.             ctx.translate(0, -1.8);
  430.         }
  431.  
  432.         if(this.petals.length === 1){
  433.             this.petals[0].render.x = 0
  434.             this.petals[0].render.y = 0
  435.  
  436.             let scaleMult = .8;
  437.             if(this.petals[0].radius * .8 > 13.25/2){
  438.                 scaleMult = 13.25/(this.petals[0].radius*.8)/2;
  439.             }
  440.             if(petalContainerRenderSizeMultsMap[this.petals[0].type] !== undefined){
  441.                 if (typeof petalContainerRenderSizeMultsMap[this.petals[0].type] == "object"){
  442.                     if (petalContainerRenderSizeMultsMap[this.petals[0].type][this.petals[0].rarity]){
  443.                         scaleMult *= petalContainerRenderSizeMultsMap[this.petals[0].type][this.petals[0].rarity];
  444.                     }
  445.                 }
  446.                 else{
  447.                     scaleMult *= petalContainerRenderSizeMultsMap[this.petals[0].type];
  448.                 }
  449.             }
  450.  
  451.             let individualRotate = false;
  452.             if(petalContainerIndividualRotate[this.petals[0].type] !== undefined){
  453.                 if (typeof petalContainerIndividualRotate[this.petals[0].type] == "object"){
  454.                     if (petalContainerIndividualRotate[this.petals[0].type][this.petals[0].rarity]){
  455.                         individualRotate = petalContainerIndividualRotate[this.petals[0].type][this.petals[0].rarity];
  456.                     }
  457.                 }
  458.                 else{
  459.                     individualRotate = petalContainerIndividualRotate[this.petals[0].type];
  460.                 }
  461.             }
  462.  
  463.             let last = {y: this.petals[0].render.y, selfAngle: this.petals[0].selfAngle};
  464.             this.petals[0].render.y -= 4;
  465.             this.petals[0].scaleMult = scaleMult;
  466.             if(individualRotate !== false)this.petals[0].selfAngle += individualRotate;
  467.  
  468.             if(this.greyed === true)window.alphaMult = 0.4;
  469.             this.petals[0].draw();
  470.             this.petals[0].render.y = last.y;
  471.             delete this.petals[0].scaleMult;
  472.             this.petals[0].selfAngle = last.selfAngle;
  473.         } else {
  474.             let petalRadius = (this.petals[0] ?? {radius: 0}).radius;
  475.             if((this.petals[0] ?? {type: 'not peas'}).type === 'Peas'){
  476.                 petalRadius -= 0.2;
  477.             }
  478.             let radius = Math.min(petalRadius * 1.16, 25 - petalRadius);
  479.  
  480.             let greaterThanMargin = petalRadius * .8 + radius - 13.25;
  481.             if(greaterThanMargin > 0){
  482.                 radius -= greaterThanMargin;
  483.                 if(radius < 8){
  484.                     greaterThanMargin = 8-radius;
  485.                     radius = 8;
  486.                     petalRadius *= 1 / (greaterThanMargin/13.25+1);
  487.                     for(let i = 0; i < this.petals.length; i++){
  488.                         this.petals[i].radius = petalRadius;
  489.                     }
  490.                 }
  491.             }
  492.             if (petalContainerMultPetalRadiusMap[this.petals[0].type] !== undefined){
  493.                 if (typeof petalContainerMultPetalRadiusMap[this.petals[0].type] == "object"){
  494.                     if (petalContainerMultPetalRadiusMap[this.petals[0].type][this.petals[0].rarity]){
  495.                         radius *= petalContainerMultPetalRadiusMap[this.petals[0].type][this.petals[0].rarity];
  496.                     }
  497.                 }
  498.                 else{
  499.                     radius *= petalContainerMultPetalRadiusMap[this.petals[0].type];
  500.                 }
  501.             }
  502.             let toPointToCenter = ['Stinger'].includes((this.petals[0] ?? {type: "Basic"}).type) && (this.petals[0] ?? {rarity: 0}).rarity > 5;
  503.             if (toPointToCenter == true){
  504.                 toPointToCenter = 0;
  505.             }
  506.             if (pointToCenterPetals[this.petals[0].type] !== undefined){
  507.                 if (typeof pointToCenterPetals[this.petals[0].type] == "object"){
  508.                     if (pointToCenterPetals[this.petals[0].type][this.petals[0].rarity]){
  509.                         toPointToCenter = pointToCenterPetals[this.petals[0].type][this.petals[0].rarity];
  510.                     }
  511.                 }
  512.                 else{
  513.                     toPointToCenter = pointToCenterPetals[this.petals[0].type];
  514.                 }
  515.             }
  516.             for(let i = 0; i < this.petals.length; i++){
  517.                 let rotateOffset = 0;
  518.                 if (petalContainerRotateMap[this.petals[0].type]){
  519.                     rotateOffset = petalContainerRotateMap[this.petals[0].type];
  520.                 }
  521.                 const angle = Math.PI * 2 * i / this.petals.length + rotateOffset;
  522.                 this.petals[i].render.x = 0
  523.                 this.petals[i].render.y = 0
  524.  
  525.                 let scaleMult = .8;
  526.                 if(petalContainerRenderSizeMultsMap[this.petals[0].type] !== undefined){
  527.                     if (typeof petalContainerRenderSizeMultsMap[this.petals[0].type] == "object"){
  528.                         if (petalContainerRenderSizeMultsMap[this.petals[0].type][this.petals[0].rarity]){
  529.                             scaleMult *= petalContainerRenderSizeMultsMap[this.petals[0].type][this.petals[0].rarity];
  530.                         }
  531.                     }
  532.                     else{
  533.                         scaleMult *= petalContainerRenderSizeMultsMap[this.petals[0].type];
  534.                     }
  535.                 }
  536.  
  537.                 let last = {x: this.petals[i].render.x, y: this.petals[i].render.y, selfAngle: this.petals[i].selfAngle};
  538.                 this.petals[i].render.x += Math.cos(angle) * radius * scaleMult/.8;
  539.                 this.petals[i].render.y += Math.sin(angle) * radius * scaleMult/.8 - 4;
  540.                 this.petals[i].scaleMult = scaleMult;
  541.                 if(toPointToCenter !== false)this.petals[i].selfAngle += angle+Math.PI+toPointToCenter;
  542.                 if(this.greyed === true)window.alphaMult = 0.4;
  543.                 this.petals[i].draw();
  544.                 this.petals[i].render.x = last.x;
  545.                 this.petals[i].render.y = last.y;
  546.                 delete this.petals[i].scaleMult;
  547.                 this.petals[i].selfAngle = last.selfAngle;
  548.             }
  549.         }
  550.  
  551.         if(this.type === 'Wing'){
  552.             ctx.translate(0, 1.8);
  553.         }
  554.  
  555.         if(this.toRenderText === false){
  556.             ctx.translate(0, -3.5);
  557.         }
  558.  
  559.         if(this.toRenderText === undefined){
  560.             if(this.type === "Dandelion" || this.type === "Neutron Star" || this.type === "Mini Flower"){
  561.                 ctx.font = '900 8.5px Ubuntu';
  562.                 ctx.letterSpacing = "-.1px";
  563.             } else if(this.type === "Lightning" || this.type === "Pentagon" || this.type === "Hexagon" || this.type == "Plastic Egg"){
  564.                 ctx.font = '900 9.5px Ubuntu';
  565.                 ctx.letterSpacing = "-.1px";
  566.             } else {
  567.                 ctx.font = '900 11px Ubuntu';
  568.                 ctx.letterSpacing = "-.05px";
  569.             }
  570.             ctx.textBaseline = 'middle';
  571.             ctx.textAlign = 'center';
  572.             ctx.fillStyle = 'white';
  573.             ctx.strokeStyle = 'black';
  574.             ctx.lineWidth = 1.35;
  575.  
  576.             ctx.fontKerning = "none";
  577.  
  578.             let type = this.type;
  579.             if (type == "Fire Missile"){
  580.                 type = "Missile";
  581.             }
  582.             if (type == "Dark Compass"){
  583.                 type = "Compass";
  584.             }
  585.             if (type == "Waterlogged Compass"){
  586.                 type = "Compass"
  587.             }
  588.             if (type == "Plastic Egg"){
  589.                 type = "Egg";
  590.             }
  591.             if (type == "Jellyfish Egg"){
  592.                 type = "Egg";
  593.             }
  594.             if (type == "Oranges" && this.rarity >= 12){
  595.                 type = "Orange";
  596.             }
  597.  
  598.             if(this.greyed) ctx.globalAlpha = 0.3;
  599.             ctx.strokeText(type, 0, 13.25);
  600.             ctx.fillText(type, 0, 13.25);
  601.             ctx.globalAlpha = 1;
  602.         }
  603.  
  604.         if(scale !== 1)ctx.scale(1/scale, 1/scale);
  605.         if(rotation !== 0)ctx.rotate(-rotation);
  606.  
  607.         if(this.amount !== 1 || (performance.now() - this.lastAmountChangedTime < 240)){
  608.             if(performance.now() - this.lastAmountChangedTime < 240){
  609.                 ctx.globalAlpha = smoothstep((performance.now() - this.lastAmountChangedTime) / 240);
  610.             }
  611.             if(this.amount === 1){
  612.                 ctx.globalAlpha = 1 - ctx.globalAlpha;
  613.             }
  614.             ctx.font = `600 ${13 * scale}px Ubuntu`;
  615.             ctx.letterSpacing = "1px";
  616.             ctx.textBaseline = 'middle';
  617.             ctx.textAlign = 'right';
  618.             ctx.fillStyle = 'white';
  619.             ctx.strokeStyle = 'black';
  620.             ctx.lineWidth = 2;
  621.             ctx.translate((70/(2.5) + .5) * scale, (-42/(2.5) + .5) * scale);
  622.             ctx.rotate(Math.PI / 9.1);
  623.             if(this.greyed) ctx.globalAlpha *= 0.3;
  624.             ctx.strokeText('x' + (this.amount === 1 ? 2 : formatAmount(this.amount)), 0, 0);
  625.             ctx.fillText('x' + (this.amount === 1 ? 2 : formatAmount(this.amount)), 0, 0);
  626.             ctx.globalAlpha = 1;
  627.         }
  628.         ctx.setTransform(ctx.lastTransform);
  629.         delete ctx.lastTransform;
  630.     };
  631.  
  632.     craftingMenu.drawInventory = function(alpha = 1) {
  633.         this.render.scroll = interpolate(this.render.scroll, this.scroll, 0.0070 * dt);
  634.  
  635.         if (alpha !== 1) {
  636.             ctx.globalAlpha = alpha;
  637.         }
  638.         let translation = 0;
  639.         if (time - this.lastCloseTime < 160) {
  640.             translation += this.h * easeOutCubic((time - this.lastCloseTime) / 160);
  641.         }
  642.         if (time - this.lastOpenTime < 160) {
  643.             translation += (this.h + 40) - (this.h + 40) * easeOutCubic((time - this.lastOpenTime) / 160);
  644.         }
  645.         if (translation !== 0) {
  646.             ctx.translate(0, translation);
  647.         }
  648.  
  649.         ctx.translate(130, canvas.h - this.h - 20);
  650.         ctx.fillStyle = this.getMainFill();
  651.         ctx.strokeStyle = this.getMainStroke();
  652.         ctx.lineWidth = 8;
  653.  
  654.         ctx.beginPath()
  655.         ctx.roundRect(0, 0, this.w, this.h, 3);
  656.         ctx.fill();
  657.         ctx.stroke();
  658.         ctx.closePath();
  659.  
  660.         ctx.fillStyle = '#f0f0f0';
  661.         ctx.strokeStyle = 'black';
  662.         ctx.lineWidth = 3.75;
  663.         ctx.textAlign = 'center';
  664.         ctx.textBaseline = 'middle';
  665.         ctx.font = `900 32px Ubuntu`;
  666.         ctx.strokeText("Craft", this.w / 2, 29);
  667.         ctx.fillText("Craft", this.w / 2, 29);
  668.  
  669.         if (this.craftingAnimationState === true) {
  670.             this.runCraftingAnimation();
  671.         }
  672.         if (this.craftingAnimationState === "display") {
  673.             this.displayPetalContainer.x = this.craftingPetalSlotsDimensions.x + this.displayPetalContainer.render.w * .35;
  674.             this.displayPetalContainer.y = this.craftingPetalSlotsDimensions.y + this.displayPetalContainer.render.h * .35;
  675.             this.displayPetalContainer.render.x = this.displayPetalContainer.x;
  676.             this.displayPetalContainer.render.y = this.displayPetalContainer.y;
  677.             this.displayPetalContainer.draw();
  678.         } else {
  679.             for (let i = 0; i < this.craftingPetalSlots.length; i++) {
  680.                 ctx.fillStyle = '#b17f49';
  681.                 ctx.beginPath();
  682.                 ctx.roundRect(this.craftingPetalSlots[i].x, this.craftingPetalSlots[i].y, this.craftingPetalSlots[i].w, this.craftingPetalSlots[i].h, 8);
  683.                 ctx.fill();
  684.                 ctx.closePath();
  685.  
  686.                 if (this.craftingPetalContainers[i] !== undefined) {
  687.                     const pc = this.craftingPetalContainers[i];
  688.                     pc.x = this.craftingPetalSlots[i].x + this.craftingPetalSlots[i].w / 2;
  689.                     pc.y = this.craftingPetalSlots[i].y + this.craftingPetalSlots[i].h / 2;
  690.                     pc.draw();
  691.                 }
  692.             }
  693.         }
  694.  
  695.         if (mouseInBox({ x: mouse.canvasX, y: mouse.canvasY }, { x: this.craftingButton.x - this.craftingButton.w / 2 + 130, y: this.craftingButton.y - this.craftingButton.h / 2 + canvas.h - this.h - 20, w: this.craftingButton.w, h: this.craftingButton.h }) === true && this.craftingAnimationState === false) {
  696.             this.hoveringOverCraftButton = true;
  697.         } else {
  698.             this.hoveringOverCraftButton = false;
  699.         }
  700.         ctx.letterSpacing = "0px";
  701.         let fillcolor = "#777777"
  702.         let strokecolor = "#555555";
  703.         if (this.craftingPetalContainers[0] !== undefined) {
  704.             if (Colors.rarities[this.craftingPetalContainers[0].rarity + 1]) {
  705.                 fillcolor = Colors.rarities[this.craftingPetalContainers[0].rarity + 1].color;
  706.                 strokecolor = Colors.rarities[this.craftingPetalContainers[0].rarity + 1].border;
  707.  
  708.                 if (this.hoveringOverCraftButton) {
  709.                     fillcolor = blendColor(fillcolor, "#ffffff", 0.1);
  710.                     strokecolor = blendColor(strokecolor, "#ffffff", 0.03)
  711.                 }
  712.             }
  713.         }
  714.         ctx.lineWidth = 7;
  715.         ctx.fillStyle = fillcolor;
  716.         ctx.strokeStyle = strokecolor;
  717.         ctx.beginPath();
  718.         ctx.roundRect(this.craftingButton.x - this.craftingButton.w / 2, this.craftingButton.y - this.craftingButton.h / 2, this.craftingButton.w, this.craftingButton.h, 4);
  719.         ctx.fill();
  720.         ctx.stroke();
  721.         ctx.closePath();
  722.  
  723.         ctx.fillStyle = '#f0f0f0';
  724.         ctx.strokeStyle = 'black';
  725.         ctx.lineWidth = 2.25;
  726.         ctx.textAlign = 'center';
  727.         ctx.textBaseline = 'middle';
  728.         ctx.font = `900 22px Ubuntu`;
  729.         ctx.strokeText("Craft", this.craftingButton.x, this.craftingButton.y);
  730.         ctx.fillText("Craft", this.craftingButton.x, this.craftingButton.y);
  731.         if (this.craftingPetalContainers[0]) {
  732.             ctx.fillStyle = '#f0f0f0';
  733.             ctx.strokeStyle = 'black';
  734.             ctx.lineWidth = 2.25;
  735.             ctx.textAlign = 'center';
  736.             ctx.textBaseline = 'middle';
  737.             ctx.font = `900 12px Ubuntu`;
  738.  
  739.             let attempt = this.craftingPetalContainers[0].attempt;
  740.             if (attempt == undefined) {
  741.                 attempt = 0;
  742.             }
  743.             let chance = calculateChance(attempt, this.craftingPetalContainers[0].rarity)
  744.             if (this.craftingAnimationTimer > 3000 && this.craftingAnimationData.successAmount > 0) {
  745.                 ctx.fillStyle = "#00ff00"
  746.                 ctx.strokeText("Success (-" + this.craftingAnimationData.lost + ")", this.craftingButton.x, this.craftingButton.y + 40);
  747.                 ctx.fillText("Success (-" + this.craftingAnimationData.lost + ")", this.craftingButton.x, this.craftingButton.y + 40);
  748.             }
  749.             else {
  750.                 ctx.strokeText("Attempt " + (attempt + 1), this.craftingButton.x, this.craftingButton.y + 60);
  751.                 ctx.fillText("Attempt " + (attempt + 1), this.craftingButton.x, this.craftingButton.y + 60);
  752.  
  753.                 if (this.craftingPetalContainers[0].rarity >= 12){
  754.                     ctx.strokeText(Math.floor(chance * 100) / 100 + "% success chance", this.craftingButton.x, this.craftingButton.y + 40);
  755.                     ctx.fillText(Math.floor(chance * 100) / 100 + "% success chance", this.craftingButton.x, this.craftingButton.y + 40);
  756.                 }
  757.                 else{
  758.                     ctx.strokeText(Math.floor(chance * 10) / 10 + "% success chance", this.craftingButton.x, this.craftingButton.y + 40);
  759.                     ctx.fillText(Math.floor(chance * 10) / 10 + "% success chance", this.craftingButton.x, this.craftingButton.y + 40);
  760.                 }
  761.             }
  762.  
  763.         }
  764.  
  765.         if (this.hoveringOverCraftButton === true || this.draggingHorizontalScrollBar === true || this.draggingScrollBar === true || this.hoveringOverHorizontalScrollBar === true || this.hoveringOverScrollBar === true) {
  766.             setCursor('pointer');
  767.         }
  768.  
  769.         ctx.save();
  770.  
  771.         ctx.beginPath();
  772.         ctx.rect(this.inventorySpace.x, this.inventorySpace.y, this.fillingHorizontal ? this.inventorySpace.w + 24 : this.inventorySpace.w, this.inventorySpace.h);
  773.         ctx.clip();
  774.         ctx.closePath();
  775.  
  776.         this.firstPetalContainer = null;
  777.         this.lastPetalContainer = null;
  778.  
  779.         const firstRarityX = this.petalContainerSize / 2 + this.inventorySpace.x + (this.petalContainerSize + 12) * 0 + 3;
  780.         const lastRarityX = this.petalContainerSize / 2 + this.inventorySpace.x + (this.petalContainerSize + 12) * this.maxRarity - 6;
  781.         this.totalPetalWidth = lastRarityX - firstRarityX;
  782.  
  783.         let maxTypeIndex = 0;
  784.         for (let typeKey in this.petalContainers) {
  785.             for (let i = 0; i <= Math.max(5, this.maxRarity); i++) {
  786.                 const rarityKey = i;
  787.                 const pcX = this.petalContainerSize / 2 + this.inventorySpace.x + (this.petalContainerSize + 12) * rarityKey + 3 - this.render.horizontalScroll * (this.totalPetalWidth - this.inventorySpace.h);
  788.                 const pcY = 5 + this.petalContainerSize / 2 + this.typeIndexes[typeKey] * (this.petalContainerSize + 12) + 5 + this.inventorySpace.y - this.render.scroll * (this.totalPetalHeight - this.inventorySpace.h);
  789.                 if (this.typeIndexes[typeKey] > maxTypeIndex) {
  790.                     maxTypeIndex = this.typeIndexes[typeKey];
  791.                 }
  792.                 if (this.fillerPetalSlots[typeKey] === undefined) {
  793.                     this.fillerPetalSlots[typeKey] = {};
  794.                 }
  795.                 if (this.fillerPetalSlots[typeKey][rarityKey] === undefined) {
  796.                     this.fillerPetalSlots[typeKey][rarityKey] = { render: { x: pcX, y: pcY } };
  797.                 }
  798.  
  799.                 const fpc = this.fillerPetalSlots[typeKey][rarityKey];
  800.                 fpc.x = pcX;
  801.                 fpc.y = pcY;
  802.                 fpc.render.x = interpolate(fpc.render.x, fpc.x, 0.00672 * dt);
  803.                 fpc.render.y = interpolate(fpc.render.y, fpc.y, 0.00672 * dt);
  804.                 ctx.fillStyle = '#b17f49';
  805.  
  806.                 if (this.petalContainers[typeKey][rarityKey] === undefined && fpc.render.x + this.petalContainerSize / 2 > this.inventorySpace.x * 0.9 && fpc.render.x + this.petalContainerSize / 2 < (this.inventorySpace.x + this.inventorySpace.w) * 1.2 && fpc.render.y + this.petalContainerSize / 2 > this.inventorySpace.y * 0.9 && fpc.render.y + this.petalContainerSize / 2 < (this.inventorySpace.y + this.inventorySpace.h) * 1.1) {
  807.                     ctx.beginPath();
  808.                     ctx.roundRect(fpc.render.x - this.petalContainerSize / 2, fpc.render.y - this.petalContainerSize / 2, this.petalContainerSize, this.petalContainerSize, 8);
  809.                     ctx.fill();
  810.                     ctx.closePath();
  811.                 }
  812.  
  813.                 if (this.petalContainers[typeKey] !== undefined && this.petalContainers[typeKey][rarityKey] !== undefined) {
  814.                     const pc = this.petalContainers[typeKey][rarityKey];
  815.                     pc.x = pcX;
  816.                     pc.y = pcY;
  817.  
  818.                     if (pc.render.x + pc.w / 2 > this.inventorySpace.x * 0.9 && pc.render.x - pc.w / 2 < (this.inventorySpace.x + this.inventorySpace.w) * 1.1 && pc.render.y + pc.w / 2 > this.inventorySpace.y * 0.9 && pc.render.y - pc.w / 2 < (this.inventorySpace.y + this.inventorySpace.h) * 1.1) {
  819.                         pc.draw(undefined, undefined, true);
  820.                     } else {
  821.                         pc.render.x = interpolate(pc.render.x, pc.x, 0.00672 * dt)
  822.                         pc.render.y = interpolate(pc.render.y, pc.y, 0.00672 * dt)
  823.                     }
  824.  
  825.                     if (this.firstPetalContainer === null) {
  826.                         this.firstPetalContainer = pc;
  827.                     }
  828.                     this.lastPetalContainer = pc;
  829.                 } else {
  830.                     if (this.firstPetalContainer === null) {
  831.                         this.firstPetalContainer = fpc;
  832.                     }
  833.                     this.lastPetalContainer = fpc;
  834.                 }
  835.             }
  836.         }
  837.  
  838.         if (Object.keys(this.petalContainers).length < 5) {
  839.             this.fillingHorizontal = true;
  840.             for (let j = Object.keys(this.petalContainers).length; j < 5; j++) {
  841.                 const typeKey = "filler" + j;
  842.                 for (let i = 0; i <= Math.max(5, this.maxRarity); i++) {
  843.                     const rarityKey = i;
  844.                     const pcX = this.petalContainerSize / 2 + this.inventorySpace.x + (this.petalContainerSize + 12) * rarityKey + 3 - this.render.horizontalScroll * (this.totalPetalWidth - this.inventorySpace.h);
  845.                     const pcY = 5 + this.petalContainerSize / 2 + (maxTypeIndex + j - Object.keys(this.petalContainers).length + 1) * (this.petalContainerSize + 12) + 5 + this.inventorySpace.y - this.render.scroll * (this.totalPetalHeight - this.inventorySpace.h);
  846.  
  847.                     if (this.fillerPetalSlots[typeKey] === undefined) {
  848.                         this.fillerPetalSlots[typeKey] = {};
  849.                     }
  850.                     if (this.fillerPetalSlots[typeKey][rarityKey] === undefined) {
  851.                         this.fillerPetalSlots[typeKey][rarityKey] = { render: { x: pcX, y: pcY } };
  852.                     }
  853.                     const fpc = this.fillerPetalSlots[typeKey][rarityKey];
  854.                     fpc.x = pcX;
  855.                     fpc.y = pcY;
  856.                     fpc.render.x = interpolate(fpc.render.x, fpc.x, 0.00672 * dt);
  857.                     fpc.render.y = interpolate(fpc.render.y, fpc.y, 0.00672 * dt);
  858.                     ctx.fillStyle = '#b17f49';
  859.                     ctx.beginPath();
  860.                     ctx.roundRect(fpc.render.x - this.petalContainerSize / 2, fpc.render.y - this.petalContainerSize / 2, this.petalContainerSize, this.petalContainerSize, 8);
  861.                     ctx.fill();
  862.                     ctx.closePath();
  863.                 }
  864.             }
  865.         } else {
  866.             this.fillingHorizontal = false;
  867.         }
  868.  
  869.         if (this.lastPetalContainer !== null) {
  870.             const petalDimensions = {
  871.                 start: this.firstPetalContainer.y - this.petalContainerSize / 2 - 6,
  872.                 end: this.lastPetalContainer.y + this.petalContainerSize / 2 + 6
  873.             }
  874.             petalDimensions.length = petalDimensions.end - petalDimensions.start;
  875.             this.totalPetalHeight = petalDimensions.length;
  876.         }
  877.  
  878.         ctx.restore();
  879.  
  880.         let needsFilter = false;
  881.         for (let i = 0; i < this.fadingPetalContainers.length; i++) {
  882.             if (this.fadingPetalContainers[i].spawnTime < 0.001) {
  883.                 this.fadingPetalContainers[i].toRemove = true;
  884.                 needsFilter = true;
  885.             }
  886.             this.fadingPetalContainers[i].draw();
  887.         }
  888.         if (needsFilter === true) {
  889.             this.fadingPetalContainers = this.fadingPetalContainers.filter(p => p.toRemove !== true);
  890.         }
  891.         if (this.fillingHorizontal === false) {
  892.             this.render.scroll = interpolate(this.render.scroll, this.scroll, 0.0070 * dt);
  893.             if (this.render.scroll < -.1) {
  894.                 this.render.scroll = -.1;
  895.             } else if (this.render.scroll > 1.1) {
  896.                 this.render.scroll = 1.1;
  897.             }
  898.  
  899.             this.scrollbar.pos = interpolate(this.scrollbar.start, this.scrollbar.end, this.render.scroll);
  900.             this.scrollbar.bottom = this.scrollbar.pos + this.scrollbar.length / 2;
  901.             this.scrollbar.top = this.scrollbar.pos - this.scrollbar.length / 2;
  902.  
  903.             this.scrollbar.renderTop = interpolate(this.scrollbar.renderTop, this.scrollbar.top, this.draggingScrollBar ? 0.28 : 0.08);
  904.             this.scrollbar.renderBottom = interpolate(this.scrollbar.renderBottom, this.scrollbar.bottom, this.draggingScrollBar ? 0.28 : 0.08);
  905.         }
  906.  
  907.         if (this.maxRarity >= 5) {
  908.             this.render.horizontalScroll = interpolate(this.render.horizontalScroll, this.horizontalScroll, 0.0070 * dt);
  909.  
  910.             this.horizontalScrollBar.pos = interpolate(this.horizontalScrollBar.start, this.horizontalScrollBar.end, this.render.horizontalScroll);
  911.             this.horizontalScrollBar.right = this.horizontalScrollBar.pos + this.horizontalScrollBar.length / 2;
  912.             this.horizontalScrollBar.left = this.horizontalScrollBar.pos - this.horizontalScrollBar.length / 2;
  913.  
  914.             this.horizontalScrollBar.renderRight = interpolate(this.horizontalScrollBar.renderRight, this.horizontalScrollBar.right, this.draggingHorizontalScrollBar ? 0.28 : 0.08);
  915.             this.horizontalScrollBar.renderLeft = interpolate(this.horizontalScrollBar.renderLeft, this.horizontalScrollBar.left, this.draggingHorizontalScrollBar ? 0.28 : 0.08);
  916.         }
  917.  
  918.         if (this.scroll < 0) {
  919.             this.scroll = 0;
  920.         } else if (this.scroll > 1) {
  921.             this.scroll = 1;
  922.         }
  923.  
  924.         ctx.strokeStyle = this.getMainStroke();
  925.         ctx.lineWidth = 8;
  926.         ctx.lineCap = 'round';
  927.         ctx.beginPath();
  928.         ctx.moveTo(this.w - 16, (this.scrollbar.renderTop));
  929.         ctx.lineTo(this.w - 16, (this.scrollbar.renderBottom));
  930.         ctx.stroke();
  931.         ctx.closePath();
  932.  
  933.         ctx.beginPath();
  934.         ctx.moveTo(this.horizontalScrollBar.renderRight, this.h - 16);
  935.         ctx.lineTo(this.horizontalScrollBar.renderLeft, this.h - 16);
  936.         ctx.stroke();
  937.         ctx.closePath();
  938.  
  939.         if (this.menuActive === true && translation === 0) {
  940.             if (mouse.canvasX > 130 + this.w - 7.5 - 30 - 3 && mouse.canvasY > canvas.h - this.h - 20 + 7.5 + 3 && mouse.canvasX < 130 + this.w - 7.5 - 3 && mouse.canvasY < canvas.h - this.h - 20 + 7.5 + 30 + 3) {
  941.                 ctx.fillStyle = "#c16666";
  942.                 setCursor('pointer');
  943.                 this.hoveringOverX = true;
  944.             } else {
  945.                 this.hoveringOverX = false;
  946.                 ctx.fillStyle = '#c1565e';
  947.             }
  948.         } else {
  949.             ctx.fillStyle = '#c1565e';
  950.             this.hoveringOverX = false;
  951.         }
  952.         ctx.translate(-3, 3);
  953.         ctx.strokeStyle = '#90464b';
  954.         ctx.lineWidth = 5;
  955.         ctx.beginPath();
  956.         ctx.roundRect(this.w - 7.5 - 30, 7.5, 30, 30, 6);
  957.         ctx.fill();
  958.         ctx.stroke();
  959.         ctx.closePath();
  960.  
  961.         ctx.lineWidth = 4.75;
  962.         ctx.lineCap = 'round';
  963.         ctx.strokeStyle = '#cccccc';
  964.         ctx.beginPath();
  965.         ctx.moveTo(this.w - 30, 30);
  966.         ctx.lineTo(this.w - 7.5 * 2, 7.5 + 7.5);
  967.         ctx.stroke();
  968.         ctx.closePath();
  969.         ctx.beginPath();
  970.         ctx.moveTo(this.w - 7.5 * 2, 30);
  971.         ctx.lineTo(this.w - 30, 7.5 + 7.5);
  972.         ctx.stroke();
  973.         ctx.closePath();
  974.         ctx.translate(3, -3);
  975.  
  976.         const mouseX = mouse.x * canvas.w / window.innerWidth;
  977.         const mouseY = mouse.y * canvas.h / window.innerHeight;
  978.  
  979.         if (mouseX > 130 && mouseX < 130 + this.w - 20 && mouseY > canvas.h - this.h - 20 && mouseY < canvas.h - 20) {
  980.             ctx.lastTransform5 = ctx.getTransform();
  981.             for (let typeKey in this.petalContainers) {
  982.                 for (let i = 0; i <= this.maxRarity; i++) {
  983.                     if (this.petalContainers[typeKey] === undefined) continue;
  984.                     const rarityKey = i;
  985.                     const pc = this.petalContainers[typeKey][rarityKey];
  986.                     if (pc === undefined) continue;
  987.  
  988.                     if (pc.render.x + pc.w / 2 > this.inventorySpace.x * 0.9 && pc.render.x - pc.w / 2 < (this.inventorySpace.x + this.inventorySpace.w) * 1.1 && pc.render.y + pc.w / 2 > this.inventorySpace.y * 0.9 && pc.render.y - pc.w / 2 < (this.inventorySpace.y + this.inventorySpace.h) * 1.1) {
  989.                         if (mouseInBox({ x: mouseX, y: mouseY }, { x: pc.render.x - pc.w / 2 + 130, y: pc.render.y - pc.h / 2 + canvas.h - this.h - 20, w: pc.w, h: pc.h }) === true) {
  990.                             pc.isHovered = true;
  991.                         }
  992.                         pc.drawStatsBox();
  993.                     }
  994.                 }
  995.             }
  996.  
  997.             if (this.craftingAnimationState === "display") {
  998.                 const pc = this.displayPetalContainer;
  999.                 if (mouseInBox({ x: mouseX, y: mouseY }, { x: pc.render.x - pc.w / 2 + 130, y: pc.render.y - pc.h / 2 + canvas.h - this.h - 20, w: pc.w, h: pc.h }) === true) {
  1000.                     pc.isHovered = true;
  1001.                 }
  1002.                 pc.drawStatsBox();
  1003.             } else {
  1004.                 for (let i = 0; i < this.craftingPetalSlots.length; i++) {
  1005.                     if (this.craftingPetalContainers[i] !== undefined) {
  1006.                         const pc = this.craftingPetalContainers[i];
  1007.                         if (mouseInBox({ x: mouseX, y: mouseY }, { x: pc.render.x - pc.w / 2 + 130, y: pc.render.y - pc.h / 2 + canvas.h - this.h - 20, w: pc.w, h: pc.h }) === true) {
  1008.                             pc.isHovered = true;
  1009.                         }
  1010.                         pc.drawStatsBox();
  1011.                     }
  1012.                 }
  1013.             }
  1014.             ctx.setTransform(ctx.lastTransform5);
  1015.             delete ctx.lastTransform5;
  1016.         }
  1017.  
  1018.         ctx.translate(-130, -(canvas.h - this.h - 20));
  1019.  
  1020.         if (translation !== 0) {
  1021.             ctx.translate(0, -translation);
  1022.         }
  1023.         ctx.globalAlpha = 1;
  1024.     }
  1025.  
  1026.     renderHpBar = function({x,y,radius,hp,maxHp,beforeStreakHp,givenAlpha,flowerName,flowerUsername,shield,team},entity={fadeState: undefined, fadeTime: 0, lastHp: hp}, rarity, isBoss){
  1027.         if(entity.fadeState === undefined){
  1028.             if(Math.ceil(entity.hp) === maxHp && !shield){
  1029.                 entity.fadeState = 'invisible';
  1030.                 entity.fadeTime = -220;
  1031.             } else {
  1032.                 entity.fadeTime = time;
  1033.                 entity.fadeState = 'fadeIn';
  1034.             }
  1035.         }
  1036.         if(entity.lastHp === undefined){
  1037.             entity.lastHp = entity.hp;
  1038.         }
  1039.         if(entity.lastShield === undefined){
  1040.             entity.lastShield = entity.shield;
  1041.         }
  1042.     
  1043.         let fadeAlphaMult = 1;
  1044.  
  1045.         if(entity.dead !== true){
  1046.             if(Math.ceil(entity.lastHp) < maxHp && Math.ceil(entity.hp) === maxHp && entity.shield == 0){
  1047.                 entity.fadeTime = time;
  1048.                 entity.fadeState = 'fadeOut';
  1049.             } else if((Math.ceil(entity.lastHp) === maxHp && Math.ceil(entity.hp) < maxHp) || (entity.shield != 0 && entity.lastShield == 0)){
  1050.                 entity.fadeTime = time;
  1051.                 entity.fadeState = 'fadeIn';
  1052.             }
  1053.         }
  1054.         entity.lastShield = entity.shield;
  1055.         entity.lastHp = entity.hp;
  1056.     
  1057.         toResetFadeState = false;
  1058.         if (givenAlpha){
  1059.             if (givenAlpha > 0){
  1060.                 toResetFadeState = entity.fadeState;
  1061.                 entity.fadeState = "visible";
  1062.             }
  1063.         }
  1064.         if(entity.fadeState === 'fadeOut'){
  1065.             fadeAlphaMult = 1 - (time - entity.fadeTime) / 180;
  1066.             if(fadeAlphaMult < 0){
  1067.                 fadeAlphaMult = 0;
  1068.                 entity.fadeState = 'invisible';
  1069.             }
  1070.         } else if(entity.fadeState === 'fadeIn'){
  1071.             fadeAlphaMult = (time - entity.fadeTime) / 180;
  1072.             if(fadeAlphaMult > 1){
  1073.                 fadeAlphaMult = 1;
  1074.                 entity.fadeState = 'visible';
  1075.             }
  1076.         } else if(entity.fadeState === 'invisible'){
  1077.             return;
  1078.         }
  1079.     
  1080.         if(entity.dead === true)fadeAlphaMult *= ((10 - entity.deadAnimationTimer) / 166) ** 3;
  1081.  
  1082.         if (givenAlpha){
  1083.             fadeAlphaMult = givenAlpha;
  1084.         }
  1085.         const barDimensions = {
  1086.             w: (radius/25)**1.2*25*3.2+.33,
  1087.             h: (radius/25)**1.2*25*0.39+.33,
  1088.             borderRadius: (radius/25)**1.2*25*0.25,
  1089.             innerPadding: (radius/25)**1.05*1.8-.1
  1090.         }
  1091.         ctx.globalAlpha = fadeAlphaMult;
  1092.         hp = Math.max(hp, 0);
  1093.         beforeStreakHp = Math.max(beforeStreakHp, 0);
  1094.  
  1095.         if(rarity){
  1096.             let rarName = Colors.rarities[rarity].name;
  1097.             if(isBoss){
  1098.                 ctx.fillStyle = `hsl(${(time/10) % 360}, 50%, 40%)`;
  1099.                 rarName = 'Boss';
  1100.             } else {
  1101.                 ctx.fillStyle = Colors.rarities[rarity].color;
  1102.             };
  1103.             ctx.beginPath();
  1104.             ctx.roundRect(x - barDimensions.w/2 - barDimensions.innerPadding, y + radius*1.775 - barDimensions.innerPadding, (barDimensions.w - barDimensions.borderRadius * 1.5) + barDimensions.borderRadius * 1.5 + barDimensions.innerPadding * 2, barDimensions.h + barDimensions.innerPadding * 2, barDimensions.borderRadius * barDimensions.h / (barDimensions.h - barDimensions.innerPadding * 2));
  1105.             ctx.fill();
  1106.             ctx.closePath();
  1107.  
  1108.             ctx.font = '900 36px Ubuntu';
  1109.             ctx.lineWidth = 5;
  1110.             ctx.strokeStyle = 'black';
  1111.             ctx.strokeText(rarName, x - barDimensions.w/2 + barDimensions.w / 2, y + radius*2.5 + barDimensions.innerPadding);
  1112.             ctx.fillText(rarName, x - barDimensions.w/2 + barDimensions.w / 2, y + radius*2.5 + barDimensions.innerPadding);
  1113.         }
  1114.  
  1115.         ctx.fillStyle = '#333333';
  1116.         ctx.beginPath();
  1117.         ctx.roundRect(x - barDimensions.w/2, y + radius*1.775, barDimensions.w, barDimensions.h, barDimensions.borderRadius);
  1118.         ctx.fill();
  1119.         ctx.closePath();
  1120.     
  1121.         if(flowerName !== undefined && entity.id !== window.selfId){
  1122.             
  1123.             ctx.globalAlpha = 1;
  1124.             ctx.fillStyle = 'white';
  1125.         ctx.strokeStyle = 'black';
  1126.         ctx.lineWidth = 2.25;
  1127.         ctx.textAlign = 'center';
  1128.         ctx.textBaseline = 'top';
  1129.         ctx.font = `900 22px Ubuntu`;
  1130.                 if (window.usernames === true) {
  1131.                     ctx.strokeText(flowerName, x, y - radius * 2.75 + barDimensions.h + 2);
  1132.                     ctx.fillText(flowerName, x, y - radius * 2.75 + barDimensions.h + 2);
  1133.                     ctx.font = `900 10px Ubuntu`;
  1134.                     ctx.fillStyle = '#bbbbbb';
  1135.                     ctx.strokeText(flowerUsername, x, y - radius * 2 + barDimensions.h + 2);
  1136.                     ctx.fillText(flowerUsername, x, y - radius * 2 + barDimensions.h + 2);
  1137.             } else {
  1138.                     ctx.strokeText(flowerName, x, y - radius * 2.375 + barDimensions.h + 2);
  1139.                     ctx.fillText(flowerName, x, y - radius * 2.375 + barDimensions.h + 2);
  1140.             }
  1141.         }
  1142.     
  1143.         if(beforeStreakHp < maxHp / 10){
  1144.             ctx.globalAlpha = Math.max(0,hp * .95 / (maxHp / 10) + 0.05) * fadeAlphaMult;
  1145.         }
  1146.         if(beforeStreakHp > 0){
  1147.             ctx.fillStyle = '#dd3434'
  1148.             ctx.beginPath();
  1149.             const paddingMult = 1.4;
  1150.             ctx.roundRect(x - barDimensions.w/2 + barDimensions.innerPadding * paddingMult, y + radius*1.775 + barDimensions.innerPadding * paddingMult, (barDimensions.w - barDimensions.borderRadius * 1.5) * Math.min(1,beforeStreakHp / maxHp) + barDimensions.borderRadius * 1.5 - barDimensions.innerPadding * 2 * paddingMult, barDimensions.h - barDimensions.innerPadding * paddingMult * 2, barDimensions.borderRadius * barDimensions.h / (barDimensions.h + barDimensions.innerPadding * 2));
  1151.             ctx.fill();
  1152.             ctx.closePath();
  1153.         }
  1154.         
  1155.     
  1156.         ctx.globalAlpha = fadeAlphaMult;
  1157.         if(hp < maxHp / 10){
  1158.             ctx.globalAlpha = Math.max(0,hp * .95 / (maxHp / 10) + 0.05) * fadeAlphaMult;
  1159.         }
  1160.     
  1161.         if(hp > 0){
  1162.             ctx.fillStyle = '#75dd34'
  1163.             if (team == "flower"){
  1164.                 ctx.fillStyle = "#b5aa31"
  1165.             }
  1166.             ctx.beginPath();
  1167.             
  1168.             ctx.roundRect(x - barDimensions.w/2 + barDimensions.innerPadding, y + radius*1.775 + barDimensions.innerPadding, (barDimensions.w - barDimensions.borderRadius * 1.5) * Math.min(1, hp / maxHp) + barDimensions.borderRadius * 1.5 - barDimensions.innerPadding * 2, barDimensions.h - barDimensions.innerPadding * 2, barDimensions.borderRadius * barDimensions.h / (barDimensions.h + barDimensions.innerPadding * 2));
  1169.             ctx.fill();
  1170.             ctx.closePath();
  1171.         }
  1172.         if (shield){
  1173.             if (shield > maxHp * 0.005){
  1174.                 ctx.fillStyle = 'white'
  1175.                 ctx.beginPath();
  1176.                 
  1177.                 ctx.roundRect(x - barDimensions.w/2 + barDimensions.innerPadding, y + radius*1.805 + barDimensions.innerPadding, (barDimensions.w - barDimensions.borderRadius * 1.5) * Math.min(1, shield / maxHp) + barDimensions.borderRadius * 1.5 - barDimensions.innerPadding * 2, barDimensions.h - barDimensions.innerPadding * 3, barDimensions.borderRadius * barDimensions.h / (barDimensions.h + barDimensions.innerPadding * 3));
  1178.                 ctx.fill();
  1179.                 ctx.closePath();
  1180.             }
  1181.         }
  1182.     
  1183.         ctx.globalAlpha = 1;
  1184.     
  1185.         if(toResetFadeState !== false){
  1186.             entity.fadeState = toResetFadeState;
  1187.         }
  1188.     }
  1189.  
  1190.     enemyRenderMapText = function(e) {
  1191.         renderHpBar({
  1192.             x: 0,
  1193.             y: 0,
  1194.             radius: e.render.radius * 0.8,
  1195.             hp: e.render.hp,
  1196.             maxHp: e.maxHp,
  1197.             beforeStreakHp: e.render.beforeStreakHp,
  1198.             team: e.team
  1199.         }, e, e.rarity, e.isBoss);
  1200.         if (!window.isEditor === true && window.damageCounter) {
  1201.             renderDamageCounter({
  1202.                 radius: e.render.radius,
  1203.                 timeAlive: e.ticksSinceLastDamaged,
  1204.                 totalDamage: e.damageCount,
  1205.             })
  1206.         }
  1207.     }
  1208.  
  1209.     inventory.draw = function(alpha = 1) {
  1210.         if(this.fadingPetalContainer !== null){
  1211.             const temp = {x: this.fadingPetalContainer.render.x, y: this.fadingPetalContainer.render.y};
  1212.             this.fadingPetalContainer.render.x = this.fadingPetalContainer.x;
  1213.             this.fadingPetalContainer.render.y = this.fadingPetalContainer.y;
  1214.             const animationTime = 1 - (time - this.fadingPetalContainer.fadeTime) / 200;
  1215.             ctx.globalAlpha = Math.max(0,Math.min(1,animationTime));
  1216.             ctx.save();
  1217.             ctx.translate(this.fadingPetalContainer.x, this.fadingPetalContainer.y);
  1218.             ctx.scale(2 - animationTime, 2 - animationTime);
  1219.             ctx.translate(-this.fadingPetalContainer.x, -this.fadingPetalContainer.y);
  1220.             this.fadingPetalContainer.draw(alpha);
  1221.             ctx.restore();
  1222.             this.fadingPetalContainer.render.x = temp.x;
  1223.             this.fadingPetalContainer.render.y = temp.y;
  1224.             if(time - this.fadingPetalContainer.fadeTime > 200){
  1225.                 this.fadingPetalContainer = null;
  1226.             }
  1227.         }
  1228.  
  1229.         for(let i = 0; i < this.topPetalSlots.length; i++){
  1230.             this.topPetalSlots[i].draw(alpha);
  1231.         }
  1232.         for(let i = 0; i < this.bottomPetalSlots.length; i++){
  1233.             this.bottomPetalSlots[i].draw(alpha);
  1234.         }
  1235.         for(let key in this.topPetalContainers){
  1236.             const tpc = this.topPetalContainers[key];
  1237.             let showTimer = false;
  1238.             let rarity;
  1239.             if (tpc.type == 'Egg' || tpc.type == 'Plastic Egg') {
  1240.                 if (petalReloadData[key] && Math.abs(petalReloadData[key].reload - 1) >= 1e-12) {
  1241.                     tpc.respawnTimer = tpc.petalStats.hatchTime + tpc.petalStats.reload * petalReloadData[key].reload;
  1242.                     showTimer = true;
  1243.                 } else if (tpc.hasOwnProperty('respawnTimer')) {
  1244.                     tpc.respawnTimer -= dt / 1000;
  1245.                     showTimer = true;
  1246.                     if (tpc.respawnTimer <= 0) {
  1247.                         delete tpc.respawnTimer;
  1248.                         showTimer = false;
  1249.                     };
  1250.                 };
  1251.                 rarity = tpc.petalStats.spawnRarity;
  1252.             } else if (tpc.type == 'Stick') {
  1253.                 if (petalReloadData[key]) {
  1254.                     tpc.respawnTimer = [];
  1255.                     tpc.respawnTimer.push(tpc.petalStats.spawnSystem[1] + tpc.petalStats.reload * petalReloadData[key].reload);
  1256.                     tpc.respawnTimer.push(tpc.petalStats.spawnSystem[1] * 2 + tpc.petalStats.reload * petalReloadData[key].reload);
  1257.                     showTimer = true;
  1258.                 } else if (tpc.hasOwnProperty('respawnTimer')) {
  1259.                     tpc.respawnTimer[0] -= dt / 1000;
  1260.                     tpc.respawnTimer[1] -= dt / 1000;
  1261.                     showTimer = true;
  1262.                     if (tpc.respawnTimer[1] <= 0) {
  1263.                         delete tpc.respawnTimer;
  1264.                         showTimer = false;
  1265.                     } else if (tpc.respawnTimer[0] <= 0) {
  1266.                         tpc.respawnTimer[0] = 0;
  1267.                     };
  1268.                 };
  1269.                 rarity = tpc.petalStats.spawnSystem[0];
  1270.             };
  1271.             tpc.draw(true, key);
  1272.             if (showTimer) {
  1273.                 ctx.save();
  1274.                 ctx.lineWidth = 4.5;
  1275.                 ctx.translate(tpc.x, tpc.y - tpc.h * 1.15);
  1276.                 ctx.scale(tpc.w / 50, tpc.h / 50);
  1277.  
  1278.                 if (Colors.rarities[rarity].fancy !== undefined){
  1279.                     const gradientFill = ctx.createLinearGradient(-30, -30, 30, 30);
  1280.                     createFancyGradient(gradientFill, rarity);
  1281.                     ctx.fillStyle = gradientFill;
  1282.                     ctx.strokeStyle = Colors.rarities[rarity].fancy.border;
  1283.                 } else {
  1284.                     ctx.fillStyle = Colors.rarities[rarity].color;
  1285.                     ctx.strokeStyle = Colors.rarities[rarity].border;
  1286.                 }
  1287.         
  1288.                 ctx.beginPath();
  1289.                 ctx.roundRect(-25, -25, 50, 50, .25);
  1290.                 ctx.fill();
  1291.                 ctx.stroke();
  1292.                 ctx.closePath();
  1293.  
  1294.                 ctx.restore();
  1295.  
  1296.                 ctx.font = '900 24px Ubuntu';
  1297.                 ctx.lineWidth = 5;
  1298.                 ctx.strokeStyle = 'black';
  1299.                 ctx.fillStyle = 'white';
  1300.                 let timer = tpc.type == 'Stick' ? (tpc.respawnTimer[0] == 0 ? tpc.respawnTimer[1] : tpc.respawnTimer[0]) : tpc.respawnTimer;
  1301.                 ctx.strokeText(Math.round(timer * 100) / 100 + 's', tpc.x, tpc.y - tpc.h * 1.15);
  1302.                 ctx.fillText(Math.round(timer * 100) / 100 + 's', tpc.x, tpc.y - tpc.h * 1.15);
  1303.             };
  1304.         }
  1305.         for(let key in this.bottomPetalContainers){
  1306.             this.bottomPetalContainers[key].draw();
  1307.         }
  1308.  
  1309.         if(this === menuInventory){
  1310.             const mouseX = mouse.x * canvas.w / window.innerWidth;
  1311.             const mouseY = mouse.y * canvas.h / window.innerHeight;
  1312.             const offsetMouseY = mouseY - this.translateY;
  1313.             ctx.lastTransform8 = ctx.getTransform();
  1314.             for(let key in this.topPetalContainers){
  1315.                 const pc = this.topPetalContainers[key];
  1316.  
  1317.                 if(mouseX > pc.x - pc.w/2 && mouseX < pc.x + pc.w/2 && offsetMouseY > pc.y - pc.h/2 && offsetMouseY < pc.y + pc.h/2){
  1318.                     pc.isHovered = true;
  1319.                 }
  1320.                 pc.drawStatsBox(true);
  1321.             }
  1322.  
  1323.             for(let key in this.bottomPetalContainers){
  1324.                 const pc = this.bottomPetalContainers[key];
  1325.  
  1326.                 if(mouseX > pc.x - pc.w/2 && mouseX < pc.x + pc.w/2 && offsetMouseY > pc.y - pc.h/2 && offsetMouseY < pc.y + pc.h/2){
  1327.                     pc.isHovered = true;
  1328.                 }
  1329.                 pc.drawStatsBox(true);
  1330.             }
  1331.             ctx.setTransform(ctx.lastTransform8);
  1332.             delete ctx.lastTransform8;
  1333.         }
  1334.     }
  1335. })();