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

/**** 
* Classes
****/ 
var Cannon = Container.expand(function () {
	var self = Container.call(this);
	self.graphics = self.attachAsset('cannon', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	self.targetX = 0;
	self.targetY = 0;
	self.lastFireTime = 0;
	self.fireDelay = 300;
	self.health = 10;
	self.maxHealth = 10;
	self.isShielded = false;
	self.shieldTimer = 0;
	self.aimAt = function (x, y) {
		self.targetX = x;
		self.targetY = y;
		var dx = x - self.x;
		var dy = y - self.y;
		var angle = Math.atan2(dy, dx);
		self.graphics.rotation = angle;
	};
	self.canFire = function () {
		var currentFireDelay = rapidFire ? self.fireDelay / 3 : self.fireDelay;
		return LK.ticks * 16.67 - self.lastFireTime >= currentFireDelay;
	};
	self.fire = function () {
		if (!self.canFire()) return null;
		self.lastFireTime = LK.ticks * 16.67;
		var cannonballs = [];
		var dx = self.targetX - self.x;
		var dy = self.targetY - self.y;
		var distance = Math.sqrt(dx * dx + dy * dy);
		var baseAngle = Math.atan2(dy, dx);
		if (tripleShot) {
			// Fire three cannonballs with slight angle differences
			for (var i = 0; i < 3; i++) {
				var cannonball = new Cannonball();
				cannonball.x = self.x;
				cannonball.y = self.y;
				var angleOffset = (i - 1) * 0.2; // -0.2, 0, 0.2 radians
				var adjustedAngle = baseAngle + angleOffset;
				cannonball.velocityX = Math.cos(adjustedAngle) * cannonball.speed;
				cannonball.velocityY = Math.sin(adjustedAngle) * cannonball.speed;
				cannonballs.push(cannonball);
			}
		} else {
			// Fire single cannonball
			var cannonball = new Cannonball();
			cannonball.x = self.x;
			cannonball.y = self.y;
			cannonball.velocityX = dx / distance * cannonball.speed;
			cannonball.velocityY = dy / distance * cannonball.speed;
			cannonballs.push(cannonball);
		}
		LK.getSound('shoot').play();
		return cannonballs;
	};
	self.takeDamage = function (damage) {
		if (self.isShielded) {
			damage = Math.floor(damage / 2); // Shield reduces damage by half
		}
		self.health -= damage;
		if (self.health < 0) self.health = 0;
		// Flash red when taking damage
		tween(self.graphics, {
			tint: 0xff0000
		}, {
			duration: 100,
			onFinish: function onFinish() {
				tween(self.graphics, {
					tint: 0xffffff
				}, {
					duration: 100
				});
			}
		});
	};
	self.heal = function (amount) {
		self.health += amount;
		if (self.health > self.maxHealth) self.health = self.maxHealth;
		// Flash green when healing
		tween(self.graphics, {
			tint: 0x00ff00
		}, {
			duration: 200,
			onFinish: function onFinish() {
				tween(self.graphics, {
					tint: 0xffffff
				}, {
					duration: 200
				});
			}
		});
	};
	self.activateShield = function () {
		self.isShielded = true;
		self.shieldTimer = 900; // 15 seconds at 60fps
		self.graphics.tint = 0x88ccff; // Blue tint for shield
	};
	return self;
});
var Cannonball = Container.expand(function () {
	var self = Container.call(this);
	var graphics = self.attachAsset('cannonball', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	self.velocityX = 0;
	self.velocityY = 0;
	self.speed = 16;
	self.update = function () {
		self.x += self.velocityX;
		self.y += self.velocityY;
	};
	return self;
});
var EnemyBullet = Container.expand(function () {
	var self = Container.call(this);
	var graphics = self.attachAsset('enemyBullet', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	self.velocityX = 0;
	self.velocityY = 0;
	self.speed = 8;
	self.damage = 1;
	self.update = function () {
		self.x += self.velocityX;
		self.y += self.velocityY;
	};
	return self;
});
var HealthKit = Container.expand(function () {
	var self = Container.call(this);
	self.speed = 2;
	self.healAmount = 2;
	var graphics = self.attachAsset('healthKit', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	// Add a cross symbol
	var crossV = LK.getAsset('healthKit', {
		width: 20,
		height: 60,
		color: 0xffffff,
		shape: 'box',
		anchorX: 0.5,
		anchorY: 0.5
	});
	var crossH = LK.getAsset('healthKit', {
		width: 60,
		height: 20,
		color: 0xffffff,
		shape: 'box',
		anchorX: 0.5,
		anchorY: 0.5
	});
	self.addChild(crossV);
	self.addChild(crossH);
	self.update = function () {
		self.x += self.speed;
	};
	return self;
});
var PowerUp = Container.expand(function () {
	var self = Container.call(this);
	self.powerType = 'tripleShot';
	self.speed = 2;
	self.graphics = null;
	self.init = function (type) {
		self.powerType = type;
		if (type === 'tripleShot') {
			self.graphics = self.attachAsset('tripleShotPowerUp', {
				anchorX: 0.5,
				anchorY: 0.5
			});
		} else if (type === 'rapidFire') {
			self.graphics = self.attachAsset('rapidFirePowerUp', {
				anchorX: 0.5,
				anchorY: 0.5
			});
		}
	};
	self.update = function () {
		self.x += self.speed;
	};
	return self;
});
var ShieldPowerUp = Container.expand(function () {
	var self = Container.call(this);
	self.speed = 2;
	var graphics = self.attachAsset('shieldPowerUp', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	self.update = function () {
		self.x += self.speed;
	};
	return self;
});
var Ship = Container.expand(function () {
	var self = Container.call(this);
	self.shipType = 'small';
	self.speed = 2;
	self.points = 10;
	self.graphics = null;
	self.healthBar = null;
	self.healthBarBg = null;
	self.init = function (type) {
		self.shipType = type;
		if (type === 'small') {
			self.graphics = self.attachAsset('smallShip', {
				anchorX: 0.5,
				anchorY: 0.5
			});
			self.speed = 3;
			self.points = 10;
			self.health = 1;
			self.maxHealth = 1;
		} else if (type === 'medium') {
			self.graphics = self.attachAsset('mediumShip', {
				anchorX: 0.5,
				anchorY: 0.5
			});
			self.speed = 2;
			self.points = 25;
			self.health = 3;
			self.maxHealth = 3;
		} else if (type === 'large') {
			self.graphics = self.attachAsset('largeShip', {
				anchorX: 0.5,
				anchorY: 0.5
			});
			self.speed = 1.5;
			self.points = 50;
			self.health = 5;
			self.maxHealth = 5;
		}
		// Create health bar background - wider for better visibility
		var healthBarWidth = Math.max(120, self.graphics.width * 1.2);
		self.healthBarBg = LK.getAsset('healthBarBg', {
			width: healthBarWidth,
			height: 12,
			color: 0x444444,
			shape: 'box',
			anchorX: 0.5,
			anchorY: 0.5
		});
		self.healthBarBg.y = -self.graphics.height / 2 - 20;
		self.addChild(self.healthBarBg);
		// Create health bar foreground - wider for better visibility
		self.healthBar = LK.getAsset('healthBar', {
			width: healthBarWidth - 4,
			height: 8,
			color: 0x00FF00,
			shape: 'box',
			anchorX: 0.5,
			anchorY: 0.5
		});
		self.healthBar.y = -self.graphics.height / 2 - 20;
		self.addChild(self.healthBar);
		// Show health bar for all ships now - no hiding for small ships
		// Set shooting properties based on ship type
		self.lastShotTime = 0;
		if (type === 'small') {
			self.shotDelay = 180; // 3 seconds
		} else if (type === 'medium') {
			self.shotDelay = 150; // 2.5 seconds
		} else if (type === 'large') {
			self.shotDelay = 120; // 2 seconds
		}
	};
	self.updateHealthBar = function () {
		if (self.healthBar && self.maxHealth > 1) {
			var healthPercent = self.health / self.maxHealth;
			self.healthBar.scaleX = healthPercent;
			if (healthPercent > 0.6) {
				self.healthBar.tint = 0x00FF00; // Green
			} else if (healthPercent > 0.3) {
				self.healthBar.tint = 0xFFFF00; // Yellow
			} else {
				self.healthBar.tint = 0xFF0000; // Red
			}
		}
	};
	self.update = function () {
		self.x += self.speed;
	};
	self.canShoot = function () {
		return LK.ticks - self.lastShotTime >= self.shotDelay;
	};
	self.shootAtCannon = function (cannonX, cannonY) {
		if (!self.canShoot()) return null;
		self.lastShotTime = LK.ticks;
		var bullet = new EnemyBullet();
		bullet.x = self.x;
		bullet.y = self.y;
		var dx = cannonX - self.x;
		var dy = cannonY - self.y;
		var distance = Math.sqrt(dx * dx + dy * dy);
		bullet.velocityX = dx / distance * bullet.speed;
		bullet.velocityY = dy / distance * bullet.speed;
		return bullet;
	};
	return self;
});

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

/**** 
* Game Code
****/ 
var oceanBackground = LK.getAsset('oceanBackground', {
	anchorX: 0,
	anchorY: 0,
	x: 0,
	y: 0
});
game.addChild(oceanBackground);
// Start menu variables
var gameStarted = false;
var startMenu = new Container();
game.addChild(startMenu);
// Game title
var titleText = new Text2('OCEAN DEFENDER', {
	size: 120,
	fill: 0xFFFFFF
});
titleText.anchor.set(0.5, 0.5);
titleText.x = 1024;
titleText.y = 800;
startMenu.addChild(titleText);
// Subtitle
var subtitleText = new Text2('Defend the coast from enemy ships!', {
	size: 60,
	fill: 0xCCCCCC
});
subtitleText.anchor.set(0.5, 0.5);
subtitleText.x = 1024;
subtitleText.y = 950;
startMenu.addChild(subtitleText);
// Play button
var playButton = new Text2('PLAY', {
	size: 100,
	fill: 0x00FF00
});
playButton.anchor.set(0.5, 0.5);
playButton.x = 1024;
playButton.y = 1400;
startMenu.addChild(playButton);
// Instructions
var instructionsText = new Text2('Tap anywhere to aim and shoot', {
	size: 50,
	fill: 0xAAAAA
});
instructionsText.anchor.set(0.5, 0.5);
instructionsText.x = 1024;
instructionsText.y = 1600;
startMenu.addChild(instructionsText);
// Start playing the peaceful sea music
LK.playMusic('calmSeaMelody');
var cannon = game.addChild(new Cannon());
cannon.x = 1024;
cannon.y = 2600;
var ships = [];
var cannonballs = [];
var shipSpawnTimer = 0;
var shipSpawnDelay = 120;
var difficultyTimer = 0;
var shipsEscaped = 0;
var maxEscapedShips = 10;
var scoreTxt = new Text2('Score: 0', {
	size: 60,
	fill: 0xFFFFFF
});
scoreTxt.anchor.set(0.5, 0);
LK.gui.top.addChild(scoreTxt);
var powerUps = [];
var tripleShot = false;
var tripleShotTimer = 0;
var rapidFire = false;
var rapidFireTimer = 0;
var powerUpDuration = 600; // 10 seconds at 60fps
// Power-up timer UI
var powerUpTimerTxt = new Text2('', {
	size: 70,
	fill: 0xFFFFFF
});
powerUpTimerTxt.anchor.set(1, 0);
powerUpTimerTxt.x = -20;
powerUpTimerTxt.y = 80;
LK.gui.topRight.addChild(powerUpTimerTxt);
var activePowerUpType = '';
var activePowerUpTimer = 0;
var isShooting = false;
var shootingTimer = 0;
// Cannon health system
var enemyBullets = [];
var healthKits = [];
var shieldPowerUps = [];
// Cannon health UI - positioned next to cannon
var cannonHealthBarBg = LK.getAsset('cannonHealthBarBg', {
	width: 400,
	height: 20,
	color: 0x444444,
	shape: 'box',
	anchorX: 0.5,
	anchorY: 0.5
});
cannonHealthBarBg.x = cannon.x;
cannonHealthBarBg.y = cannon.y - 150;
game.addChild(cannonHealthBarBg);
var cannonHealthBar = LK.getAsset('cannonHealthBar', {
	width: 396,
	height: 16,
	color: 0x00ff00,
	shape: 'box',
	anchorX: 0.5,
	anchorY: 0.5
});
cannonHealthBar.x = cannon.x;
cannonHealthBar.y = cannon.y - 150;
game.addChild(cannonHealthBar);
var healthText = new Text2('Health: 10/10', {
	size: 40,
	fill: 0xFFFFFF
});
healthText.anchor.set(0.5, 0.5);
healthText.x = cannon.x;
healthText.y = cannon.y - 100;
game.addChild(healthText);
function spawnShip() {
	var ship = new Ship();
	var types = ['small', 'small', 'medium', 'large'];
	var randomType = types[Math.floor(Math.random() * types.length)];
	ship.init(randomType);
	ship.x = -150;
	ship.y = 1000 + Math.random() * 1200;
	// Set zIndex based on ship type for proper layering
	if (ship.shipType === 'large') {
		ship.zIndex = 3;
	} else if (ship.shipType === 'medium') {
		ship.zIndex = 2;
	} else {
		ship.zIndex = 1;
	}
	game.children.sort(function (a, b) {
		return (a.zIndex || 0) - (b.zIndex || 0);
	});
	ships.push(ship);
	game.addChild(ship);
}
function updateDifficulty() {
	difficultyTimer++;
	if (difficultyTimer % 1800 === 0) {
		shipSpawnDelay = Math.max(60, shipSpawnDelay - 10);
	}
}
// Touch/click handlers
game.down = function (x, y, obj) {
	if (!gameStarted) return;
	cannon.aimAt(x, y);
	isShooting = true;
	shootingTimer = 0;
	// Fire immediately on first click
	var newCannonballs = cannon.fire();
	if (newCannonballs) {
		for (var c = 0; c < newCannonballs.length; c++) {
			cannonballs.push(newCannonballs[c]);
			game.addChild(newCannonballs[c]);
		}
	}
};
game.up = function (x, y, obj) {
	if (!gameStarted) return;
	isShooting = false;
};
// Play button event handler
playButton.down = function (x, y, obj) {
	if (!gameStarted) {
		gameStarted = true;
		startMenu.visible = false;
	}
};
game.update = function () {
	if (!gameStarted) return;
	// Handle continuous shooting
	if (isShooting) {
		shootingTimer++;
		var currentFireDelay = rapidFire ? cannon.fireDelay / 3 : cannon.fireDelay;
		var fireDelayInTicks = currentFireDelay / 16.67; // Convert ms to ticks
		if (shootingTimer >= fireDelayInTicks) {
			var newCannonballs = cannon.fire();
			if (newCannonballs) {
				for (var c = 0; c < newCannonballs.length; c++) {
					cannonballs.push(newCannonballs[c]);
					game.addChild(newCannonballs[c]);
				}
			}
			shootingTimer = 0;
		}
	}
	updateDifficulty();
	shipSpawnTimer++;
	if (shipSpawnTimer >= shipSpawnDelay) {
		spawnShip();
		shipSpawnTimer = 0;
	}
	for (var i = ships.length - 1; i >= 0; i--) {
		var ship = ships[i];
		if (ship.lastX === undefined) ship.lastX = ship.x;
		if (ship.lastX <= 2048 && ship.x > 2048) {
			shipsEscaped++;
			LK.getSound('shipEscape').play();
			ship.destroy();
			ships.splice(i, 1);
			continue;
		}
		// Ships shoot at cannon
		if (ship.x > 200 && ship.x < 1800) {
			// Only shoot when in range
			var newBullet = ship.shootAtCannon(cannon.x, cannon.y);
			if (newBullet) {
				enemyBullets.push(newBullet);
				game.addChild(newBullet);
			}
		}
		ship.lastX = ship.x;
	}
	for (var j = cannonballs.length - 1; j >= 0; j--) {
		var cannonball = cannonballs[j];
		if (cannonball.lastX === undefined) cannonball.lastX = cannonball.x;
		if (cannonball.lastY === undefined) cannonball.lastY = cannonball.y;
		if (cannonball.lastX >= 0 && cannonball.x < 0 || cannonball.lastX <= 2048 && cannonball.x > 2048 || cannonball.lastY >= 0 && cannonball.y < 0 || cannonball.lastY <= 2732 && cannonball.y > 2732) {
			cannonball.destroy();
			cannonballs.splice(j, 1);
			continue;
		}
		for (var k = ships.length - 1; k >= 0; k--) {
			var ship = ships[k];
			if (cannonball.intersects(ship)) {
				ship.health--;
				ship.updateHealthBar();
				LK.effects.flashObject(ship, 0xff0000, 200);
				LK.getSound('hit').play();
				cannonball.destroy();
				cannonballs.splice(j, 1);
				if (ship.health <= 0) {
					LK.setScore(LK.getScore() + ship.points);
					scoreTxt.setText('Score: ' + LK.getScore());
					LK.getSound('shipDestroyed').play();
					// Random chance to spawn different power-ups (40% total chance)
					var spawnChance = Math.random();
					if (spawnChance < 0.15) {
						// 15% chance for weapon power-ups
						var powerUp = new PowerUp();
						var powerTypes = ['tripleShot', 'rapidFire'];
						var randomPowerType = powerTypes[Math.floor(Math.random() * powerTypes.length)];
						powerUp.init(randomPowerType);
						powerUp.x = ship.x;
						powerUp.y = ship.y;
						powerUps.push(powerUp);
						game.addChild(powerUp);
					} else if (spawnChance < 0.25) {
						// 10% chance for health kit
						var healthKit = new HealthKit();
						healthKit.x = ship.x;
						healthKit.y = ship.y;
						healthKits.push(healthKit);
						game.addChild(healthKit);
					} else if (spawnChance < 0.35) {
						// 10% chance for shield
						var shieldPowerUp = new ShieldPowerUp();
						shieldPowerUp.x = ship.x;
						shieldPowerUp.y = ship.y;
						shieldPowerUps.push(shieldPowerUp);
						game.addChild(shieldPowerUp);
					}
					ship.destroy();
					ships.splice(k, 1);
				}
				break;
			}
		}
		if (cannonballs[j]) {
			cannonball.lastX = cannonball.x;
			cannonball.lastY = cannonball.y;
		}
	}
	// Update power-ups
	for (var p = powerUps.length - 1; p >= 0; p--) {
		var powerUp = powerUps[p];
		if (powerUp.lastX === undefined) powerUp.lastX = powerUp.x;
		// Remove power-up if it goes off screen
		if (powerUp.lastX <= 2048 && powerUp.x > 2048) {
			powerUp.destroy();
			powerUps.splice(p, 1);
			continue;
		}
		// Check collision with cannonballs for collection
		for (var cb = cannonballs.length - 1; cb >= 0; cb--) {
			var cannonball = cannonballs[cb];
			if (cannonball.intersects(powerUp)) {
				// Collect power-up
				LK.getSound('powerUpCollect').play();
				LK.effects.flashScreen(0x00ff00, 300);
				// Clear any existing power-up
				tripleShot = false;
				rapidFire = false;
				// Activate new power-up
				if (powerUp.powerType === 'tripleShot') {
					tripleShot = true;
					activePowerUpType = 'Triple Shot';
					activePowerUpTimer = powerUpDuration;
				} else if (powerUp.powerType === 'rapidFire') {
					rapidFire = true;
					activePowerUpType = 'Rapid Fire';
					activePowerUpTimer = powerUpDuration;
				}
				powerUp.destroy();
				powerUps.splice(p, 1);
				break;
			}
		}
		if (powerUps[p]) {
			powerUp.lastX = powerUp.x;
		}
	}
	// Update enemy bullets
	for (var eb = enemyBullets.length - 1; eb >= 0; eb--) {
		var enemyBullet = enemyBullets[eb];
		if (enemyBullet.lastY === undefined) enemyBullet.lastY = enemyBullet.y;
		// Remove if off screen
		if (enemyBullet.lastY <= 2732 && enemyBullet.y > 2732) {
			enemyBullet.destroy();
			enemyBullets.splice(eb, 1);
			continue;
		}
		// Check collision with cannon
		if (enemyBullet.intersects(cannon)) {
			cannon.takeDamage(enemyBullet.damage);
			enemyBullet.destroy();
			enemyBullets.splice(eb, 1);
			// Update health UI
			var healthPercent = cannon.health / cannon.maxHealth;
			cannonHealthBar.scaleX = healthPercent;
			if (healthPercent > 0.6) {
				cannonHealthBar.tint = 0x00FF00;
			} else if (healthPercent > 0.3) {
				cannonHealthBar.tint = 0xFFFF00;
			} else {
				cannonHealthBar.tint = 0xFF0000;
			}
			healthText.setText('Health: ' + cannon.health + '/' + cannon.maxHealth);
			// Check game over
			if (cannon.health <= 0) {
				LK.showGameOver();
				return;
			}
			continue;
		}
		if (enemyBullets[eb]) {
			enemyBullet.lastY = enemyBullet.y;
		}
	}
	// Update health kits
	for (var hk = healthKits.length - 1; hk >= 0; hk--) {
		var healthKit = healthKits[hk];
		if (healthKit.lastX === undefined) healthKit.lastX = healthKit.x;
		// Remove if off screen
		if (healthKit.lastX <= 2048 && healthKit.x > 2048) {
			healthKit.destroy();
			healthKits.splice(hk, 1);
			continue;
		}
		// Check collection by cannonball
		for (var cb = cannonballs.length - 1; cb >= 0; cb--) {
			var cannonball = cannonballs[cb];
			if (cannonball.intersects(healthKit)) {
				cannon.heal(healthKit.healAmount);
				LK.getSound('powerUpCollect').play();
				LK.effects.flashScreen(0x00ff00, 200);
				// Update health UI
				var healthPercent = cannon.health / cannon.maxHealth;
				cannonHealthBar.scaleX = healthPercent;
				if (healthPercent > 0.6) {
					cannonHealthBar.tint = 0x00FF00;
				} else if (healthPercent > 0.3) {
					cannonHealthBar.tint = 0xFFFF00;
				} else {
					cannonHealthBar.tint = 0xFF0000;
				}
				healthText.setText('Health: ' + cannon.health + '/' + cannon.maxHealth);
				healthKit.destroy();
				healthKits.splice(hk, 1);
				break;
			}
		}
		if (healthKits[hk]) {
			healthKit.lastX = healthKit.x;
		}
	}
	// Update shield power-ups
	for (var sp = shieldPowerUps.length - 1; sp >= 0; sp--) {
		var shieldPowerUp = shieldPowerUps[sp];
		if (shieldPowerUp.lastX === undefined) shieldPowerUp.lastX = shieldPowerUp.x;
		// Remove if off screen
		if (shieldPowerUp.lastX <= 2048 && shieldPowerUp.x > 2048) {
			shieldPowerUp.destroy();
			shieldPowerUps.splice(sp, 1);
			continue;
		}
		// Check collection by cannonball
		for (var cb = cannonballs.length - 1; cb >= 0; cb--) {
			var cannonball = cannonballs[cb];
			if (cannonball.intersects(shieldPowerUp)) {
				cannon.activateShield();
				LK.getSound('powerUpCollect').play();
				LK.effects.flashScreen(0x0099ff, 300);
				shieldPowerUp.destroy();
				shieldPowerUps.splice(sp, 1);
				break;
			}
		}
		if (shieldPowerUps[sp]) {
			shieldPowerUp.lastX = shieldPowerUp.x;
		}
	}
	// Update cannon shield
	if (cannon.isShielded && cannon.shieldTimer > 0) {
		cannon.shieldTimer--;
		if (cannon.shieldTimer <= 0) {
			cannon.isShielded = false;
			tween(cannon.graphics, {
				tint: 0xffffff
			}, {
				duration: 500
			});
		}
	}
	// Update power-up timer
	if (activePowerUpTimer > 0) {
		activePowerUpTimer--;
		// Update timer display
		var timeLeft = Math.ceil(activePowerUpTimer / 60);
		var timerText = activePowerUpType + ': ' + timeLeft + 's';
		if (cannon.isShielded) {
			var shieldTimeLeft = Math.ceil(cannon.shieldTimer / 60);
			timerText += ' | Shield: ' + shieldTimeLeft + 's';
		}
		powerUpTimerTxt.setText(timerText);
		// Check if power-up expired
		if (activePowerUpTimer <= 0) {
			tripleShot = false;
			rapidFire = false;
			activePowerUpType = '';
			if (cannon.isShielded) {
				var shieldTimeLeft = Math.ceil(cannon.shieldTimer / 60);
				powerUpTimerTxt.setText('Shield: ' + shieldTimeLeft + 's');
			} else {
				powerUpTimerTxt.setText('');
			}
		}
	} else {
		// No active weapon power-up, but maybe shield
		if (cannon.isShielded) {
			var shieldTimeLeft = Math.ceil(cannon.shieldTimer / 60);
			powerUpTimerTxt.setText('Shield: ' + shieldTimeLeft + 's');
		} else {
			powerUpTimerTxt.setText('');
		}
	}
};