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

/**** 
* Classes
****/ 
var BlueBlock = Container.expand(function () {
	var self = Container.call(this);
	var blockGraphics = self.attachAsset('blueBlock', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	return self;
});
var BouncingCircle = Container.expand(function () {
	var self = Container.call(this);
	var circleGraphics = self.attachAsset('bouncingCircle', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	// Velocity properties
	self.velocityX = 12;
	self.velocityY = 10;
	self.update = function () {
		// Move the circle
		self.x += self.velocityX;
		self.y += self.velocityY;
		// Check collision with blue blocks
		for (var i = blocks.length - 1; i >= 0; i--) {
			var block = blocks[i];
			if (self.intersects(block)) {
				// Play blue block sound and additional sounds
				LK.getSound('sonidodebloqueazul').play();
				var additionalSounds = ['q', 'w', 'e', 'r', 't'];
				var randomAdditionalSound = additionalSounds[Math.floor(Math.random() * additionalSounds.length)];
				LK.getSound(randomAdditionalSound).play();
				// Block destroyed
				// Add expansion animation to bouncing circle
				tween(self, {
					scaleX: 1.5,
					scaleY: 1.5
				}, {
					duration: 200,
					easing: tween.easeOut,
					onFinish: function onFinish() {
						tween(self, {
							scaleX: 1,
							scaleY: 1
						}, {
							duration: 200,
							easing: tween.easeIn
						});
					}
				});
				// Spawn red block at random position with minimum distance from other blocks
				var newRedBlock = game.addChild(new RedBlock());
				var validPosition = false;
				var attempts = 0;
				while (!validPosition && attempts < 50) {
					newRedBlock.x = Math.random() * (2048 - 120) + 60; // Random X within screen bounds
					newRedBlock.y = Math.random() * 800 + 200; // Random Y in upper part of screen
					validPosition = true;
					// Check distance from all existing blue blocks
					for (var b = 0; b < blocks.length; b++) {
						var existingBlock = blocks[b];
						var dx = newRedBlock.x - existingBlock.x;
						var dy = newRedBlock.y - existingBlock.y;
						var distance = Math.sqrt(dx * dx + dy * dy);
						if (distance < 200) {
							// Minimum distance of 200 pixels
							validPosition = false;
							break;
						}
					}
					// Check distance from all existing red blocks
					for (var r = 0; r < redBlocks.length; r++) {
						var existingRedBlock = redBlocks[r];
						var dx = newRedBlock.x - existingRedBlock.x;
						var dy = newRedBlock.y - existingRedBlock.y;
						var distance = Math.sqrt(dx * dx + dy * dy);
						if (distance < 200) {
							// Minimum distance of 200 pixels
							validPosition = false;
							break;
						}
					}
					// Check distance from all existing green blocks
					for (var g = 0; g < greenBlocks.length; g++) {
						var existingGreenBlock = greenBlocks[g];
						var dx = newRedBlock.x - existingGreenBlock.x;
						var dy = newRedBlock.y - existingGreenBlock.y;
						var distance = Math.sqrt(dx * dx + dy * dy);
						if (distance < 200) {
							// Minimum distance of 200 pixels
							validPosition = false;
							break;
						}
					}
					// Check distance from all existing purple blocks
					for (var p = 0; p < purpleBlocks.length; p++) {
						var existingPurpleBlock = purpleBlocks[p];
						var dx = newRedBlock.x - existingPurpleBlock.x;
						var dy = newRedBlock.y - existingPurpleBlock.y;
						var distance = Math.sqrt(dx * dx + dy * dy);
						if (distance < 200) {
							// Minimum distance of 200 pixels
							validPosition = false;
							break;
						}
					}
					attempts++;
				}
				redBlocks.push(newRedBlock);
				// 10% chance to spawn power orb
				if (Math.random() < 0.1) {
					var powerOrb = game.addChild(new PowerOrb());
					powerOrb.x = block.x;
					powerOrb.y = block.y;
					powerOrbs.push(powerOrb);
				}
				// Destroy the block
				block.destroy();
				blocks.splice(i, 1);
				// Reverse ball Y velocity
				self.velocityY = -self.velocityY;
				break; // Only hit one block per frame
			}
		}
		// Check collision with red blocks
		for (var j = redBlocks.length - 1; j >= 0; j--) {
			var redBlock = redBlocks[j];
			if (self.intersects(redBlock)) {
				// Play red block sound and additional sounds
				LK.getSound('sonidodebloquerojo').play();
				var additionalSounds = ['q', 'w', 'e', 'r', 't'];
				var randomAdditionalSound = additionalSounds[Math.floor(Math.random() * additionalSounds.length)];
				LK.getSound(randomAdditionalSound).play();
				// Block destroyed
				// Add expansion animation to bouncing circle
				tween(self, {
					scaleX: 1.5,
					scaleY: 1.5
				}, {
					duration: 200,
					easing: tween.easeOut,
					onFinish: function onFinish() {
						tween(self, {
							scaleX: 1,
							scaleY: 1
						}, {
							duration: 200,
							easing: tween.easeIn
						});
					}
				});
				// Spawn green block at random position with minimum distance from other blocks
				var newGreenBlock = game.addChild(new GreenBlock());
				var validPosition = false;
				var attempts = 0;
				while (!validPosition && attempts < 50) {
					newGreenBlock.x = Math.random() * (2048 - 120) + 60; // Random X within screen bounds
					newGreenBlock.y = Math.random() * 800 + 200; // Random Y in upper part of screen
					validPosition = true;
					// Check distance from all existing blue blocks
					for (var b = 0; b < blocks.length; b++) {
						var existingBlock = blocks[b];
						var dx = newGreenBlock.x - existingBlock.x;
						var dy = newGreenBlock.y - existingBlock.y;
						var distance = Math.sqrt(dx * dx + dy * dy);
						if (distance < 200) {
							// Minimum distance of 200 pixels
							validPosition = false;
							break;
						}
					}
					// Check distance from all existing red blocks
					for (var r = 0; r < redBlocks.length; r++) {
						var existingRedBlock = redBlocks[r];
						var dx = newGreenBlock.x - existingRedBlock.x;
						var dy = newGreenBlock.y - existingRedBlock.y;
						var distance = Math.sqrt(dx * dx + dy * dy);
						if (distance < 200) {
							// Minimum distance of 200 pixels
							validPosition = false;
							break;
						}
					}
					// Check distance from all existing green blocks
					for (var g = 0; g < greenBlocks.length; g++) {
						var existingGreenBlock = greenBlocks[g];
						var dx = newGreenBlock.x - existingGreenBlock.x;
						var dy = newGreenBlock.y - existingGreenBlock.y;
						var distance = Math.sqrt(dx * dx + dy * dy);
						if (distance < 200) {
							// Minimum distance of 200 pixels
							validPosition = false;
							break;
						}
					}
					// Check distance from all existing purple blocks
					for (var p = 0; p < purpleBlocks.length; p++) {
						var existingPurpleBlock = purpleBlocks[p];
						var dx = newGreenBlock.x - existingPurpleBlock.x;
						var dy = newGreenBlock.y - existingPurpleBlock.y;
						var distance = Math.sqrt(dx * dx + dy * dy);
						if (distance < 200) {
							// Minimum distance of 200 pixels
							validPosition = false;
							break;
						}
					}
					attempts++;
				}
				greenBlocks.push(newGreenBlock);
				// 10% chance to spawn power orb
				if (Math.random() < 0.1) {
					var powerOrb = game.addChild(new PowerOrb());
					powerOrb.x = redBlock.x;
					powerOrb.y = redBlock.y;
					powerOrbs.push(powerOrb);
				}
				// Destroy the red block
				redBlock.destroy();
				redBlocks.splice(j, 1);
				// Reverse ball Y velocity
				self.velocityY = -self.velocityY;
				break; // Only hit one block per frame
			}
		}
		// Check collision with green blocks
		for (var k = greenBlocks.length - 1; k >= 0; k--) {
			var greenBlock = greenBlocks[k];
			if (self.intersects(greenBlock)) {
				// Play green block sound and additional sounds
				LK.getSound('sonidodebloquerojo').play();
				var additionalSounds = ['q', 'w', 'e', 'r', 't'];
				var randomAdditionalSound = additionalSounds[Math.floor(Math.random() * additionalSounds.length)];
				LK.getSound(randomAdditionalSound).play();
				// Block destroyed
				// Add expansion animation to bouncing circle
				tween(self, {
					scaleX: 1.5,
					scaleY: 1.5
				}, {
					duration: 200,
					easing: tween.easeOut,
					onFinish: function onFinish() {
						tween(self, {
							scaleX: 1,
							scaleY: 1
						}, {
							duration: 200,
							easing: tween.easeIn
						});
					}
				});
				// Spawn purple block at random position with minimum distance from other blocks
				var newPurpleBlock = game.addChild(new PurpleBlock());
				var validPosition = false;
				var attempts = 0;
				while (!validPosition && attempts < 50) {
					newPurpleBlock.x = Math.random() * (2048 - 120) + 60; // Random X within screen bounds
					newPurpleBlock.y = Math.random() * 800 + 200; // Random Y in upper part of screen
					validPosition = true;
					// Check distance from all existing blue blocks
					for (var b = 0; b < blocks.length; b++) {
						var existingBlock = blocks[b];
						var dx = newPurpleBlock.x - existingBlock.x;
						var dy = newPurpleBlock.y - existingBlock.y;
						var distance = Math.sqrt(dx * dx + dy * dy);
						if (distance < 200) {
							// Minimum distance of 200 pixels
							validPosition = false;
							break;
						}
					}
					// Check distance from all existing red blocks
					for (var r = 0; r < redBlocks.length; r++) {
						var existingRedBlock = redBlocks[r];
						var dx = newPurpleBlock.x - existingRedBlock.x;
						var dy = newPurpleBlock.y - existingRedBlock.y;
						var distance = Math.sqrt(dx * dx + dy * dy);
						if (distance < 200) {
							// Minimum distance of 200 pixels
							validPosition = false;
							break;
						}
					}
					// Check distance from all existing green blocks
					for (var g = 0; g < greenBlocks.length; g++) {
						var existingGreenBlock = greenBlocks[g];
						var dx = newPurpleBlock.x - existingGreenBlock.x;
						var dy = newPurpleBlock.y - existingGreenBlock.y;
						var distance = Math.sqrt(dx * dx + dy * dy);
						if (distance < 200) {
							// Minimum distance of 200 pixels
							validPosition = false;
							break;
						}
					}
					// Check distance from all existing purple blocks
					for (var p = 0; p < purpleBlocks.length; p++) {
						var existingPurpleBlock = purpleBlocks[p];
						var dx = newPurpleBlock.x - existingPurpleBlock.x;
						var dy = newPurpleBlock.y - existingPurpleBlock.y;
						var distance = Math.sqrt(dx * dx + dy * dy);
						if (distance < 200) {
							// Minimum distance of 200 pixels
							validPosition = false;
							break;
						}
					}
					attempts++;
				}
				purpleBlocks.push(newPurpleBlock);
				// 10% chance to spawn power orb
				if (Math.random() < 0.1) {
					var powerOrb = game.addChild(new PowerOrb());
					powerOrb.x = greenBlock.x;
					powerOrb.y = greenBlock.y;
					powerOrbs.push(powerOrb);
				}
				// Destroy the green block
				greenBlock.destroy();
				greenBlocks.splice(k, 1);
				// Reverse ball Y velocity
				self.velocityY = -self.velocityY;
				break; // Only hit one block per frame
			}
		}
		// Check collision with purple blocks
		for (var l = purpleBlocks.length - 1; l >= 0; l--) {
			var purpleBlock = purpleBlocks[l];
			if (self.intersects(purpleBlock)) {
				// Play purple block sound and additional sounds
				LK.getSound('sonidodebloquerojo').play();
				var additionalSounds = ['q', 'w', 'e', 'r', 't'];
				var randomAdditionalSound = additionalSounds[Math.floor(Math.random() * additionalSounds.length)];
				LK.getSound(randomAdditionalSound).play();
				// Block destroyed
				// Add expansion animation to bouncing circle
				tween(self, {
					scaleX: 1.5,
					scaleY: 1.5
				}, {
					duration: 200,
					easing: tween.easeOut,
					onFinish: function onFinish() {
						tween(self, {
							scaleX: 1,
							scaleY: 1
						}, {
							duration: 200,
							easing: tween.easeIn
						});
					}
				});
				// 10% chance to spawn power orb
				if (Math.random() < 0.1) {
					var powerOrb = game.addChild(new PowerOrb());
					powerOrb.x = purpleBlock.x;
					powerOrb.y = purpleBlock.y;
					powerOrbs.push(powerOrb);
				}
				// Destroy the purple block
				purpleBlock.destroy();
				purpleBlocks.splice(l, 1);
				// Reverse ball Y velocity
				self.velocityY = -self.velocityY;
				break; // Only hit one block per frame
			}
		}
		// Bounce off screen edges
		if (self.x <= 25) {
			self.x = 25;
			self.velocityX = -self.velocityX;
		}
		if (self.x >= 2048 - 25) {
			self.x = 2048 - 25;
			self.velocityX = -self.velocityX;
		}
		if (self.y <= 25) {
			self.y = 25;
			self.velocityY = -self.velocityY;
		}
		if (self.y >= 2732 - 25) {
			self.y = 2732 - 25;
			self.velocityY = -self.velocityY;
		}
	};
	return self;
});
var CornerBlock = Container.expand(function () {
	var self = Container.call(this);
	var blockGraphics = self.attachAsset('cornerBlock', {
		anchorX: 0.5,
		anchorY: 0.5,
		tint: 0x000000
	});
	// Track collision state for sound triggering
	self.lastIntersecting = false;
	self.update = function () {
		// Check collision with bouncing circle
		var currentIntersecting = self.intersects(bouncingCircle);
		if (!self.lastIntersecting && currentIntersecting) {
			// Collision just started - play random sound (C, A, or G)
			var sounds = ['c', 'a', 'g'];
			var randomSound = sounds[Math.floor(Math.random() * sounds.length)];
			LK.getSound(randomSound).play();
			var additionalSounds = ['q', 'w', 'e', 'r', 't'];
			var randomAdditionalSound = additionalSounds[Math.floor(Math.random() * additionalSounds.length)];
			LK.getSound(randomAdditionalSound).play();
			// Add expansion animation to bouncing circle
			tween(bouncingCircle, {
				scaleX: 1.5,
				scaleY: 1.5
			}, {
				duration: 200,
				easing: tween.easeOut,
				onFinish: function onFinish() {
					tween(bouncingCircle, {
						scaleX: 1,
						scaleY: 1
					}, {
						duration: 200,
						easing: tween.easeIn
					});
				}
			});
		}
		self.lastIntersecting = currentIntersecting;
	};
	return self;
});
var CornerBlockRight = Container.expand(function () {
	var self = Container.call(this);
	var blockGraphics = self.attachAsset('cornerBlockRight', {
		anchorX: 0.5,
		anchorY: 0.5,
		tint: 0x000000
	});
	// Track collision state for sound triggering
	self.lastIntersecting = false;
	self.update = function () {
		// Check collision with bouncing circle
		var currentIntersecting = self.intersects(bouncingCircle);
		if (!self.lastIntersecting && currentIntersecting) {
			// Collision just started - play random sound (C, A, or G)
			var sounds = ['c', 'a', 'g'];
			var randomSound = sounds[Math.floor(Math.random() * sounds.length)];
			LK.getSound(randomSound).play();
			var additionalSounds = ['q', 'w', 'e', 'r', 't'];
			var randomAdditionalSound = additionalSounds[Math.floor(Math.random() * additionalSounds.length)];
			LK.getSound(randomAdditionalSound).play();
			// Add expansion animation to bouncing circle
			tween(bouncingCircle, {
				scaleX: 1.5,
				scaleY: 1.5
			}, {
				duration: 200,
				easing: tween.easeOut,
				onFinish: function onFinish() {
					tween(bouncingCircle, {
						scaleX: 1,
						scaleY: 1
					}, {
						duration: 200,
						easing: tween.easeIn
					});
				}
			});
		}
		self.lastIntersecting = currentIntersecting;
	};
	return self;
});
var CornerBlockTop = Container.expand(function () {
	var self = Container.call(this);
	var blockGraphics = self.attachAsset('cornerBlockTop', {
		anchorX: 0.5,
		anchorY: 0.5,
		tint: 0x000000
	});
	// Track collision state for sound triggering
	self.lastIntersecting = false;
	self.update = function () {
		// Check collision with bouncing circle
		var currentIntersecting = self.intersects(bouncingCircle);
		if (!self.lastIntersecting && currentIntersecting) {
			// Collision just started - play random sound (C, A, or G)
			var sounds = ['c', 'a', 'g'];
			var randomSound = sounds[Math.floor(Math.random() * sounds.length)];
			LK.getSound(randomSound).play();
			var additionalSounds = ['q', 'w', 'e', 'r', 't'];
			var randomAdditionalSound = additionalSounds[Math.floor(Math.random() * additionalSounds.length)];
			LK.getSound(randomAdditionalSound).play();
			// Add expansion animation to bouncing circle
			tween(bouncingCircle, {
				scaleX: 1.5,
				scaleY: 1.5
			}, {
				duration: 200,
				easing: tween.easeOut,
				onFinish: function onFinish() {
					tween(bouncingCircle, {
						scaleX: 1,
						scaleY: 1
					}, {
						duration: 200,
						easing: tween.easeIn
					});
				}
			});
		}
		self.lastIntersecting = currentIntersecting;
	};
	return self;
});
var GreenBlock = Container.expand(function () {
	var self = Container.call(this);
	var blockGraphics = self.attachAsset('greenBlock', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	return self;
});
// Cache paddle constants
var Paddle = Container.expand(function () {
	var self = Container.call(this);
	var paddleGraphics = self.attachAsset('paddle', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	self.update = function () {
		// Prevent paddle from going through left wall
		if (self.x < PADDLE_HALF_WIDTH) {
			self.x = PADDLE_HALF_WIDTH;
		}
		// Prevent paddle from going through right wall
		if (self.x > SCREEN_WIDTH - PADDLE_HALF_WIDTH) {
			self.x = SCREEN_WIDTH - PADDLE_HALF_WIDTH;
		}
	};
	return self;
});
var PowerOrb = Container.expand(function () {
	var self = Container.call(this);
	var orbGraphics = self.attachAsset('powerOrb', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	// Fall downward
	self.velocityY = 8;
	self.update = function () {
		self.y += self.velocityY;
		// Remove if goes off screen
		if (self.y > 2800) {
			self.destroy();
			// Remove from powerOrbs array
			for (var i = powerOrbs.length - 1; i >= 0; i--) {
				if (powerOrbs[i] === self) {
					powerOrbs.splice(i, 1);
					break;
				}
			}
		}
	};
	return self;
});
var PurpleBlock = Container.expand(function () {
	var self = Container.call(this);
	var blockGraphics = self.attachAsset('purpleBlock', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	return self;
});
var RedBlock = Container.expand(function () {
	var self = Container.call(this);
	var blockGraphics = self.attachAsset('redBlock', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	return self;
});

/**** 
* Initialize Game
****/ 
var game = new LK.Game({
	backgroundColor: 0x000000
});

/**** 
* Game Code
****/ 
// Add scattered musical wave symbols across the background
var musicalWaves = [];
for (var i = 0; i < 20; i++) {
	var waveType = 'musicalWave' + (Math.floor(Math.random() * 4) + 1);
	var wave = game.addChild(LK.getAsset(waveType, {
		anchorX: 0.5,
		anchorY: 0.5,
		x: Math.random() * 2048,
		y: Math.random() * 2732,
		alpha: 0.3,
		rotation: Math.random() * Math.PI * 2
	}));
	musicalWaves.push(wave);
}
// Add scattered musical notes across the background
var musicalNotes = [];
for (var i = 0; i < 15; i++) {
	var noteType = 'musicalNote' + (Math.floor(Math.random() * 3) + 1);
	var note = game.addChild(LK.getAsset(noteType, {
		anchorX: 0.5,
		anchorY: 0.5,
		x: Math.random() * 2048,
		y: Math.random() * 2732,
		alpha: 0.25,
		rotation: Math.random() * Math.PI * 2
	}));
	musicalNotes.push(note);
}
// Add staff lines across the background
var staffLines = [];
for (var i = 0; i < 12; i++) {
	var staffType = 'staffLine' + (Math.floor(Math.random() * 3) + 1);
	var staff = game.addChild(LK.getAsset(staffType, {
		anchorX: 0.5,
		anchorY: 0.5,
		x: Math.random() * 2048,
		y: Math.random() * 2732,
		alpha: 0.2,
		rotation: Math.random() * Math.PI * 0.5
	}));
	staffLines.push(staff);
}
// Add treble clefs scattered in the background
var trebleClefs = [];
for (var i = 0; i < 8; i++) {
	var clef = game.addChild(LK.getAsset('trebleClef', {
		anchorX: 0.5,
		anchorY: 0.5,
		x: Math.random() * 2048,
		y: Math.random() * 2732,
		alpha: 0.15,
		rotation: Math.random() * Math.PI * 2
	}));
	trebleClefs.push(clef);
}
// Add scattered background circles
var backgroundCircles = [];
for (var i = 0; i < 40; i++) {
	var circleType = 'backgroundCircle' + (Math.floor(Math.random() * 6) + 1);
	var circle = game.addChild(LK.getAsset(circleType, {
		anchorX: 0.5,
		anchorY: 0.5,
		x: Math.random() * 2048,
		y: Math.random() * 2732,
		alpha: 0.1
	}));
	backgroundCircles.push(circle);
}
// Cache paddle constants
var PADDLE_HALF_WIDTH = 150;
var SCREEN_WIDTH = 2048;
var blocks = [];
var redBlocks = [];
var greenBlocks = [];
var purpleBlocks = [];
var powerOrbs = [];
var paddleCollisions = 0;
var bouncingCircle = game.addChild(new BouncingCircle());
bouncingCircle.x = 1024;
bouncingCircle.y = 2550; // Position above paddle
bouncingCircle.lastIntersecting = false;
var paddle = game.addChild(new Paddle());
paddle.x = 1024;
paddle.y = 2600;
game.move = function (x, y, obj) {
	paddle.x = x;
};
// Add corner block covering entire left side of screen
var cornerBlock = game.addChild(new CornerBlock());
cornerBlock.x = 10; // Position at left edge
cornerBlock.y = 1366; // Center vertically (half of 2732)
// Add corner block covering entire right side of screen
var cornerBlockRight = game.addChild(new CornerBlockRight());
cornerBlockRight.x = 2038; // Position at right edge
cornerBlockRight.y = 1366; // Center vertically (half of 2732)
// Add corner block covering entire top side of screen
var cornerBlockTop = game.addChild(new CornerBlockTop());
cornerBlockTop.x = 1024; // Center horizontally (half of 2048)
cornerBlockTop.y = 10; // Position at top edge
// Play background music
LK.playMusic('musica');
game.update = function () {
	// Track ball-paddle collision state transitions
	var currentIntersecting = bouncingCircle.intersects(paddle);
	if (!bouncingCircle.lastIntersecting && currentIntersecting) {
		// Collision just started - push ball above paddle and reverse Y velocity
		bouncingCircle.y = paddle.y - 20 - 25;
		bouncingCircle.velocityY = -Math.abs(bouncingCircle.velocityY);
		// Increment paddle collision counter
		paddleCollisions++;
		// Play random sound (C, A, or G)
		var sounds = ['c', 'a', 'g'];
		var randomSound = sounds[Math.floor(Math.random() * sounds.length)];
		LK.getSound(randomSound).play();
		var additionalSounds = ['q', 'w', 'e', 'r', 't'];
		var randomAdditionalSound = additionalSounds[Math.floor(Math.random() * additionalSounds.length)];
		LK.getSound(randomAdditionalSound).play();
		// Add expansion animation to bouncing circle
		tween(bouncingCircle, {
			scaleX: 1.5,
			scaleY: 1.5
		}, {
			duration: 200,
			easing: tween.easeOut,
			onFinish: function onFinish() {
				tween(bouncingCircle, {
					scaleX: 1,
					scaleY: 1
				}, {
					duration: 200,
					easing: tween.easeIn
				});
			}
		});
		// Only spawn blue blocks if paddle collisions are less than 10
		if (paddleCollisions < 10) {
			// Spawn new blue block at random position with minimum distance from other blocks
			var newBlock = game.addChild(new BlueBlock());
			var validPosition = false;
			var attempts = 0;
			while (!validPosition && attempts < 50) {
				newBlock.x = Math.random() * (2048 - 120) + 60; // Random X within screen bounds
				newBlock.y = Math.random() * 800 + 200; // Random Y in upper part of screen
				validPosition = true;
				// Check distance from all existing blue blocks
				for (var b = 0; b < blocks.length; b++) {
					var existingBlock = blocks[b];
					var dx = newBlock.x - existingBlock.x;
					var dy = newBlock.y - existingBlock.y;
					var distance = Math.sqrt(dx * dx + dy * dy);
					if (distance < 200) {
						// Minimum distance of 200 pixels
						validPosition = false;
						break;
					}
				}
				// Check distance from all existing red blocks
				for (var r = 0; r < redBlocks.length; r++) {
					var existingRedBlock = redBlocks[r];
					var dx = newBlock.x - existingRedBlock.x;
					var dy = newBlock.y - existingRedBlock.y;
					var distance = Math.sqrt(dx * dx + dy * dy);
					if (distance < 200) {
						// Minimum distance of 200 pixels
						validPosition = false;
						break;
					}
				}
				// Check distance from all existing green blocks
				for (var g = 0; g < greenBlocks.length; g++) {
					var existingGreenBlock = greenBlocks[g];
					var dx = newBlock.x - existingGreenBlock.x;
					var dy = newBlock.y - existingGreenBlock.y;
					var distance = Math.sqrt(dx * dx + dy * dy);
					if (distance < 200) {
						// Minimum distance of 200 pixels
						validPosition = false;
						break;
					}
				}
				// Check distance from all existing purple blocks
				for (var p = 0; p < purpleBlocks.length; p++) {
					var existingPurpleBlock = purpleBlocks[p];
					var dx = newBlock.x - existingPurpleBlock.x;
					var dy = newBlock.y - existingPurpleBlock.y;
					var distance = Math.sqrt(dx * dx + dy * dy);
					if (distance < 200) {
						// Minimum distance of 200 pixels
						validPosition = false;
						break;
					}
				}
				attempts++;
			}
			blocks.push(newBlock);
		}
	}
	bouncingCircle.lastIntersecting = currentIntersecting;
	// Check power orb collisions with paddle
	for (var k = powerOrbs.length - 1; k >= 0; k--) {
		var powerOrb = powerOrbs[k];
		if (powerOrb.intersects(paddle)) {
			// Increase ball speed
			var speedMultiplier = 1.5;
			bouncingCircle.velocityX *= speedMultiplier;
			bouncingCircle.velocityY *= speedMultiplier;
			// Visual feedback - flash ball green
			tween(bouncingCircle, {
				tint: 0x00ff00
			}, {
				duration: 200,
				onFinish: function onFinish() {
					tween(bouncingCircle, {
						tint: 0xffffff
					}, {
						duration: 200
					});
				}
			});
			// Remove power orb
			powerOrb.destroy();
			powerOrbs.splice(k, 1);
		}
	}
	// Check if ball hits bottom area (game over zone)
	if (bouncingCircle.y >= 2700) {
		LK.showGameOver();
		return;
	}
};

===================================================================
--- original.js
+++ change.js
@@ -819,14 +819,8 @@
 			powerOrb.destroy();
 			powerOrbs.splice(k, 1);
 		}
 	}
-	// Check win condition - all blocks destroyed
-	var totalBlocks = blocks.length + redBlocks.length + greenBlocks.length + purpleBlocks.length;
-	if (totalBlocks === 0) {
-		LK.showYouWin();
-		return;
-	}
 	// Check if ball hits bottom area (game over zone)
 	if (bouncingCircle.y >= 2700) {
 		LK.showGameOver();
 		return;