/**** 
* Plugins
****/ 
var tween = LK.import("@upit/tween.v1");

/**** 
* Classes
****/ 
var Background = Container.expand(function () {
	var self = Container.call(this);
	// Attach the background_1 asset to the class
	self.backgrounds = [];
	for (var i = 0; i <= 9; i++) {
		var background = self.attachAsset('background_' + i, {
			anchorX: 0.5,
			anchorY: 0.5,
			visible: false
		});
		self.backgrounds.push(background);
	}
	self.backgrounds[0].visible = true; // Set the initial background visible
	// Position the background at the center of the screen
	self.x = 2048 / 2;
	self.y = 2732 / 2;
	// Function to change the background based on the index
	self.changeBackground = function (index) {
		var currentBg = self.backgrounds.find(function (bg) {
			return bg.visible;
		});
		var newBg = self.backgrounds[index];
		if (newBg && currentBg !== newBg) {
			tween(currentBg, {
				alpha: 0
			}, {
				duration: 500,
				easing: tween.easeOut,
				onFinish: function onFinish() {
					currentBg.visible = false;
					newBg.alpha = 0;
					newBg.visible = true;
					tween(newBg, {
						alpha: 1
					}, {
						duration: 500,
						easing: tween.easeIn
					});
				}
			});
		}
	};
});
// Create a class for bigHeart
var BigHeart = Container.expand(function () {
	var self = Container.call(this);
	self.currentGraphic = null;
	self.nextGraphic = null;
	self.tapLimit = 12; // Initialize tap limit
	self.nbTapsPerFrame = self.tapLimit / 6; // Initialize number of taps per frame
	self.heartType = 0; // Initialize tap counter
	self.explosionTriggered = false; // Initialize explosion flag
	// Attach the bigHeart asset to the class
	var bigHeartGraphics = self.attachAsset('bigHeart', {
		anchorX: 0.5,
		anchorY: 0.5,
		alpha: 0.1
	});
	self.heartFrames = {}; // Initialize heartFrames as a property of BigHeart class
	for (var type = 9; type >= 0; type--) {
		self.heartFrames[type] = [];
		for (var i = 5; i >= 0; i--) {
			self.heartFrames[type][5 - i] = self.attachAsset('heart_' + type + '_frame_' + i, {
				anchorX: 0.5,
				anchorY: 0.5,
				scaleX: 0.9,
				scaleY: 0.9,
				heartType: type,
				index: 5 - i,
				visible: !i
			});
		}
	}
	log("Setting frames in constructor...");
	self.currentGraphic = self.heartFrames[self.heartType][5];
	self.nextGraphic = self.heartFrames[self.heartType][4];
	if (self.currentGraphic) {
		if (self.currentGraphic && self.currentGraphic.scaleX !== undefined) {
			self.currentGraphic.scaleX = 1.1;
		}
		if (self.currentGraphic && self.currentGraphic.scaleY !== undefined) {
			self.currentGraphic.scaleY = 1.1;
		}
		self.currentGraphic.visible = true;
	}
	if (self.nextGraphic) {
		if (self.nextGraphic.scaleX !== undefined) {
			self.nextGraphic.scaleX = 1.1;
		}
		if (self.nextGraphic.scaleY !== undefined) {
			self.nextGraphic.scaleY = 1.1;
		}
		self.nextGraphic.visible = true;
	}
	// Position the bigHeart at the center of the screen
	self.x = 2048 / 2;
	self.y = 2732 / 2 - 300;
	// Define baseWidth and baseHeight
	var baseWidth = bigHeartGraphics.width;
	var baseHeight = bigHeartGraphics.height;
	// Event handler called when a press happens on element. This is automatically called on press if bigHeart is attached.
	self.down = function (x, y, obj) {
		// Log the down event
		log("Down event triggered on BigHeart");
		if (self.currentGraphic && self.nextGraphic) {
			log("Current indexes:: ", self.currentGraphic.index, ',', self.nextGraphic.index); // Log the tap count
		} else {
			log("CurrentGraphic or NextGraphic is not initialized.");
		}
		// Increment tap counter
		progressManager.manualGeneration();
		self.animateBeat();
		self.animateFrames();
		// Create a new heart projection using the current frame index
		if (self.currentGraphic) {
			projectionsManager.popHearts(self.currentGraphic.heartType);
		} else {
			log("CurrentGraphic is not initialized.");
		}
		shakeMiddleground();
	};
	// Beat Animation
	self.animateBeat = function () {
		// Play beat sound
		LK.getSound('bump').play();
		if (self.currentGraphic) {
			if (!self.currentGraphic._activeTween) {
				self.currentGraphic._activeTween = tween(self.currentGraphic, {
					scaleX: 1.2,
					scaleY: 1.2,
					x: 0
				}, {
					duration: 100,
					onFinish: function onFinish() {
						if (self.currentGraphic) {
							delete self.currentGraphic._activeTween;
							tween(self.currentGraphic, {
								scaleX: 1.1,
								scaleY: 1.1,
								x: 0
							}, {
								duration: 100
							});
						}
					}
				});
			}
		}
		if (self.nextGraphic && !self.nextGraphic._activeTween) {
			self.nextGraphic._activeTween = tween(self.nextGraphic, {
				duration: 250,
				onFinish: function onComplete() {
					if (self.nextGraphic) {
						delete self.nextGraphic._activeTween;
						tween(self.nextGraphic, {
							scaleX: 1.2,
							scaleY: 1.2,
							x: 0
						}, {
							duration: 100,
							onFinish: function onFinish() {
								if (self.nextGraphic) {
									delete self.nextGraphic._activeTween;
									tween(self.nextGraphic, {
										scaleX: 1.1,
										scaleY: 1.1,
										x: 0
									}, {
										duration: 100
									});
								}
							}
						});
					}
				}
			});
		}
	};
	// Frames Animation
	self.animateFrames = function () {
		if (self.explosionTriggered || tapCount >= self.tapLimit * (self.heartType + 1)) {
			return;
		}
		// Calculate progress in current level (0 to 1)
		var progress = (tapCount - self.heartType * self.tapLimit) / self.tapLimit;
		// Map progress to frame indices (frames go from 5 to 0)
		var frameProgress = progress * 5;
		var currentFrame = 5 - Math.floor(frameProgress);
		var nextFrame = Math.max(0, currentFrame - 1);
		var alpha = frameProgress - Math.floor(frameProgress);
		// Update frame visibility only if current frame changed
		if (self.currentGraphic !== self.heartFrames[self.heartType][currentFrame]) {
			// Hide all frames
			self.heartFrames[self.heartType].forEach(function (frame) {
				return frame.visible = false;
			});
			// Setup current and next frames
			self.currentGraphic = self.heartFrames[self.heartType][currentFrame];
			self.nextGraphic = self.heartFrames[self.heartType][nextFrame];
			[self.currentGraphic, self.nextGraphic].forEach(function (frame) {
				if (frame) {
					frame.visible = true;
					frame.scaleX = frame.scaleY = 1.1;
				}
			});
		}
		// Update alpha for smooth transition
		if (self.currentGraphic) {
			self.currentGraphic.alpha = 1 - alpha;
		}
	};
	// Explosion Animation
	self.animateExplosion = function (callback) {
		if (!self.explosionTriggered) {
			self.explosionTriggered = true;
			if (true || !isDebug) {
				LK.getSound('boom').play();
			}
			var cloneGraphic;
			if (self.nextGraphic) {
				cloneGraphic = LK.getAsset('heart_' + self.nextGraphic.heartType + '_frame_' + self.nextGraphic.index, {
					anchorX: 0.5,
					anchorY: 0.5,
					scaleX: self.nextGraphic.scaleX,
					scaleY: self.nextGraphic.scaleY,
					alpha: 1
				});
				self.addChild(cloneGraphic);
			}
			LK.setTimeout(function () {
				LK.effects.flashScreen(0xffffff, 2000); // Flash the screen white for 500ms
				background.changeBackground(progressManager.currentLevel + 1); // Change background when level changes
				if (cloneGraphic) {
					log("nextGraphic for explosion!", cloneGraphic);
					tween(cloneGraphic, {
						scaleX: 45,
						scaleY: 45,
						alpha: 0
					}, {
						duration: 3000,
						easing: tween.easeOut,
						onFinish: function onFinish() {
							// Make all frames of the current heartType invisible
							self.heartFrames[self.heartType].forEach(function (frame) {
								frame.visible = false;
							});
							self.explosionTriggered = false; // Reset explosion flag
							cloneGraphic.destroy(); // Remove the clone after animation
							if (callback) {
								callback();
							}
						}
					});
					// Pre scale next heart
					tween(self.heartFrames[self.heartType + 1][5], {
						scaleX: 1.1,
						scaleY: 1.1
					}, {
						duration: 300,
						easing: tween.easeOut
					});
					tween(self.heartFrames[self.heartType + 1][4], {
						scaleX: 1.1,
						scaleY: 1.1
					}, {
						duration: 300,
						easing: tween.easeOut
					});
				} else {
					log("No nextGraphic for explosion!");
				}
			}, 205);
		}
	};
	self.resetGraphics = function () {
		log("resetGraphics...");
		// Stop current graphic tweens
		if (self.currentGraphic && self.currentGraphic._activeTween) {
			self.currentGraphic._activeTween.stop();
		}
		if (self.nextGraphic && self.nextGraphic._activeTween) {
			self.nextGraphic._activeTween.stop();
		}
		// Hide only active frames
		if (self.currentGraphic) {
			self.currentGraphic.visible = false;
		}
		if (self.nextGraphic) {
			self.nextGraphic.visible = false;
		}
		self.currentGraphic = null;
		self.nextGraphic = null;
	};
});
// Constants for Generators and Upgrades
var GeneratorButton = Container.expand(function (index) {
	var self = Container.call(this);
	// Attach a button asset to the class
	var buttonGraphics = self.attachAsset('generatorButton', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	// Ensure rightBoard is initialized before accessing its properties
	self.index = Math.min(Math.max(0, index), maxGenerators);
	var generatorAsset = self.attachAsset('generator_' + self.index, {
		anchorX: 0.5,
		anchorY: 0.5
	});
	if (typeof GENERATORS !== 'undefined') {
		self.config = Object.values(GENERATORS).find(function (g) {
			return g.id === self.index;
		});
	} else {
		console.error("GENERATORS is not defined");
		self.config = {
			cost: 0
		}; // Default to prevent undefined error
	}
	self.costText = new Text2(self.config.cost.toString(), {
		size: 50,
		fill: 0x043515,
		dropShadow: true,
		align: 'center'
	});
	self.countText = new Text2(' ', {
		size: 50,
		fill: 0x043515,
		dropShadow: true,
		align: 'center'
	});
	self.countText.x = -buttonGraphics.width / 2 + 10;
	self.countText.y = -buttonGraphics.height / 2 + 10;
	self.addChild(self.countText);
	self.costText.x = 45;
	self.costText.y = 75;
	self.visible = false;
	self.addChild(self.costText);
	if (typeof GENERATORS !== 'undefined') {
		self.config = Object.values(GENERATORS).find(function (g) {
			return g.id === self.index;
		});
	} else {
		console.error("GENERATORS is not defined");
	}
	// Position the button at the center of the screen
	// self.x = 2048 / 2;
	// self.y = 2732 / 2;
	// Event handler called when a press happens on the button
	self.down = function (x, y, obj) {
		log("Generator button pressed", y);
		globalStartY = y;
		self.startTime = Date.now();
	};
	self.up = function (x, y, obj) {
		var endTime = Date.now();
		var timeDiff = endTime - self.startTime;
		var distance = Math.sqrt(Math.pow(x - self.startX, 2) + Math.pow(y - globalStartY, 2));
		if (timeDiff < 200 && distance < 10) {
			// Detected as a tap
			log("Detected tap on Generator button");
			// Check if tapCount is less than the cost of the generator
			if (tapCount < self.config.cost) {
				log("No enough love");
				LK.getSound('cantBuyGenerator').play(); // Play sound when player can't buy
				tween(self, {
					x: 10,
					y: 10
				}, {
					duration: 100,
					easing: tween.easeInOut,
					onFinish: function onFinish() {
						tween(self, {
							x: -10,
							y: -10
						}, {
							duration: 100,
							easing: tween.easeInOut,
							onFinish: function onFinish() {
								tween(self, {
									x: 0,
									y: 0
								}, {
									duration: 100,
									easing: tween.easeInOut
								});
							}
						});
					}
				});
				return; // Exit if not enough taps
			}
			// Buy the corresponding generator using progressManager
			if (progressManager.buyGenerator(self.index)) {
				log("Generator purchased successfully");
				tween(self, {
					scaleX: 1.2,
					// Increase scale for bump effect
					scaleY: 1.2
				}, {
					duration: 100,
					// Duration of the bump
					easing: tween.easeOut,
					// Easing function for smooth effect
					onFinish: function onFinish() {
						tween(self, {
							// Return to original scale
							scaleX: 1,
							scaleY: 1
						}, {
							duration: 100,
							easing: tween.easeIn
						});
					}
				});
			} else {
				log("Failed to purchase generator");
			}
		} else {
			// Detected as a swipe
			log("Detected swipe on Generator button");
			rightBoard.handleSwipe(y - globalStartY);
		}
	};
});
// Create a class for Projections
var Projections = Container.expand(function () {
	var self = Container.call(this);
	var nbProjections = 5;
	var heartSpeed = 20;
	var gravity = 0.5;
	var initialScale = 0.25;
	var scaleVariation = 0.5;
	var alphaDecay = 0.002;
	self.heartPool = [];
	self.preloadedAssets = {}; // Preload assets for each heart type
	for (var type = 0; type <= 9; type++) {
		self.preloadedAssets[type] = LK.getAsset('heart_' + type + '_frame_0', {
			anchorX: 0.5,
			anchorY: 0.5,
			scaleX: 0.5,
			scaleY: 0.5
		});
	}
	// Initialize heart pool
	for (var i = 0; i < nbProjections * 5; i++) {
		var heart = new Container();
		heart.vx = 0;
		heart.vy = 0;
		heart.alpha = 0;
		heart.update = function () {
			this.x += this.vx;
			this.y += this.vy;
			this.vy += gravity; // Add gravity effect 
			this.alpha -= alphaDecay;
			if (this.alpha <= 0 || this.y > 2900) {
				this.alpha = 0;
				self.heartPool.push(this);
			}
		};
		// Add all heart type assets to the heart Container
		for (var type = 0; type <= 9; type++) {
			var heartAsset = heart.attachAsset('heart_' + type + '_frame_0', {
				anchorX: 0.5,
				anchorY: 0.5,
				scaleX: 0.5,
				scaleY: 0.5,
				heartType: type,
				visible: type === 0 // Only make the current heartType visible
			});
		}
		self.heartPool.push(heart);
	}
	self.x = 2048 / 2;
	self.y = 2732 / 2 - 400;
	// Function to pop hearts
	self.popHearts = function (heartType) {
		if (self.isUpdatingHeartType) {
			return;
		} // Exit if updateHeartType is running
		for (var i = 0; i < nbProjections; i++) {
			if (self.heartPool.length > 0) {
				var heart = self.heartPool.pop();
				if (heart.alpha <= 0) {
					// Ensure heart has finished its previous animation
					heart.x = 0;
					heart.y = 0;
					heart.vx = (Math.random() - 0.5) * heartSpeed;
					heart.vy = (Math.random() - 1.5) * heartSpeed;
					heart.alpha = 0.8;
					heart.scaleX = initialScale + Math.random() * scaleVariation; // Randomize scale between initialScale and initialScale + scaleVariation
					heart.scaleY = heart.scaleX; // Keep aspect ratio consistent
					heart.rotation = Math.random() * Math.PI * 2; // Randomize rotation between 0 and 2π
					self.addChild(heart);
				} else {
					self.heartPool.push(heart); // Return heart to pool if it hasn't finished animation
				}
			}
		}
	};
	self.updateHeartType = function (heartType) {
		// Update the heart type for all hearts in the pool
		self.isUpdatingHeartType = true; // Set flag to indicate updateHeartType is running
		self.heartPool.forEach(function (heart) {
			heart.children.forEach(function (child) {
				// Iterate over all children
				child.visible = child.heartType === heartType; // Set visibility based on heartType
			});
		});
		self.isUpdatingHeartType = false; // Reset flag after updateHeartType completes
	};
});
var RightBoard = Container.expand(function () {
	var self = Container.call(this);
	// Attach the rightBoard asset to the class
	var rightBoardGraphics = self.attachAsset('rightBoard', {
		anchorX: 0.5,
		anchorY: 0.5,
		width: 400,
		height: 3000,
		alpha: 0.2,
		visible: true // For Debuging
	});
	// Position the rightBoard at the right side of the screen
	self.x = 1848;
	self.y = 1366;
	self.buttonsOffsetX = 50;
	self.buttonsOffsetY = -300;
	self.generatorButtons = []; // Initialize an array to hold generator buttons
	// Create and position generator buttons
	for (var i = 0; i <= 9; i++) {
		// Todo : use maxGenerators
		var generatorButton = new GeneratorButton(i);
		generatorButton.x = self.buttonsOffsetX; //0 * self.x + i * 100 - 100; // Position buttons with some spacing
		generatorButton.y = self.buttonsOffsetY + i * 300 + i * 300 * 0.1; //self.y;
		self.generatorButtons.push(generatorButton);
		self.addChild(generatorButton);
	}
	self.down = function (x, y, obj) {
		log("Generator button pressed", y);
		globalStartY = y;
		self.startTime = Date.now();
		dragNode = self; // Set dragNode to the button being pressed
	};
	self.up = function (x, y, obj) {
		var endTime = Date.now();
		var timeDiff = endTime - self.startTime;
		var distance = Math.sqrt(Math.pow(x - self.startX, 2) + Math.pow(y - globalStartY, 2));
		if (timeDiff < 200 && distance < 10) {
			// Detected as a tap
			log("Detected tap on RightBoard");
		} else {
			// Detected as a swipe
			log("Detected swipe on RightBoard");
			self.handleSwipe(y - globalStartY, y);
		}
		dragNode = null; // Reset dragNode when mouse is up
	};
	// Add any additional functionality or properties for rightBoard here
	self.handleSwipe = function (deltaY, y) {
		// Calculate new positions for the first and last buttons
		var firstButtonNewY = self.y + self.generatorButtons[0].y + deltaY;
		var lastButtonNewY = self.y + self.generatorButtons[self.generatorButtons.length - 1].y + deltaY;
		log("firstButtonNewY:", firstButtonNewY, "lastButtonNewY:", lastButtonNewY);
		// Check if the first button stays above the screen center and the last button stays below the screen center
		// Adjust deltaY to prevent moving beyond boundaries
		if (deltaY > 0) {
			deltaY = Math.min(deltaY, 1000 - (self.y + self.generatorButtons[0].y));
		}
		if (deltaY < 0) {
			deltaY = Math.max(deltaY, 1366 - (self.y + self.generatorButtons[self.generatorButtons.length - 1].y));
		}
		// Move all generator buttons vertically based on swipe direction
		self.generatorButtons.forEach(function (button) {
			button.y += deltaY;
		});
		globalStartY = y; // Update globalStartY for continuous movement
	};
	self.move = function (x, y, obj) {
		if (dragNode) {
			// Check if a button is being dragged
			var deltaY = y - globalStartY; // Calculate deltaY based on movement
			log("Move detected with deltaY:", deltaY);
			// Calculate new positions for the first and last buttons
			var firstButtonNewY = self.y + self.generatorButtons[0].y + deltaY;
			var lastButtonNewY = self.y + self.generatorButtons[self.generatorButtons.length - 1].y + deltaY;
			log("firstButtonNewY:", firstButtonNewY, "lastButtonNewY:", lastButtonNewY);
			// Check if the first button stays above the screen center and the last button stays below the screen center
			// Adjust deltaY to prevent moving beyond boundaries
			if (deltaY > 0) {
				deltaY = Math.min(deltaY, 1000 - (self.y + self.generatorButtons[0].y));
			}
			if (deltaY < 0) {
				deltaY = Math.max(deltaY, 1366 - (self.y + self.generatorButtons[self.generatorButtons.length - 1].y));
			}
			// Move all generator buttons vertically based on swipe direction
			self.generatorButtons.forEach(function (button) {
				button.y += deltaY;
			});
			globalStartY = y; // Update globalStartY for continuous movement
		}
	};
});

/**** 
* Initialize Game
****/ 
var game = new LK.Game({
	backgroundColor: 0xa16e9f //Init game with black background 
});

/**** 
* Game Code
****/ 
// Declare a global variable to store the startY position for GeneratorButton events
var globalStartY = 0;
// Constants for Generators and Upgrades
var GENERATORS = GENERATORS || {
	ROSE: {
		id: 0,
		name: "Rose",
		description: "A charming rose that generates a few love beats",
		autoClick: true,
		clickRate: 1,
		// 1 click per 10 seconds
		cost: 10,
		upgradeLevel: 0
	},
	CHOCLATE: {
		id: 1,
		name: "Choclate",
		description: "A sweet choclate that generates love faster",
		autoClick: true,
		clickRate: 2,
		cost: 11,
		upgradeLevel: 0
	},
	CHAIN_BRACELET: {
		id: 2,
		name: "Chain Bracelet",
		description: "A beautiful chain bracelet that generates love even faster",
		autoClick: true,
		clickRate: 3,
		cost: 12,
		upgradeLevel: 0
	}
};
var UPGRADES = {
	LOVE_FILTER: {
		id: 0,
		name: "Love Filter",
		description: "A powerful love filter that make you irresistible",
		targetGenerator: 1,
		// Targets Generator #1 (Me)
		multipliers: [2, 4, 8],
		// Levels of multiplier
		cost: 12
	}
};
function shakeMiddleground() {
	tween(middlegroundContainer, {
		x: 10,
		y: 10
	}, {
		duration: 100,
		easing: tween.easeInOut,
		onFinish: function onFinish() {
			tween(middlegroundContainer, {
				x: -10,
				y: -10
			}, {
				duration: 100,
				easing: tween.easeInOut,
				onFinish: function onFinish() {
					tween(middlegroundContainer, {
						x: 0,
						y: 0
					}, {
						duration: 100,
						easing: tween.easeInOut
					});
				}
			});
		}
	});
}
function shakeScreen() {
	tween(game, {
		x: 10,
		y: 10
	}, {
		duration: 100,
		easing: tween.easeInOut,
		onFinish: function onFinish() {
			tween(game, {
				x: -10,
				y: -10
			}, {
				duration: 100,
				easing: tween.easeInOut,
				onFinish: function onFinish() {
					tween(game, {
						x: 0,
						y: 0
					}, {
						duration: 100,
						easing: tween.easeInOut
					});
				}
			});
		}
	});
}
var nbHearts = 10;
var backgroundContainer = new Container();
var middlegroundContainer = new Container();
var foregroundContainer = new Container();
game.addChild(backgroundContainer);
game.addChild(middlegroundContainer);
game.addChild(foregroundContainer);
var background = new Background(); // Create a Background instance
backgroundContainer.addChild(background); // Add Background instance to the backgroundContainer
var isDebug = true;
var projectionsManager = backgroundContainer.addChild(new Projections()); // Place projectionsManager in backgroundContainer
function log() {
	if (isDebug) {
		console.log.apply(console, arguments);
	}
}
// Declare maxGenerators as a global variable
var maxGenerators = 2;
// Declare tapCount as a global variable
var tapCount = 0;
// Create a text object to display tapCount
var tapCountText = new Text2('LOVE\r\n ', {
	size: 100,
	fill: 0xFFFFFF,
	dropShadow: true,
	align: 'center'
});
// Center the text horizontally, anchor point set at the middle of its top edge.
tapCountText.anchor.set(0.5, 0);
// Position the text at the top-center of the screen.
LK.gui.top.addChild(tapCountText);
// Add a big heart at the center of the screen
var bigHeart = new BigHeart();
middlegroundContainer.addChild(bigHeart);
// Add a RightBoard instance to the foreground container
var rightBoard = new RightBoard();
foregroundContainer.addChild(rightBoard);
// Update the tapCountText whenever tapCount changes
function updateTapCountText() {
	tapCountText.setText('LOVE\r\n' + tapCount);
}
// Global ProgressManager
function _typeof(o) {
	"@babel/helpers - typeof";
	return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (o) {
		return typeof o;
	} : function (o) {
		return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o;
	}, _typeof(o);
}
function _classCallCheck(a, n) {
	if (!(a instanceof n)) {
		throw new TypeError("Cannot call a class as a function");
	}
}
function _defineProperties(e, r) {
	for (var t = 0; t < r.length; t++) {
		var o = r[t];
		o.enumerable = o.enumerable || !1, o.configurable = !0, "value" in o && (o.writable = !0), Object.defineProperty(e, _toPropertyKey(o.key), o);
	}
}
function _createClass(e, r, t) {
	return r && _defineProperties(e.prototype, r), t && _defineProperties(e, t), Object.defineProperty(e, "prototype", {
		writable: !1
	}), e;
}
function _toPropertyKey(t) {
	var i = _toPrimitive(t, "string");
	return "symbol" == _typeof(i) ? i : i + "";
}
function _toPrimitive(t, r) {
	if ("object" != _typeof(t) || !t) {
		return t;
	}
	var e = t[Symbol.toPrimitive];
	if (void 0 !== e) {
		var i = e.call(t, r || "default");
		if ("object" != _typeof(i)) {
			return i;
		}
		throw new TypeError("@@toPrimitive must return a primitive value.");
	}
	return ("string" === r ? String : Number)(t);
}
var progressManager;
// Progress Management
function ProgressManager() {
	var self = this;
	self.maxHeartBeatsPerSecond = 8; // Add maxHeartBeatsPerSecond property
	self.priceIncreaseRate = 1.33; // Extracted price increase rate
	self.money = 0;
	self.generators = {};
	self.generatorCounts = {}; // Add a counter for each generator
	self.upgrades = {};
	self.currentTime = Date.now();
	self.currentLevel = 0;
	self.tapsPerLevel = {
		0: 99,
		1: 999,
		2: 9999,
		3: 99999,
		4: 999999,
		5: 9999999,
		6: 99999999,
		7: 999999999,
		8: 9999999999,
		9: 99999999999
	};
	if (isDebug) {
		self.tapsPerLevel = {
			0: 10,
			1: 50,
			2: 100,
			3: 200,
			4: 300,
			5: 400,
			6: 500,
			7: 600,
			8: 700,
			9: 1000
		};
	}
	self.lastUpdateTime = self.currentTime;
	self.updateGeneratorsUi = function () {
		// Update generator button visibility based on money
		//log("Updating Generators UI");
		rightBoard.generatorButtons.forEach(function (button, index) {
			var generatorConfig = rightBoard.generatorButtons[index].config;
			rightBoard.generatorButtons[index].costText.setText(generatorConfig.cost.toString()); // Update the cost text to reflect the new exponential cost
			if (generatorConfig) {
				// Store a flag 'wasShown' in generatorButton when displayed
				if (self.money >= generatorConfig.cost * 0.75) {
					if (!button.wasShown) {
						button.x = 2048 + button.width; // Start from the right border
						tween(button, {
							x: 0
						}, {
							duration: 500,
							easing: tween.easeOut
						}); // Animate entrance
					}
					// Show generator if player has at least 75% of its cost
					button.wasShown = true;
					button.visible = true;
					// Set alpha to 0.75 if player can't buy the generator
					button.alpha = self.money >= generatorConfig.cost ? 1 : 0.6;
				} else {
					button.visible = button.wasShown;
					button.alpha = 0.6;
				}
			} else {
				button.visible = false;
			}
		});
	};
	self.updateGame = function () {
		//log("ProgressManager updateGame...");
		var now = Date.now();
		var deltaTime = now - self.lastUpdateTime;
		var tempGenerated = 0;
		// Update generators
		Object.values(self.generators).forEach(function (generator) {
			var generated = generator.generate(deltaTime) * self.generatorCounts[generator.id];
			log("generator => +" + generated);
			tempGenerated += Math.ceil(generated);
		});
		// Calculate beats based on generation rate
		var beatsToGenerate = Math.floor(tempGenerated / 2); // One beat every 10 taps generated
		beatsToGenerate = Math.min(beatsToGenerate, self.maxHeartBeatsPerSecond); // Cap at 5 beats per update to avoid overwhelming
		self.money += tempGenerated;
		self.updateGeneratorsUi();
		// Trigger multiple beats based on generation rate
		if (tempGenerated > 0) {
			for (var i = 0; i < beatsToGenerate; i++) {
				LK.setTimeout(function () {
					bigHeart.animateBeat();
				}, i * 300);
			}
		}
		tapCount = self.money; // Update tapCount to reflect the current money
		updateTapCountText(); // Update the text display
		//log("Tap count: ", tapCount); // Log the tap count
		self.checkProgress(); // Check the progress
		self.lastUpdateTime = now;
	};
	self.manualGeneration = function () {
		tapCount++;
		self.money++;
		log("manualGeneration Tap count: ", tapCount); // Log the tap count
		updateTapCountText(); // Update the text display
		self.updateGeneratorsUi();
		self.checkProgress(); // Check for level up immediately
	};
	self.checkProgress = function () {
		if (tapCount >= self.tapsPerLevel[self.currentLevel]) {
			if (self.currentLevel < 9) {
				// Ensure we don't exceed level 9
				var previousLevel = self.currentLevel;
				var previousFrames = bigHeart.heartFrames[previousLevel] || [];
				previousFrames.forEach(function (frame) {
					if (frame && frame._activeTween) {
						frame._activeTween.stop();
					}
					frame.visible = false;
				});
				bigHeart.animateExplosion(function () {
					self.currentLevel++;
					bigHeart.heartType = self.currentLevel;
					bigHeart.currentGraphic = bigHeart.heartFrames[bigHeart.heartType][5];
					bigHeart.nextGraphic = bigHeart.heartFrames[bigHeart.heartType][4];
					bigHeart.currentGraphic.visible = true;
					projectionsManager.updateHeartType(bigHeart.heartType);
					bigHeart.nextGraphic.visible = true;
					tween(bigHeart.currentGraphic, {
						scaleX: 1.1,
						scaleY: 1.1
					}, {
						duration: 300,
						easing: tween.easeOut
					});
					tween(bigHeart.nextGraphic, {
						scaleX: 1.1,
						scaleY: 1.1
					}, {
						duration: 300,
						easing: tween.easeOut
					});
				});
			}
		}
	};
	self.buyGenerator = function (generatorId) {
		var generatorConfig = Object.values(GENERATORS).find(function (g) {
			return g.id === generatorId;
		});
		if (!generatorConfig) {
			log("Generator not found");
			return false;
		}
		// Check if player has enough money
		if (self.money < generatorConfig.cost) {
			log("Not enough money");
			return false;
		}
		// Initialize generator if it doesn't exist
		if (!self.generators[generatorId]) {
			self.generators[generatorId] = new Generator(generatorConfig);
			self.generatorCounts[generatorId] = 0;
		}
		self.money -= generatorConfig.cost;
		// Calculate new cost
		var currentCount = self.generatorCounts[generatorId] || 0;
		var baseCost = GENERATORS[Object.keys(GENERATORS)[generatorId]].cost;
		var newCost = Math.floor(baseCost * Math.pow(self.priceIncreaseRate, currentCount + 1));
		log("Updating costs - Base:", baseCost, "Count:", currentCount, "New Cost:", newCost);
		// Update costs
		generatorConfig.cost = newCost;
		rightBoard.generatorButtons[generatorId].config.cost = newCost;
		self.generatorCounts[generatorId]++; // Increment the count for the generator 
		rightBoard.generatorButtons[generatorId].countText.setText(self.generatorCounts[generatorId].toString());
		log("Generator", generatorId, "Count:", self.generatorCounts[generatorId], "New Cost:", newCost);
		LK.getSound('buyGenerator').play();
		return true;
	};
	self.buyUpgrade = function (upgradeId, generatorId) {
		var upgradeConfig = Object.values(UPGRADES).find(function (u) {
			return u.id === upgradeId;
		});
		var targetGenerator = self.generators[generatorId];
		if (!upgradeConfig || !targetGenerator) {
			throw new Error("Upgrade or Generator not found");
		}
		if (self.money < upgradeConfig.cost) {
			return false;
		}
		self.money -= upgradeConfig.cost;
		var upgrade = new Upgrade(upgradeConfig);
		upgrade.apply(targetGenerator);
		self.upgrades[upgradeId] = upgrade;
		return true;
	};
}
function Generator(config) {
	var self = this;
	self.id = config.id;
	self.name = config.name;
	self.description = config.description;
	self.autoClick = config.autoClick;
	self.clickRate = config.clickRate;
	self.cost = config.cost;
	self.upgradeLevel = config.upgradeLevel;
	self.generate = function (deltaTime) {
		if (!self.autoClick) {
			return 0;
		}
		var clickAmount = self.clickRate * deltaTime / 1000;
		return clickAmount * Math.pow(2, self.upgradeLevel);
	};
	self.currentMultiplier = Math.pow(2, self.upgradeLevel);
	self.manualGenerate = function () {
		return 1 * self.currentMultiplier;
	};
	self.upgrade = function (upgradeMultiplier) {
		self.upgradeLevel++;
	};
}
function Upgrade(config) {
	var self = this;
	self.id = config.id;
	self.name = config.name;
	self.description = config.description;
	self.targetGenerator = config.targetGenerator;
	self.multipliers = config.multipliers;
	self.cost = config.cost;
	self.currentLevel = 0;
	self.apply = function (generator) {
		if (self.currentLevel < self.multipliers.length) {
			generator.upgrade(self.multipliers[self.currentLevel]);
			self.currentLevel++;
		}
	};
}
function initializeGame() {
	progressManager = new ProgressManager();
	var intervalId = LK.setInterval(function () {
		progressManager.updateGame();
	}, 1000);
	// Ensure to clear the interval when necessary
	// LK.clearInterval(intervalId);
}
initializeGame();

===================================================================
--- original.js
+++ change.js
@@ -546,8 +546,9 @@
 	self.down = function (x, y, obj) {
 		log("Generator button pressed", y);
 		globalStartY = y;
 		self.startTime = Date.now();
+		dragNode = self; // Set dragNode to the button being pressed
 	};
 	self.up = function (x, y, obj) {
 		var endTime = Date.now();
 		var timeDiff = endTime - self.startTime;
@@ -559,8 +560,9 @@
 			// Detected as a swipe
 			log("Detected swipe on RightBoard");
 			self.handleSwipe(y - globalStartY, y);
 		}
+		dragNode = null; // Reset dragNode when mouse is up
 	};
 	// Add any additional functionality or properties for rightBoard here
 	self.handleSwipe = function (deltaY, y) {
 		// Calculate new positions for the first and last buttons
@@ -580,8 +582,32 @@
 			button.y += deltaY;
 		});
 		globalStartY = y; // Update globalStartY for continuous movement
 	};
