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

/**** 
* Classes
****/ 
var AIPlayer = Container.expand(function (playerIndex) {
	var self = Container.call(this);
	var playerGraphics = self.attachAsset('player', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	// Different tints for each AI player
	var playerColors = [0xFFFF00, 0xFF00FF, 0x00FFFF]; // Yellow, Magenta, Cyan
	playerGraphics.tint = playerColors[playerIndex % 3];
	// Add number display for each AI player with different numbers (not 456)
	var playerNumbers = ['123', '789', '321']; // Different numbers for each AI player
	var numberText = new Text2(playerNumbers[playerIndex], {
		size: 40,
		fill: 0x000000 // Black text
	});
	numberText.anchor.set(0.5, 0.5);
	numberText.x = 0;
	numberText.y = 0;
	self.addChild(numberText);
	self.targetX = 0;
	self.targetY = 0;
	self.isMoving = false;
	self.health = 3;
	self.moveTimer = 0;
	self.nextMoveTime = Math.random() * 120 + 60; // Random 1-3 seconds
	self.playerIndex = playerIndex;
	// AI Personality traits
	var personalityTypes = ['cowardly', 'fast', 'cautious'];
	self.personality = personalityTypes[playerIndex % 3];
	self.riskLevel = 0; // Track current risk assessment
	self.safetyTimer = 0; // Time since last risky action
	self.panicMode = false; // Emergency state for cowardly AI
	self.moveTo = function (x, y) {
		// Calculate distance from current position
		var dx = x - self.x;
		var dy = y - self.y;
		var distance = Math.sqrt(dx * dx + dy * dy);
		// Personality-based movement adjustments
		var maxDistance = 180;
		var moveDuration = 350;
		var animationDuration = 150;
		if (self.personality === 'cowardly') {
			// Cowardly AI: smaller, more cautious movements
			maxDistance = self.panicMode ? 80 : 120;
			moveDuration = 450; // Slower movement
		} else if (self.personality === 'fast') {
			// Fast AI: larger, quicker movements
			maxDistance = 220;
			moveDuration = 250; // Faster movement
			animationDuration = 100; // Quicker animation
		} else if (self.personality === 'cautious') {
			// Cautious AI: moderate but calculated movements
			maxDistance = self.riskLevel > 5 ? 100 : 160;
			moveDuration = 380;
		}
		if (distance > maxDistance) {
			// Scale down the movement to fit within max distance
			var scale = maxDistance / distance;
			x = self.x + dx * scale;
			y = self.y + dy * scale;
		}
		self.targetX = x;
		self.targetY = y;
		self.isMoving = true;
		// Personality-based animation variations
		var scaleVariation = 0.9;
		var rotationVariation = 0.1;
		if (self.personality === 'fast') {
			scaleVariation = 0.8; // More dramatic scaling
			rotationVariation = 0.15;
		} else if (self.personality === 'cowardly') {
			scaleVariation = 0.95; // Less dramatic scaling
			rotationVariation = 0.05;
		}
		// Add walking animation
		tween(playerGraphics, {
			scaleX: scaleVariation,
			scaleY: 1.1,
			rotation: rotationVariation
		}, {
			duration: animationDuration,
			easing: tween.easeInOut
		});
		tween(self, {
			x: x,
			y: y
		}, {
			duration: moveDuration,
			easing: tween.easeOut,
			onFinish: function onFinish() {
				self.isMoving = false;
				// Reset player graphics to normal state after movement
				tween(playerGraphics, {
					scaleX: 1,
					scaleY: 1,
					rotation: 0
				}, {
					duration: animationDuration,
					easing: tween.easeOut
				});
			}
		});
	};
	self.takeDamage = function () {
		self.health--;
		LK.effects.flashObject(self, 0xFF0000, 500);
		LK.getSound('caught').play();
		if (self.health <= 0) {
			// AI player is eliminated but game continues
			self.visible = false;
			self.isMoving = false;
		}
	};
	self.update = function () {
		// Update personality-specific timers and states
		self.safetyTimer++;
		if (self.personality === 'cowardly' && self.health < 3) {
			self.panicMode = true;
		}
		// Only move if alive and singer is facing away
		if (self.health > 0 && !self.isMoving && singer.facingAway) {
			self.moveTimer++;
			// Personality-based timing adjustments
			var moveThreshold = self.nextMoveTime;
			if (self.personality === 'cowardly') {
				// Cowardly AI waits longer and is more hesitant
				moveThreshold = self.panicMode ? self.nextMoveTime * 0.7 : self.nextMoveTime * 1.5;
			} else if (self.personality === 'fast') {
				// Fast AI moves more frequently
				moveThreshold = self.nextMoveTime * 0.6;
			} else if (self.personality === 'cautious') {
				// Cautious AI timing depends on risk level
				moveThreshold = self.nextMoveTime * (1 + self.riskLevel * 0.1);
			}
			if (self.moveTimer >= moveThreshold) {
				var targetX, targetY;
				var validMove = false;
				var attempts = 0;
				var maxAttempts = 10;
				while (!validMove && attempts < maxAttempts) {
					if (self.personality === 'cowardly') {
						// Cowardly AI: small, safe movements, prefers staying back
						if (self.panicMode) {
							// In panic mode, try to move away from singer
							targetX = self.x + (Math.random() - 0.5) * 150;
							targetY = self.y + Math.random() * 100 + 20; // Move away from win line
						} else {
							// Normal cowardly behavior: very small forward movements
							targetX = self.x + (Math.random() - 0.5) * 200;
							targetY = self.y - Math.random() * 80 - 20;
						}
					} else if (self.personality === 'fast') {
						// Fast AI: aggressive movements towards win line
						targetX = self.x + (Math.random() - 0.5) * 400;
						targetY = self.y - Math.random() * 200 - 80;
					} else if (self.personality === 'cautious') {
						// Cautious AI: calculated movements, avoids risky areas
						var forwardness = Math.max(50, 120 - self.riskLevel * 15);
						targetX = self.x + (Math.random() - 0.5) * 250;
						targetY = self.y - Math.random() * forwardness - 30;
					}
					// Keep within bounds
					targetX = Math.max(200, Math.min(1848, targetX));
					targetY = Math.max(500, targetY);
					// Enhanced obstacle avoidance with personality considerations
					validMove = true;
					var obstacleRiskCount = 0;
					for (var i = 0; i < obstacles.length; i++) {
						var obstacle = obstacles[i];
						var dx = targetX - obstacle.x;
						var dy = targetY - obstacle.y;
						var distance = Math.sqrt(dx * dx + dy * dy);
						// Personality-based safety margins
						var safetyMargin = 100;
						if (self.personality === 'cowardly') {
							safetyMargin = 150; // Larger safety margin
						} else if (self.personality === 'fast') {
							safetyMargin = 80; // Smaller safety margin, more risk-taking
						} else if (self.personality === 'cautious') {
							safetyMargin = 120; // Moderate safety margin
						}
						if (distance < safetyMargin) {
							if (self.personality === 'cautious') {
								obstacleRiskCount++;
							}
							validMove = false;
							break;
						}
					}
					// Update risk level for cautious AI
					if (self.personality === 'cautious') {
						self.riskLevel = Math.max(0, self.riskLevel + obstacleRiskCount - 1);
						if (self.safetyTimer > 300) {
							// Reset risk after 5 seconds of safety
							self.riskLevel = Math.max(0, self.riskLevel - 1);
							self.safetyTimer = 0;
						}
					}
					attempts++;
				}
				if (validMove) {
					self.moveTo(targetX, targetY);
					if (self.personality === 'cautious') {
						self.safetyTimer = 0; // Reset safety timer on movement
					}
				}
				self.moveTimer = 0;
				// Personality-based next move timing
				if (self.personality === 'cowardly') {
					self.nextMoveTime = Math.random() * 180 + 120; // 2-5 seconds, more cautious
				} else if (self.personality === 'fast') {
					self.nextMoveTime = Math.random() * 60 + 30; // 0.5-1.5 seconds, very aggressive
				} else if (self.personality === 'cautious') {
					self.nextMoveTime = Math.random() * 120 + 80; // 1.3-3.3 seconds, measured
				}
			}
		}
	};
	return self;
});
var Obstacle = Container.expand(function (assetId) {
	var self = Container.call(this);
	var obstacleGraphics = self.attachAsset(assetId || 'obstacle1', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	// Add trigger point visualization
	var triggerPoint = self.attachAsset('triggerPoint', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	triggerPoint.alpha = 0; // Make it completely invisible
	triggerPoint.x = 0; // Center it horizontally on the obstacle
	triggerPoint.y = obstacleGraphics.height / 2 + 5; // Position 5 pixels below bottom center
	// 30% chance this obstacle can melt
	self.canMelt = Math.random() < 0.3;
	// Random chance (50%) this obstacle can move the character
	self.canMoveCharacter = Math.random() < 0.5;
	// Set trigger point color to green for meltable obstacles
	if (self.canMelt) {
		triggerPoint.tint = 0x00ff00; // Green color for meltable obstacles
	}
	self.isPlayerOnTrigger = false;
	self.lastPlayerOnTrigger = false;
	self.triggerTimer = 0;
	self.melted = false;
	self.lastPlayerColliding = false;
	// Store reference to trigger point for collision detection
	self.triggerPoint = triggerPoint;
	return self;
});
var Player = Container.expand(function () {
	var self = Container.call(this);
	var playerGraphics = self.attachAsset('player', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	// Apply blue tint to main player to differentiate from AI players
	playerGraphics.tint = 0x0000FF; // Blue color for main player
	// Add number display for main player showing 456
	var numberText = new Text2('456', {
		size: 40,
		fill: 0x000000 // Black text
	});
	numberText.anchor.set(0.5, 0.5);
	numberText.x = 0;
	numberText.y = 0;
	self.addChild(numberText);
	self.targetX = 0;
	self.targetY = 0;
	self.isMoving = false;
	self.health = 3;
	self.moveTo = function (x, y) {
		// Calculate distance from current position
		var dx = x - self.x;
		var dy = y - self.y;
		var distance = Math.sqrt(dx * dx + dy * dy);
		// Limit maximum movement distance to 200 pixels
		var maxDistance = 200;
		if (distance > maxDistance) {
			// Scale down the movement to fit within max distance
			var scale = maxDistance / distance;
			x = self.x + dx * scale;
			y = self.y + dy * scale;
		}
		self.targetX = x;
		self.targetY = y;
		self.isMoving = true;
		// Add walking animation - slight scaling and rotation
		tween(playerGraphics, {
			scaleX: 0.9,
			scaleY: 1.1,
			rotation: 0.1
		}, {
			duration: 150,
			easing: tween.easeInOut
		});
		tween(self, {
			x: x,
			y: y
		}, {
			duration: 300,
			easing: tween.easeOut,
			onFinish: function onFinish() {
				self.isMoving = false;
				// Reset player graphics to normal state after movement
				tween(playerGraphics, {
					scaleX: 1,
					scaleY: 1,
					rotation: 0
				}, {
					duration: 150,
					easing: tween.easeOut
				});
			}
		});
	};
	self.takeDamage = function () {
		self.health--;
		LK.effects.flashObject(self, 0xFF0000, 500);
		LK.getSound('caught').play();
		if (self.health <= 0) {
			LK.showGameOver();
		}
	};
	return self;
});
var Singer = Container.expand(function () {
	var self = Container.call(this);
	var singerAwayGraphics = self.attachAsset('singerAway', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	var singerLookingGraphics = self.attachAsset('singerLooking', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	singerLookingGraphics.visible = false; // Start with looking image hidden
	self.facingAway = true;
	self.turnTimer = 0;
	self.nextTurnTime = 180; // 3 seconds at 60fps
	self.lookingTime = 0;
	self.maxLookingTime = 120; // 2 seconds looking
	self.update = function () {
		self.turnTimer++;
		if (self.facingAway) {
			// Singer is facing away, count down to turn around
			if (self.turnTimer >= self.nextTurnTime) {
				self.turnAround();
			}
		} else {
			// Singer is looking, count down to face away again
			self.lookingTime++;
			if (self.lookingTime >= self.maxLookingTime) {
				self.faceAway();
			}
		}
	};
	self.turnAround = function () {
		self.facingAway = false;
		self.lookingTime = 0;
		// Switch to looking image
		singerAwayGraphics.visible = false;
		singerLookingGraphics.visible = true;
		LK.getSound('turn').play();
		// Start playing looping music when looking up
		LK.playMusic('singerLookingMusic');
		// Check if player is moving and apply damage
		if (player.isMoving) {
			player.takeDamage();
		}
	};
	self.faceAway = function () {
		self.facingAway = true;
		self.turnTimer = 0;
		self.nextTurnTime = Math.random() * 180 + 120; // Random 2-5 seconds
		// Switch to away image
		singerAwayGraphics.visible = true;
		singerLookingGraphics.visible = false;
		// Stop music when facing away
		LK.stopMusic();
		// Play 'song' audio file on loop when facing away
		LK.getSound('song').play();
	};
	return self;
});

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

/**** 
* Game Code
****/ 
// Create win line at top
var winLine = game.addChild(LK.getAsset('winLine', {
	anchorX: 0.5,
	anchorY: 0.5
}));
winLine.x = 2048 / 2;
winLine.y = 450;
// Create singer at top
var singer = game.addChild(new Singer());
singer.x = 2048 / 2;
singer.y = 300;
// Start playing 'song' audio since singer starts facing away
LK.getSound('song').play();
// Create player at bottom
var player = game.addChild(new Player());
player.x = 2048 / 2;
player.y = 2400;
player.targetX = player.x;
player.targetY = player.y;
// Create 3 AI players for competition
var aiPlayers = [];
var startPositions = [{
	x: 2048 / 2 - 300,
	y: 2400
},
// Left of main player
{
	x: 2048 / 2 + 300,
	y: 2400
},
// Right of main player  
{
	x: 2048 / 2,
	y: 2350
} // Behind main player
];
for (var ai = 0; ai < 3; ai++) {
	var aiPlayer = game.addChild(new AIPlayer(ai));
	aiPlayer.x = startPositions[ai].x;
	aiPlayer.y = startPositions[ai].y;
	aiPlayer.targetX = aiPlayer.x;
	aiPlayer.targetY = aiPlayer.y;
	aiPlayers.push(aiPlayer);
}
// Create obstacles
var obstacles = [];
// Generate 20 obstacles using different assets
var obstacleAssets = ['obstacle1', 'obstacle2', 'obstacle3', 'obstacle4', 'obstacle5', 'obstacle6', 'obstacle7', 'obstacle8', 'obstacle9', 'obstacle10', 'obstacle11', 'obstacle12', 'obstacle13', 'obstacle14', 'obstacle15', 'obstacle16', 'obstacle17', 'obstacle18', 'obstacle19', 'obstacle20'];
// Function to check if a position is too close to existing obstacles
function isPositionValid(x, y, minDistance) {
	for (var j = 0; j < obstacles.length; j++) {
		var existingObstacle = obstacles[j];
		var dx = x - existingObstacle.x;
		var dy = y - existingObstacle.y;
		var distance = Math.sqrt(dx * dx + dy * dy);
		if (distance < minDistance) {
			return false;
		}
	}
	return true;
}
for (var i = 0; i < 20; i++) {
	var obstacle = game.addChild(new Obstacle(obstacleAssets[i]));
	var validPosition = false;
	var attempts = 0;
	var maxAttempts = 100; // Prevent infinite loops
	var minSpacing = 250; // Minimum distance between obstacles
	// Try to find a valid position
	while (!validPosition && attempts < maxAttempts) {
		// Random x position between 200 and 1800 (avoiding edges)
		var newX = Math.random() * 1600 + 200;
		// Random y position between 600 and 2200 (between singer area and player start)
		var newY = Math.random() * 1600 + 600;
		if (isPositionValid(newX, newY, minSpacing)) {
			obstacle.x = newX;
			obstacle.y = newY;
			validPosition = true;
		}
		attempts++;
	}
	// If we couldn't find a valid position after max attempts, place it anyway
	// but try to space it out from the center
	if (!validPosition) {
		obstacle.x = Math.random() * 1600 + 200;
		obstacle.y = Math.random() * 1600 + 600;
	}
	obstacles.push(obstacle);
}
// Create health display
var healthTxt = new Text2('Health: 3', {
	size: 60,
	fill: 0xFFFFFF
});
healthTxt.anchor.set(0, 0);
LK.gui.topRight.addChild(healthTxt);
// Create countdown timer display
var countdownTxt = new Text2('180', {
	size: 80,
	fill: 0xFFFFFF
});
countdownTxt.anchor.set(0.5, 0);
LK.gui.top.addChild(countdownTxt);
// Game state
var pendingMove = null;
var moveDelay = 15; // 0.25 seconds at 60fps
var delayTimer = 0;
// Countdown timer state
var countdownSeconds = 180; // 3 minutes = 180 seconds
var countdownTimer = 0;
var countdownFramesPerSecond = 60; // 60 frames per second
// Touch input with delay
game.down = function (x, y, obj) {
	// Only allow movement if not already moving and singer is facing away
	if (!player.isMoving && singer.facingAway) {
		pendingMove = {
			x: x,
			y: y
		};
		delayTimer = moveDelay;
	}
};
// Track game over state
var gameEnded = false;
var lastGameEndedState = false;
game.update = function () {
	// Handle delayed movement
	if (pendingMove && delayTimer > 0) {
		delayTimer--;
		if (delayTimer <= 0) {
			// Check if target position is valid (not inside obstacles)
			var validMove = true;
			for (var i = 0; i < obstacles.length; i++) {
				var obstacle = obstacles[i];
				var dx = pendingMove.x - obstacle.x;
				var dy = pendingMove.y - obstacle.y;
				var distance = Math.sqrt(dx * dx + dy * dy);
				if (distance < 100) {
					// Collision detection
					validMove = false;
					break;
				}
			}
			if (validMove) {
				player.moveTo(pendingMove.x, pendingMove.y);
			}
			pendingMove = null;
		}
	}
	// Update health display
	healthTxt.setText('Health: ' + player.health);
	// Update countdown timer
	countdownTimer++;
	if (countdownTimer >= countdownFramesPerSecond) {
		countdownTimer = 0;
		countdownSeconds--;
		countdownTxt.setText(countdownSeconds.toString());
		// Change color when time is running low
		if (countdownSeconds <= 10) {
			countdownTxt.fill = 0xFF0000; // Red color for urgency
		} else if (countdownSeconds <= 20) {
			countdownTxt.fill = 0xFFFF00; // Yellow color for warning
		}
		// Game over when countdown reaches 0
		if (countdownSeconds <= 0) {
			LK.showGameOver();
		}
	}
	// Check for game end state transitions
	var currentGameEnded = player.health <= 0 || player.y <= winLine.y + 50;
	if (!lastGameEndedState && currentGameEnded) {
		// Game just ended, spawn random obstacles
		for (var j = 0; j < 8; j++) {
			var randomAssetIndex = Math.floor(Math.random() * obstacleAssets.length);
			var newObstacle = game.addChild(new Obstacle(obstacleAssets[randomAssetIndex]));
			newObstacle.x = Math.random() * 1800 + 200; // Random x between 200 and 2000
			newObstacle.y = Math.random() * 1800 + 600; // Random y between 600 and 2400
			obstacles.push(newObstacle);
		}
	}
	lastGameEndedState = currentGameEnded;
	// Check win condition
	if (player.y <= winLine.y + 50) {
		LK.showYouWin();
	}
	// Check obstacle collisions
	for (var k = 0; k < obstacles.length; k++) {
		var obstacle = obstacles[k];
		// Check if player is colliding with obstacle
		var obstacleDx = player.x - obstacle.x;
		var obstacleDy = player.y - obstacle.y;
		var obstacleDistance = Math.sqrt(obstacleDx * obstacleDx + obstacleDy * obstacleDy);
		var isPlayerCollidingWithObstacle = obstacleDistance < 100;
		// Check for obstacles that can move the character
		if (obstacle.canMoveCharacter && !obstacle.melted) {
			// Check for collision transition (just started colliding)
			if (!obstacle.lastPlayerColliding && isPlayerCollidingWithObstacle) {
				// Move player to a random nearby position
				var randomAngle = Math.random() * Math.PI * 2;
				var moveDistance = 150 + Math.random() * 100; // Random distance between 150-250
				var newX = player.x + Math.cos(randomAngle) * moveDistance;
				var newY = player.y + Math.sin(randomAngle) * moveDistance;
				// Keep player within game bounds
				newX = Math.max(100, Math.min(1948, newX));
				newY = Math.max(500, Math.min(2600, newY));
				// Use tween to move player smoothly
				tween(player, {
					x: newX,
					y: newY
				}, {
					duration: 400,
					easing: tween.easeOut
				});
			}
			obstacle.lastPlayerColliding = isPlayerCollidingWithObstacle;
		}
		// Check trigger point collisions for melting obstacles
		if (obstacle.canMelt && !obstacle.melted) {
			// Check if player is on trigger point
			var triggerX = obstacle.x + obstacle.triggerPoint.x;
			var triggerY = obstacle.y + obstacle.triggerPoint.y;
			var dx = player.x - triggerX;
			var dy = player.y - triggerY;
			var distance = Math.sqrt(dx * dx + dy * dy);
			obstacle.isPlayerOnTrigger = distance < 75; // Half of trigger point size
			// Check for transition from not on trigger to on trigger
			if (!obstacle.lastPlayerOnTrigger && obstacle.isPlayerOnTrigger) {
				obstacle.triggerTimer = 0; // Reset timer when player enters trigger
			}
			// If player is on trigger, increment timer
			if (obstacle.isPlayerOnTrigger) {
				obstacle.triggerTimer++;
				// If player has been on trigger for 2 seconds (120 frames at 60fps)
				if (obstacle.triggerTimer >= 120) {
					// Start melting effect
					obstacle.melted = true;
					// Melting animation - scale down and fade out
					tween(obstacle, {
						scaleX: 0,
						scaleY: 0,
						alpha: 0
					}, {
						duration: 1000,
						easing: tween.easeInOut,
						onFinish: function onFinish() {
							// Remove from obstacles array and destroy
							var index = obstacles.indexOf(obstacle);
							if (index > -1) {
								obstacles.splice(index, 1);
							}
							obstacle.destroy();
						}
					});
				}
			} else {
				obstacle.triggerTimer = 0; // Reset timer if player leaves trigger
			}
			obstacle.lastPlayerOnTrigger = obstacle.isPlayerOnTrigger;
		}
	}
	// Update AI players
	for (var ai = 0; ai < aiPlayers.length; ai++) {
		var aiPlayer = aiPlayers[ai];
		if (aiPlayer.health > 0) {
			aiPlayer.update();
			// Check AI player obstacle collisions
			for (var m = 0; m < obstacles.length; m++) {
				var obstacle = obstacles[m];
				var aiObstacleDx = aiPlayer.x - obstacle.x;
				var aiObstacleDy = aiPlayer.y - obstacle.y;
				var aiObstacleDistance = Math.sqrt(aiObstacleDx * aiObstacleDx + aiObstacleDy * aiObstacleDy);
				var isAICollidingWithObstacle = aiObstacleDistance < 100;
				// Check for obstacles that can move the AI character
				if (obstacle.canMoveCharacter && !obstacle.melted) {
					if (!obstacle['lastAIColliding' + ai] && isAICollidingWithObstacle) {
						// Move AI player to a random nearby position
						var randomAngle = Math.random() * Math.PI * 2;
						var moveDistance = 150 + Math.random() * 100;
						var newX = aiPlayer.x + Math.cos(randomAngle) * moveDistance;
						var newY = aiPlayer.y + Math.sin(randomAngle) * moveDistance;
						// Keep AI player within game bounds
						newX = Math.max(100, Math.min(1948, newX));
						newY = Math.max(500, Math.min(2600, newY));
						tween(aiPlayer, {
							x: newX,
							y: newY
						}, {
							duration: 400,
							easing: tween.easeOut
						});
					}
					obstacle['lastAIColliding' + ai] = isAICollidingWithObstacle;
				}
			}
			// Check if AI player wins
			if (aiPlayer.y <= winLine.y + 50) {
				LK.showGameOver(); // AI player wins, human player loses
			}
		}
	}
	// Check if player is caught moving when singer turns
	if (!singer.facingAway && player.isMoving) {
		// This is handled in the singer's turnAround method
		// but we also check continuously in case of timing issues
		if (LK.ticks % 30 === 0) {
			// Check every half second
			player.takeDamage();
		}
	}
	// Check if AI players are caught moving when singer turns
	if (!singer.facingAway) {
		for (var aiIndex = 0; aiIndex < aiPlayers.length; aiIndex++) {
			var aiPlayer = aiPlayers[aiIndex];
			if (aiPlayer.isMoving && aiPlayer.health > 0) {
				if (LK.ticks % 30 === 0) {
					// Check every half second
					aiPlayer.takeDamage();
				}
			}
		}
	}
};