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

/**** 
* Classes
****/ 
var Bubble = Container.expand(function () {
	var self = Container.call(this);
	var bubbleGraphics = self.attachAsset('collectible', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	// Random bubble size
	var size = 0.3 + Math.random() * 0.7;
	bubbleGraphics.scaleX = size;
	bubbleGraphics.scaleY = size;
	// Random bubble speed
	self.speed = 1 + Math.random() * 2;
	// Side drift
	self.drift = (Math.random() - 0.5) * 0.5;
	self.update = function () {
		// Move upward
		self.y -= self.speed;
		// Add slight horizontal drift
		self.x += self.drift;
		// Remove if off screen
		if (self.y < -50) {
			var bubbleIndex = bubbles.indexOf(self);
			if (bubbleIndex !== -1) {
				bubbles.splice(bubbleIndex, 1);
			}
			self.destroy();
		}
	};
	return self;
});
var Bullet = Container.expand(function () {
	var self = Container.call(this);
	var bulletGraphics = self.attachAsset('bullet', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	self.speed = 8;
	self.targetX = 0;
	self.targetY = 0;
	self.lastIntersecting = false;
	self.returningToSpawn = false;
	self.update = function () {
		// Move towards target
		var dx = self.targetX - self.x;
		var dy = self.targetY - self.y;
		var distance = Math.sqrt(dx * dx + dy * dy);
		if (distance > 5) {
			self.x += dx / distance * self.speed;
			self.y += dy / distance * self.speed;
		} else {
			// When reached target, destroy bullet instead of returning
			var bulletIndex = bullets.indexOf(self);
			if (bulletIndex !== -1) {
				bullets.splice(bulletIndex, 1);
			}
			self.destroy();
		}
		// Check intersection with central monster
		var currentIntersecting = self.intersects(centralMonster);
		if (!self.lastIntersecting && currentIntersecting) {
			// Hit the monster
			monsterHits++;
			centralMonster.grow();
			// Play monster hit sound
			LK.getSound('monsterhit').play();
			// Check if monster should explode after 10 hits
			if (monsterHits >= hitsToWin) {
				centralMonster.explode();
			}
			// Remove from bullets array
			var bulletIndex = bullets.indexOf(self);
			if (bulletIndex !== -1) {
				bullets.splice(bulletIndex, 1);
			}
			self.destroy();
		}
		self.lastIntersecting = currentIntersecting;
		// Check intersection with enemies
		for (var i = 0; i < enemies.length; i++) {
			var enemy = enemies[i];
			if (self.intersects(enemy)) {
				// Hit an enemy - destroy both bullet and enemy
				// Award 10 points for killing fish
				playerScore += 10;
				scoreText.setText('Score: ' + playerScore);
				// Play monster hit sound
				LK.getSound('monsterhit').play();
				enemy.destroy();
				enemies.splice(i, 1);
				// Remove bullet from bullets array
				var bulletIndex = bullets.indexOf(self);
				if (bulletIndex !== -1) {
					bullets.splice(bulletIndex, 1);
				}
				self.destroy();
				break; // Exit loop since bullet is destroyed
			}
		}
		// Remove if off screen
		if (self.x < -50 || self.x > 2098 || self.y < -50 || self.y > 2782) {
			// Remove from bullets array
			var bulletIndex = bullets.indexOf(self);
			if (bulletIndex !== -1) {
				bullets.splice(bulletIndex, 1);
			}
			self.destroy();
		}
	};
	return self;
});
var CentralMonster = Container.expand(function () {
	var self = Container.call(this);
	var monsterGraphics = self.attachAsset('centralMonster', {
		anchorX: 0.5,
		anchorY: 0.5,
		scaleX: 0.8,
		scaleY: 0.8
	});
	self.spawnTimer = 0;
	self.spawnInterval = 120; // Spawn every 2 seconds at 60fps
	self.armPositions = [{
		x: -250,
		y: -200
	},
	// Top left arm
	{
		x: 250,
		y: -200
	},
	// Top right arm
	{
		x: -300,
		y: 0
	},
	// Left arm
	{
		x: 300,
		y: 0
	},
	// Right arm
	{
		x: -250,
		y: 200
	},
	// Bottom left arm
	{
		x: 250,
		y: 200
	} // Bottom right arm
	];
	self.startMovement = function () {
		// Create continuous floating movement
		self.animateMovement();
	};
	self.animateMovement = function () {
		// Escape from Pacman - move away from him
		var dx = self.x - pacman.x;
		var dy = self.y - pacman.y;
		var distance = Math.sqrt(dx * dx + dy * dy);
		// If too close to Pacman, move away
		if (distance < 400) {
			// Normalize direction and move away
			dx = dx / distance;
			dy = dy / distance;
		} else {
			// Random movement when far enough
			dx = (Math.random() - 0.5) * 2;
			dy = (Math.random() - 0.5) * 2;
		}
		// Calculate new position (escape direction)
		var newX = self.x + dx * (200 + Math.random() * 200);
		var newY = self.y + dy * (200 + Math.random() * 200);
		// Keep within screen bounds
		newX = Math.max(200, Math.min(1848, newX));
		newY = Math.max(200, Math.min(2532, newY));
		tween(self, {
			x: newX,
			y: newY
		}, {
			duration: 1500 + Math.random() * 500,
			easing: tween.easeInOut,
			onFinish: function onFinish() {
				self.animateMovement(); // Continue movement
			}
		});
		// Add rotation animation
		tween(self, {
			rotation: self.rotation + (Math.random() - 0.5) * 0.5
		}, {
			duration: 1500 + Math.random() * 1000,
			easing: tween.easeInOut
		});
	};
	self.update = function () {
		self.spawnTimer++;
		// Spawn enemies from arms
		if (self.spawnTimer >= self.spawnInterval) {
			self.spawnTimer = 0;
			self.spawnEnemy();
		}
	};
	self.spawnEnemy = function () {
		// Pick random arm position
		var armIndex = Math.floor(Math.random() * self.armPositions.length);
		var armPos = self.armPositions[armIndex];
		// Create enemy at arm position (relative to monster)
		var enemy = new Enemy();
		enemy.x = self.x + armPos.x;
		enemy.y = self.y + armPos.y;
		// Store spawn position for reference
		enemy.spawnX = enemy.x;
		enemy.spawnY = enemy.y;
		// Randomly decide if this enemy should follow player or not
		enemy.shouldFollowPlayer = Math.random() < 0.5; // 50% chance
		// Enemy will follow Pacman automatically in its update method
		enemies.push(enemy);
		game.addChild(enemy);
		// Add spawn effect
		enemy.alpha = 0;
		tween(enemy, {
			alpha: 1,
			scaleX: 0.3,
			scaleY: 0.3
		}, {
			duration: 500,
			easing: tween.easeOut
		});
	};
	self.grow = function () {
		// Increase monster size
		var newScale = monsterGraphics.scaleX + 0.1;
		tween(monsterGraphics, {
			scaleX: newScale,
			scaleY: newScale
		}, {
			duration: 300,
			easing: tween.easeOut
		});
		// Flash effect when hit
		tween(monsterGraphics, {
			tint: 0xff0000
		}, {
			duration: 100,
			onFinish: function onFinish() {
				tween(monsterGraphics, {
					tint: 0xffffff
				}, {
					duration: 100
				});
			}
		});
	};
	self.explode = function () {
		// Stop all movement
		tween.stop(self);
		// Award bonus score for defeating monster
		playerScore += 100;
		scoreText.setText('Score: ' + playerScore);
		// Flash screen
		LK.effects.flashScreen(0xffffff, 500);
		// Show game win when monster dies
		LK.showYouWin();
	};
	return self;
});
// Create central monster
var Enemy = Container.expand(function () {
	var self = Container.call(this);
	var enemyGraphics = self.attachAsset('enemy', {
		anchorX: 0.5,
		anchorY: 0.5,
		scaleX: 0.3,
		scaleY: 0.3
	});
	self.speed = 2;
	self.targetX = 0;
	self.targetY = 0;
	self.lastX = 0;
	self.lastY = 0;
	self.directionChangeTimer = 0;
	self.directionChangeInterval = 60 + Math.random() * 60; // Random direction changes
	self.isChangingDirection = false;
	self.update = function () {
		self.lastX = self.x;
		self.lastY = self.y;
		// Check if this enemy should follow the player
		if (self.shouldFollowPlayer) {
			// Follow player behavior - move towards Pacman
			var dx = pacman.x - self.x;
			var dy = pacman.y - self.y;
			var distance = Math.sqrt(dx * dx + dy * dy);
			if (distance > 0) {
				// Move towards Pacman
				var direction = Math.min(1, self.speed / distance);
				self.x += dx * direction;
				self.y += dy * direction;
			}
		} else {
			// Random movement behavior
			// Direction change timer
			self.directionChangeTimer++;
			if (self.directionChangeTimer >= self.directionChangeInterval && !self.isChangingDirection) {
				self.directionChangeTimer = 0;
				self.directionChangeInterval = 60 + Math.random() * 60;
				self.isChangingDirection = true;
				// Simple left/right movement only
				var swimmingDirection = Math.random() > 0.5 ? 1 : -1; // Left or right
				var swimDistance = 200 + Math.random() * 300; // Random swim distance
				var tempTargetX = self.x + swimmingDirection * swimDistance;
				// Keep within bounds
				tempTargetX = Math.max(100, Math.min(1948, tempTargetX));
				// Smooth horizontal movement only
				tween(self, {
					x: tempTargetX
				}, {
					duration: 1000 + Math.random() * 500,
					easing: tween.easeInOut,
					onFinish: function onFinish() {
						self.isChangingDirection = false;
					}
				});
			}
			// Move towards Pacman horizontally only when not changing direction
			if (!self.isChangingDirection) {
				var dx = pacman.x - self.x;
				var distance = Math.abs(dx);
				if (distance > 0) {
					// Move horizontally towards Pacman
					var direction = dx > 0 ? 1 : -1;
					self.x += direction * self.speed;
				}
			}
		}
		// Keep enemies within screen bounds instead of destroying them
		if (self.x < 100) self.x = 100;
		if (self.x > 1948) self.x = 1948;
		if (self.y < 100) self.y = 100;
		if (self.y > 2632) self.y = 2632;
	};
	return self;
});
var Pacman = Container.expand(function () {
	var self = Container.call(this);
	var pacmanGraphics = self.attachAsset('pacman', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	self.speed = 5;
	self.targetX = 0;
	self.targetY = 0;
	self.returningToSpawn = false;
	self.update = function () {
		// Move towards target position
		var dx = self.targetX - self.x;
		var dy = self.targetY - self.y;
		var distance = Math.sqrt(dx * dx + dy * dy);
		if (distance > 10) {
			self.x += dx / distance * self.speed;
			self.y += dy / distance * self.speed;
		} else {
			// When reached target, start returning to spawn after a delay
			if (!self.returningToSpawn) {
				self.returningToSpawn = true;
				LK.setTimeout(function () {
					tween(self, {
						x: spawnX,
						y: spawnY
					}, {
						duration: 2000,
						easing: tween.easeInOut,
						onFinish: function onFinish() {
							self.returningToSpawn = false;
						}
					});
				}, 1000);
			}
		}
	};
	return self;
});

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

/**** 
* Game Code
****/ 
// Add sea background
var seaBackground = game.addChild(LK.getAsset('seaBackground', {
	anchorX: 0,
	anchorY: 0,
	x: 0,
	y: 0
}));
// Create Pacman character
var pacman = game.addChild(new Pacman());
pacman.x = 200;
pacman.y = 200;
// Create central monster
var centralMonster = game.addChild(new CentralMonster());
centralMonster.x = 1024;
centralMonster.y = 1366;
// Array to track enemies
var enemies = [];
// Array to track bullets
var bullets = [];
// Array to track bubbles
var bubbles = [];
// Bubble spawn timer
var bubbleSpawnTimer = 0;
// Track monster hits
var monsterHits = 0;
var hitsToWin = 10;
// Level tracking removed - continuous gameplay
// Player lives
var playerLives = 3;
// Player score
var playerScore = 0;
// Game timer - 99 seconds at 60fps
var gameTimer = 99 * 60;
// Store spawn position - start from top-left corner
var spawnX = 200;
var spawnY = 200;
// Touch controls for Pacman movement and shooting
game.down = function (x, y, obj) {
	pacman.targetX = x;
	pacman.targetY = y;
	// Calculate angle from Pacman to target and rotate Pacman
	var dx = x - pacman.x;
	var dy = y - pacman.y;
	var angle = Math.atan2(dy, dx);
	// Rotate Pacman to face the firing direction
	tween(pacman, {
		rotation: angle
	}, {
		duration: 200,
		easing: tween.easeOut
	});
	// Create bullet towards touch position
	var bullet = new Bullet();
	bullet.x = pacman.x;
	bullet.y = pacman.y;
	bullet.targetX = x;
	bullet.targetY = y;
	bullets.push(bullet);
	game.addChild(bullet);
	// Play bubble sound effect
	LK.getSound('bubble').play();
};
game.move = function (x, y, obj) {
	pacman.targetX = x;
	pacman.targetY = y;
};
// Game update loop
game.update = function () {
	// Update bullets
	for (var i = bullets.length - 1; i >= 0; i--) {
		var bullet = bullets[i];
		if (bullet.parent) {
			// Bullet is still active
		} else {
			// Bullet was destroyed, remove from array
			bullets.splice(i, 1);
		}
	}
	// Update enemies
	for (var j = enemies.length - 1; j >= 0; j--) {
		var enemy = enemies[j];
		if (enemy.parent) {
			// Check collision with player
			if (enemy.intersects(pacman)) {
				// Player hit by enemy
				playerLives--;
				livesText.setText('Lives: ' + playerLives);
				// Flash effect on hit
				LK.effects.flashScreen(0xff0000, 300);
				// End game when lives reach 0
				if (playerLives <= 0) {
					LK.showGameOver();
					return;
				}
				// Remove enemy that hit player
				enemy.destroy();
				enemies.splice(j, 1);
				continue;
			}
		} else {
			// Enemy was destroyed, remove from array
			enemies.splice(j, 1);
		}
	}
	// Check collision with central monster
	if (centralMonster.intersects(pacman)) {
		// Player hit by central monster
		playerLives--;
		livesText.setText('Lives: ' + playerLives);
		// Flash effect on hit
		LK.effects.flashScreen(0xff0000, 300);
		// End game when lives reach 0
		if (playerLives <= 0) {
			LK.showGameOver();
			return;
		}
		// Push player away from monster
		var dx = pacman.x - centralMonster.x;
		var dy = pacman.y - centralMonster.y;
		var distance = Math.sqrt(dx * dx + dy * dy);
		if (distance > 0) {
			pacman.x += dx / distance * 100;
			pacman.y += dy / distance * 100;
		}
	}
	// Update game timer
	gameTimer--;
	var secondsLeft = Math.ceil(gameTimer / 60);
	timerText.setText('Time: ' + secondsLeft);
	// Reset timer instead of game over when time is up
	if (gameTimer <= 0) {
		gameTimer = 99 * 60; // Reset to 99 seconds
		timerText.setText('Time: 99');
		// Flash screen to indicate timer reset
		LK.effects.flashScreen(0xff8800, 500);
	}
	// Spawn bubbles
	bubbleSpawnTimer++;
	if (bubbleSpawnTimer >= 15) {
		// Spawn every 15 frames (4 times per second)
		bubbleSpawnTimer = 0;
		// Create new bubble at random position at bottom
		var bubble = new Bubble();
		bubble.x = Math.random() * 2048;
		bubble.y = 2732 + 50; // Start below screen
		bubbles.push(bubble);
		game.addChild(bubble);
		// Add floating animation with tween
		tween(bubble, {
			alpha: 0.7,
			scaleX: bubble.scaleX * 1.2,
			scaleY: bubble.scaleY * 1.2
		}, {
			duration: 2000 + Math.random() * 3000,
			easing: tween.easeInOut
		});
	}
	// Update bubbles
	for (var k = bubbles.length - 1; k >= 0; k--) {
		var bubble = bubbles[k];
		if (!bubble.parent) {
			// Bubble was destroyed, remove from array
			bubbles.splice(k, 1);
		}
	}
};
// Create lives display
var livesText = new Text2('Lives: ' + playerLives, {
	size: 80,
	fill: 0xFFFFFF
});
livesText.anchor.set(0, 0);
livesText.x = 150;
livesText.y = 150;
LK.gui.topLeft.addChild(livesText);
// Create score display
var scoreText = new Text2('Score: ' + playerScore, {
	size: 80,
	fill: 0xFFFFFF
});
scoreText.anchor.set(0, 0);
scoreText.x = 150;
scoreText.y = 250;
LK.gui.topLeft.addChild(scoreText);
// Create timer display
var timerText = new Text2('Time: 99', {
	size: 80,
	fill: 0xFFFFFF
});
timerText.anchor.set(0, 0);
timerText.x = 150;
timerText.y = 350;
LK.gui.topLeft.addChild(timerText);
// Level display removed - no longer needed
// startNewLevel function removed - continuous gameplay
// Start monster movement
centralMonster.startMovement();
// Play the uploaded diver music
LK.playMusic('diver');

===================================================================
--- original.js
+++ change.js
@@ -260,36 +260,15 @@
 	};
 	self.explode = function () {
 		// Stop all movement
 		tween.stop(self);
-		// Restore Pacman's health when monster dies
-		playerLives = 3;
-		livesText.setText('Lives: ' + playerLives);
-		// Reset monster hits for continuous gameplay
-		monsterHits = 0;
-		// Clear all enemies
-		for (var i = enemies.length - 1; i >= 0; i--) {
-			enemies[i].destroy();
-			enemies.splice(i, 1);
-		}
-		// Clear all bullets
-		for (var j = bullets.length - 1; j >= 0; j--) {
-			bullets[j].destroy();
-			bullets.splice(j, 1);
-		}
 		// Award bonus score for defeating monster
 		playerScore += 100;
 		scoreText.setText('Score: ' + playerScore);
-		// Reset monster scale and restart movement
-		monsterGraphics.scaleX = 0.8;
-		monsterGraphics.scaleY = 0.8;
-		monsterGraphics.alpha = 1;
 		// Flash screen
 		LK.effects.flashScreen(0xffffff, 500);
-		// Restart movement after a short delay
-		LK.setTimeout(function () {
-			self.startMovement();
-		}, 1000);
+		// Show game win when monster dies
+		LK.showYouWin();
 	};
 	return self;
 });
 // Create central monster