/**** 
* 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);
		// Explosion animation
		tween(monsterGraphics, {
			scaleX: 3,
			scaleY: 3,
			alpha: 0
		}, {
			duration: 1000,
			easing: tween.easeOut,
			onFinish: function onFinish() {
				// Start new episode instead of ending game
				startNewEpisode();
			}
		});
		// Flash screen
		LK.effects.flashScreen(0xffffff, 500);
	};
	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 = 1024;
pacman.y = 2000;
// 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;
// Track current episode
var currentEpisode = 1;
// Player lives
var playerLives = 3;
// Player score
var playerScore = 0;
// Game timer - 99 seconds at 60fps
var gameTimer = 99 * 60;
// Store spawn position
var spawnX = 1024;
var spawnY = 2000;
// 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);
				// Reset lives instead of game over when reaching 0
				if (playerLives <= 0) {
					playerLives = 3; // Reset to 3 lives
					livesText.setText('Lives: ' + playerLives);
					// Flash screen to indicate life reset
					LK.effects.flashScreen(0xffff00, 500);
				}
				// 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);
		// Reset lives instead of game over when reaching 0
		if (playerLives <= 0) {
			playerLives = 3; // Reset to 3 lives
			livesText.setText('Lives: ' + playerLives);
			// Flash screen to indicate life reset
			LK.effects.flashScreen(0xffff00, 500);
		}
		// 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);
// Create episode display
var episodeText = new Text2('Episode: ' + currentEpisode, {
	size: 80,
	fill: 0xFFFFFF
});
episodeText.anchor.set(0, 0);
episodeText.x = 150;
episodeText.y = 450;
LK.gui.topLeft.addChild(episodeText);
// Function to start new episode
function startNewEpisode() {
	// Increment episode
	currentEpisode++;
	episodeText.setText('Episode: ' + currentEpisode);
	// Check if player has completed all 10 episodes
	if (currentEpisode > 10) {
		// Player has won the game after completing episode 10
		LK.showYouWin();
		return;
	}
	// Reset monster hits
	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);
	}
	// Reset central monster
	centralMonster.destroy();
	centralMonster = game.addChild(new CentralMonster());
	centralMonster.x = 1024;
	centralMonster.y = 1366;
	centralMonster.startMovement();
	// Reset pacman position
	pacman.x = spawnX;
	pacman.y = spawnY;
	pacman.targetX = spawnX;
	pacman.targetY = spawnY;
	pacman.returningToSpawn = false;
	// Add bonus score for completing episode
	playerScore += 100;
	scoreText.setText('Score: ' + playerScore);
	// Reset timer for new episode
	gameTimer = 99 * 60;
	// Flash screen green for new episode
	LK.effects.flashScreen(0x00ff00, 500);
}
// Start monster movement
centralMonster.startMovement();
// Play the uploaded diver music
LK.playMusic('diver');
;
;

===================================================================
--- original.js
+++ change.js
@@ -616,8 +616,14 @@
 function startNewEpisode() {
 	// Increment episode
 	currentEpisode++;
 	episodeText.setText('Episode: ' + currentEpisode);
+	// Check if player has completed all 10 episodes
+	if (currentEpisode > 10) {
+		// Player has won the game after completing episode 10
+		LK.showYouWin();
+		return;
+	}
 	// Reset monster hits
 	monsterHits = 0;
 	// Clear all enemies
 	for (var i = enemies.length - 1; i >= 0; i--) {