/**** 
* 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();
				// Update blue blocks score
				blueBlocksScore++;
				blueScoreText.setText('Blue: ' + blueBlocksScore);
				// 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();
				// Update red blocks score
				redBlocksScore++;
				redScoreText.setText('Red: ' + redBlocksScore);
				// 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();
				// Update green blocks score
				greenBlocksScore++;
				greenScoreText.setText('Green: ' + greenBlocksScore);
				// 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();
				// Update purple blocks score
				purpleBlocksScore++;
				purpleScoreText.setText('Purple: ' + purpleBlocksScore);
				// 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 blueBlocksScore = 0;
var redBlocksScore = 0;
var greenBlocksScore = 0;
var purpleBlocksScore = 0;
var paddleCollisions = 0;
// Create score text for blue blocks
var blueScoreText = new Text2('Blue: 0', {
	size: 60,
	fill: 0x0066CC
});
blueScoreText.anchor.set(0.5, 0);
LK.gui.top.addChild(blueScoreText);
blueScoreText.x = -200;
blueScoreText.y = 60;
// Create score text for red blocks
var redScoreText = new Text2('Red: 0', {
	size: 60,
	fill: 0xFF0000
});
redScoreText.anchor.set(0.5, 0);
LK.gui.top.addChild(redScoreText);
redScoreText.x = 200;
redScoreText.y = 60;
// Create score text for green blocks
var greenScoreText = new Text2('Green: 0', {
	size: 60,
	fill: 0x00FF00
});
greenScoreText.anchor.set(0.5, 0);
LK.gui.top.addChild(greenScoreText);
greenScoreText.x = -200;
greenScoreText.y = 120;
// Create score text for purple blocks
var purpleScoreText = new Text2('Purple: 0', {
	size: 60,
	fill: 0x8000FF
});
purpleScoreText.anchor.set(0.5, 0);
LK.gui.top.addChild(purpleScoreText);
purpleScoreText.x = 200;
purpleScoreText.y = 120;
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
@@ -87,8 +87,32 @@
 							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
@@ -134,8 +158,67 @@
 							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;
@@ -149,8 +232,155 @@
 				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();
+				// Update green blocks score
+				greenBlocksScore++;
+				greenScoreText.setText('Green: ' + greenBlocksScore);
+				// 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();
+				// Update purple blocks score
+				purpleBlocksScore++;
+				purpleScoreText.setText('Purple: ' + purpleBlocksScore);
+				// 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;
@@ -295,8 +525,16 @@
 		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', {
@@ -338,8 +576,16 @@
 		}
 	};
 	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,
@@ -430,11 +676,15 @@
 var PADDLE_HALF_WIDTH = 150;
 var SCREEN_WIDTH = 2048;
 var blocks = [];
 var redBlocks = [];
+var greenBlocks = [];
+var purpleBlocks = [];
 var powerOrbs = [];
 var blueBlocksScore = 0;
 var redBlocksScore = 0;
+var greenBlocksScore = 0;
+var purpleBlocksScore = 0;
 var paddleCollisions = 0;
 // Create score text for blue blocks
 var blueScoreText = new Text2('Blue: 0', {
 	size: 60,
@@ -452,8 +702,26 @@
 redScoreText.anchor.set(0.5, 0);
 LK.gui.top.addChild(redScoreText);
 redScoreText.x = 200;
 redScoreText.y = 60;
+// Create score text for green blocks
+var greenScoreText = new Text2('Green: 0', {
+	size: 60,
+	fill: 0x00FF00
+});
+greenScoreText.anchor.set(0.5, 0);
+LK.gui.top.addChild(greenScoreText);
+greenScoreText.x = -200;
+greenScoreText.y = 120;
+// Create score text for purple blocks
+var purpleScoreText = new Text2('Purple: 0', {
+	size: 60,
+	fill: 0x8000FF
+});
+purpleScoreText.anchor.set(0.5, 0);
+LK.gui.top.addChild(purpleScoreText);
+purpleScoreText.x = 200;
+purpleScoreText.y = 120;
 var bouncingCircle = game.addChild(new BouncingCircle());
 bouncingCircle.x = 1024;
 bouncingCircle.y = 2550; // Position above paddle
 bouncingCircle.lastIntersecting = false;
@@ -543,8 +811,32 @@
 						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);
 		}