+	self.move = function (x, y, obj) {
+		if (dragNode) {
+			// Check if a button is being dragged
+			var deltaY = y - globalStartY; // Calculate deltaY based on movement
+			log("Move detected with deltaY:", deltaY);
+			// Calculate new positions for the first and last buttons
+			var firstButtonNewY = self.y + self.generatorButtons[0].y + deltaY;
+			var lastButtonNewY = self.y + self.generatorButtons[self.generatorButtons.length - 1].y + deltaY;
+			log("firstButtonNewY:", firstButtonNewY, "lastButtonNewY:", lastButtonNewY);
+			// Check if the first button stays above the screen center and the last button stays below the screen center
+			// Adjust deltaY to prevent moving beyond boundaries
+			if (deltaY > 0) {
+				deltaY = Math.min(deltaY, 1000 - (self.y + self.generatorButtons[0].y));
+			}
+			if (deltaY < 0) {
+				deltaY = Math.max(deltaY, 1366 - (self.y + self.generatorButtons[self.generatorButtons.length - 1].y));
+			}
+			// Move all generator buttons vertically based on swipe direction
+			self.generatorButtons.forEach(function (button) {
+				button.y += deltaY;
+			});
+			globalStartY = y; // Update globalStartY for continuous movement
+		}
+	};
 });
 
 /**** 
 * Initialize Game