/**** 
* Plugins
****/ 
var tween = LK.import("@upit/tween.v1");
var storage = LK.import("@upit/storage.v1", {
	level: 1,
	highScore: 0
});

/**** 
* Classes
****/ 
var Bully = Container.expand(function (type) {
	var self = Container.call(this);
	// Default values
	self.type = type || 'normal';
	self.hp = 2;
	self.damage = 10;
	self.speed = 2;
	self.scoreValue = 10;
	// Configure bully based on type
	switch (self.type) {
		case 'big':
			self.hp = 5;
			self.damage = 25;
			self.speed = 1;
			self.scoreValue = 30;
			var bullyGraphics = self.attachAsset('bigBully', {
				anchorX: 0.5,
				anchorY: 0.5
			});
			break;
		case 'fast':
			self.hp = 1;
			self.damage = 5;
			self.speed = 4;
			self.scoreValue = 15;
			var bullyGraphics = self.attachAsset('fastBully', {
				anchorX: 0.5,
				anchorY: 0.5
			});
			break;
		default:
			var bullyGraphics = self.attachAsset('normalBully', {
				anchorX: 0.5,
				anchorY: 0.5
			});
	}
	self.targetX = 0;
	self.targetY = 0;
	self.isActive = true;
	self.down = function (x, y, obj) {
		if (!self.isActive) {
			return;
		}
		self.hp -= 1;
		// Feedback on hit
		LK.getSound('hit').play();
		LK.effects.flashObject(self, 0xffffff, 100);
		// Slightly push back the bully when hit
		tween(self, {
			x: self.x + (self.x > player.x ? 30 : -30)
		}, {
			duration: 100,
			easing: tween.easeOut
		});
		if (self.hp <= 0) {
			self.defeat();
		}
	};
	self.defeat = function () {
		if (!self.isActive) {
			return;
		}
		self.isActive = false;
		LK.setScore(LK.getScore() + self.scoreValue);
		// Animation for defeat
		tween(self, {
			alpha: 0,
			scaleX: 0.2,
			scaleY: 0.2
		}, {
			duration: 300,
			easing: tween.easeInOut,
			onFinish: function onFinish() {
				self.destroy();
				// Remove from the bullies array
				var index = bullies.indexOf(self);
				if (index > -1) {
					bullies.splice(index, 1);
				}
				// Check if wave is complete
				if (bullies.length === 0 && pendingBullies.length === 0) {
					endWave();
				}
			}
		});
	};
	self.update = function () {
		if (!self.isActive) {
			return;
		}
		// Move towards player
		var dx = self.targetX - self.x;
		var dy = self.targetY - self.y;
		var dist = Math.sqrt(dx * dx + dy * dy);
		if (dist > 5) {
			self.x += dx / dist * self.speed;
			self.y += dy / dist * self.speed;
		}
		// Check collision with player
		if (self.intersects(player) && self.isActive) {
			player.takeDamage(self.damage);
			LK.getSound('defeat').play();
			self.defeat();
		}
	};
	return self;
});
var HealthBar = Container.expand(function () {
	var self = Container.call(this);
	var barWidth = 400;
	var barHeight = 30;
	var background = LK.getAsset('background', {
		width: barWidth + 4,
		height: barHeight + 4,
		anchorX: 0,
		anchorY: 0,
		tint: 0x000000
	});
	var healthFill = LK.getAsset('background', {
		width: barWidth,
		height: barHeight,
		anchorX: 0,
		anchorY: 0,
		tint: 0x2ecc71,
		x: 2,
		y: 2
	});
	self.addChild(background);
	self.addChild(healthFill);
	self.setHealth = function (current, max) {
		var percentage = Math.max(0, current / max);
		tween(healthFill, {
			width: barWidth * percentage
		}, {
			duration: 200,
			easing: tween.easeOut
		});
		// Change color based on health percentage
		if (percentage > 0.6) {
			healthFill.tint = 0x2ecc71; // Green
		} else if (percentage > 0.3) {
			healthFill.tint = 0xf39c12; // Orange
		} else {
			healthFill.tint = 0xe74c3c; // Red
		}
	};
	return self;
});
var Player = Container.expand(function () {
	var self = Container.call(this);
	var playerGraphics = self.attachAsset('player', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	self.health = 100;
	self.maxHealth = 100;
	self.isInvulnerable = false;
	self.takeDamage = function (damage) {
		if (self.isInvulnerable) {
			return;
		}
		self.health = Math.max(0, self.health - damage);
		// Flash player red when taking damage
		LK.effects.flashObject(self, 0xff0000, 500);
		if (self.health <= 0) {
			// Game over state
			LK.showGameOver();
		}
	};
	self.makeInvulnerable = function (duration) {
		self.isInvulnerable = true;
		// Visual feedback for invulnerability
		tween(playerGraphics, {
			alpha: 0.7
		}, {
			duration: 200,
			easing: tween.easeInOut
		});
		LK.setTimeout(function () {
			self.isInvulnerable = false;
			tween(playerGraphics, {
				alpha: 1
			}, {
				duration: 200,
				easing: tween.easeInOut
			});
		}, duration);
	};
	return self;
});
var PowerUp = Container.expand(function (type) {
	var self = Container.call(this);
	self.type = type || 'health';
	var powerupGraphics = self.attachAsset('powerup', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	// Customize appearance based on type
	switch (self.type) {
		case 'invulnerability':
			powerupGraphics.tint = 0xf1c40f; // Yellow
			powerupGraphics.filters = [new GlowFilter({
				color: 0xf1c40f,
				distance: 15,
				outerStrength: 2
			})];
			powerupGraphics.scaleX = 1.5;
			powerupGraphics.scaleY = 1.5;
			break;
		case 'clearScreen':
			powerupGraphics.tint = 0x9b59b6; // Purple
			break;
		default:
			// health
			powerupGraphics.tint = 0x2ecc71;
		// Green
	}
	self.lifespan = 5000; // Powerups disappear after 5 seconds
	self.birthTime = Date.now();
	self.down = function (x, y, obj) {
		LK.getSound('powerup').play();
		// Apply effect based on type
		switch (self.type) {
			case 'health':
				player.health = Math.min(player.maxHealth, player.health + 30);
				healthBar.setHealth(player.health, player.maxHealth);
				break;
			case 'invulnerability':
				player.makeInvulnerable(5000); // 5 seconds of invulnerability
				break;
			case 'clearScreen':
				// Defeat all active bullies
				for (var i = bullies.length - 1; i >= 0; i--) {
					bullies[i].defeat();
				}
				break;
		}
		self.destroy();
		// Remove from powerups array
		var index = powerups.indexOf(self);
		if (index > -1) {
			powerups.splice(index, 1);
		}
	};
	self.update = function () {
		// Check if powerup should disappear
		if (Date.now() - self.birthTime > self.lifespan) {
			tween(self, {
				alpha: 0
			}, {
				duration: 300,
				easing: tween.linear,
				onFinish: function onFinish() {
					self.destroy();
					var index = powerups.indexOf(self);
					if (index > -1) {
						powerups.splice(index, 1);
					}
				}
			});
		}
		// Pulsating animation
		if (LK.ticks % 30 === 0) {
			tween(self, {
				scaleX: 1.2,
				scaleY: 1.2
			}, {
				duration: 300,
				easing: tween.easeInOut,
				onFinish: function onFinish() {
					tween(self, {
						scaleX: 1,
						scaleY: 1
					}, {
						duration: 300,
						easing: tween.easeInOut
					});
				}
			});
		}
	};
	return self;
});
var WaveText = Container.expand(function () {
	var self = Container.call(this);
	var waveText = new Text2("Wave 1", {
		size: 120,
		fill: 0xFFFFFF
	});
	waveText.anchor.set(0.5, 0.5);
	self.addChild(waveText);
	self.show = function (waveNumber) {
		waveText.setText("Wave " + waveNumber);
		self.alpha = 0;
		self.scaleX = 2;
		self.scaleY = 2;
		tween(self, {
			alpha: 1,
			scaleX: 1,
			scaleY: 1
		}, {
			duration: 1000,
			easing: tween.easeOut,
			onFinish: function onFinish() {
				LK.setTimeout(function () {
					tween(self, {
						alpha: 0
					}, {
						duration: 500,
						easing: tween.easeIn
					});
				}, 1000);
			}
		});
	};
	return self;
});

/**** 
* Initialize Game
****/ 
var game = new LK.Game({
	backgroundColor: 0xecf0f1 // Light gray background
});

/**** 
* Game Code
****/ 
// Define a minimal GlowFilter class to fix the ReferenceError
// Game state variables
function _typeof(o) {
	"@babel/helpers - typeof";
	return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (o) {
		return typeof o;
	} : function (o) {
		return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o;
	}, _typeof(o);
}
function _defineProperties(e, r) {
	for (var t = 0; t < r.length; t++) {
		var o = r[t];
		o.enumerable = o.enumerable || !1, o.configurable = !0, "value" in o && (o.writable = !0), Object.defineProperty(e, _toPropertyKey(o.key), o);
	}
}
function _createClass(e, r, t) {
	return r && _defineProperties(e.prototype, r), t && _defineProperties(e, t), Object.defineProperty(e, "prototype", {
		writable: !1
	}), e;
}
function _toPropertyKey(t) {
	var i = _toPrimitive(t, "string");
	return "symbol" == _typeof(i) ? i : i + "";
}
function _toPrimitive(t, r) {
	if ("object" != _typeof(t) || !t) {
		return t;
	}
	var e = t[Symbol.toPrimitive];
	if (void 0 !== e) {
		var i = e.call(t, r || "default");
		if ("object" != _typeof(i)) {
			return i;
		}
		throw new TypeError("@@toPrimitive must return a primitive value.");
	}
	return ("string" === r ? String : Number)(t);
}
function _classCallCheck(a, n) {
	if (!(a instanceof n)) {
		throw new TypeError("Cannot call a class as a function");
	}
}
var GlowFilter = /*#__PURE__*/_createClass(function GlowFilter(options) {
	_classCallCheck(this, GlowFilter);
	options = options || {}; // Ensure options is defined
	this.color = options.color || 0xffffff;
	this.distance = options.distance || 10;
	this.outerStrength = options.outerStrength || 1;
});
var currentLevel = storage.level || 1;
var highScore = storage.highScore || 0;
var player;
var bullies = [];
var powerups = [];
var pendingBullies = [];
var spawnTimer;
var healthBar;
var scoreText;
var levelText;
var waveText;
var gameActive = true;
var powerupChance = 0.2; // 20% chance of powerup spawn per bully defeated
// Add background image
var background = LK.getAsset('background', {
	anchorX: 0.5,
	anchorY: 0.5
});
background.x = 2048 / 2;
background.y = 2732 / 2;
game.addChild(background);
// Initialize the player
player = new Player();
player.x = 2048 / 2;
player.y = 2732 / 2;
game.addChild(player);
// Initialize GUI elements
healthBar = new HealthBar();
LK.gui.top.addChild(healthBar);
healthBar.y = 20;
healthBar.x = (2048 - 400) / 2; // Center healthbar
// Score display
scoreText = new Text2("Score: 0", {
	size: 60,
	fill: 0x34495E
});
scoreText.anchor.set(1, 0);
LK.gui.topRight.addChild(scoreText);
scoreText.x = -20;
scoreText.y = 20;
// Level display
levelText = new Text2("Level: " + currentLevel, {
	size: 60,
	fill: 0x34495E
});
levelText.anchor.set(0, 0);
LK.gui.topLeft.addChild(levelText);
levelText.x = 120; // Keep away from top left corner
levelText.y = 20;
// Wave announcement text
waveText = new WaveText();
waveText.x = 2048 / 2;
waveText.y = 2732 / 2;
game.addChild(waveText);
// Start background music
LK.playMusic('gameMusic', {
	fade: {
		start: 0,
		end: 0.5,
		duration: 1000
	}
});
// Start the first wave
startWave(currentLevel);
function startWave(level) {
	// Clear any existing entities
	clearEntities();
	// Show wave text
	waveText.show(level);
	// Configure wave based on level
	var numBullies = Math.min(5 + level * 2, 30); // Cap at 30 bullies
	var bigBullyChance = Math.min(0.1 + level * 0.03, 0.4); // Cap at 40%
	var fastBullyChance = Math.min(0.1 + level * 0.05, 0.5); // Cap at 50%
	// Create the wave of bullies
	for (var i = 0; i < numBullies; i++) {
		var bullyType = 'normal';
		var rand = Math.random();
		if (rand < bigBullyChance) {
			bullyType = 'big';
		} else if (rand < bigBullyChance + fastBullyChance) {
			bullyType = 'fast';
		}
		pendingBullies.push(bullyType);
	}
	// Start spawning bullies
	spawnTimer = LK.setInterval(spawnBully, 1500 - Math.min(level * 100, 1000)); // Faster spawns at higher levels
}
function spawnBully() {
	if (pendingBullies.length === 0) {
		LK.clearInterval(spawnTimer);
		return;
	}
	var bullyType = pendingBullies.shift();
	var bully = new Bully(bullyType);
	// Randomize start position (from edges of the screen)
	var side = Math.floor(Math.random() * 4); // 0: top, 1: right, 2: bottom, 3: left
	switch (side) {
		case 0:
			// top
			bully.x = Math.random() * 2048;
			bully.y = -100;
			break;
		case 1:
			// right
			bully.x = 2148;
			bully.y = Math.random() * 2732;
			break;
		case 2:
			// bottom
			bully.x = Math.random() * 2048;
			bully.y = 2832;
			break;
		case 3:
			// left
			bully.x = -100;
			bully.y = Math.random() * 2732;
			break;
	}
	// Set target to player position
	bully.targetX = player.x;
	bully.targetY = player.y;
	bullies.push(bully);
	game.addChild(bully);
	// Spawn animation
	bully.alpha = 0;
	bully.scaleX = 0.5;
	bully.scaleY = 0.5;
	tween(bully, {
		alpha: 1,
		scaleX: 1,
		scaleY: 1
	}, {
		duration: 300,
		easing: tween.easeOut
	});
}
function clearEntities() {
	// Clear bullies
	for (var i = bullies.length - 1; i >= 0; i--) {
		bullies[i].destroy();
	}
	bullies = [];
	// Clear powerups
	for (var i = powerups.length - 1; i >= 0; i--) {
		powerups[i].destroy();
	}
	powerups = [];
	// Clear any pending bullies
	pendingBullies = [];
	// Clear timers
	if (spawnTimer) {
		LK.clearInterval(spawnTimer);
	}
}
function endWave() {
	// Increase level
	currentLevel++;
	storage.level = currentLevel;
	// Update level text
	levelText.setText("Level: " + currentLevel);
	// Play completion sound
	LK.getSound('levelComplete').play();
	// Update high score if needed
	if (LK.getScore() > highScore) {
		highScore = LK.getScore();
		storage.highScore = highScore;
	}
	// Start the next wave after a delay
	LK.setTimeout(function () {
		startWave(currentLevel);
	}, 2000);
}
function spawnPowerup() {
	if (!gameActive) {
		return;
	}
	// Random position close to the player
	var px = player.x + (Math.random() * 400 - 200); // Random offset between -200 and 200
	var py = player.y + (Math.random() * 400 - 200); // Random offset between -200 and 200
	// Random powerup type
	var types = ['health', 'invulnerability', 'clearScreen'];
	var typeIndex = Math.floor(Math.random() * types.length);
	var powerup = new PowerUp(types[typeIndex]);
	powerup.x = px;
	powerup.y = py;
	// Add to game
	powerups.push(powerup);
	game.addChild(powerup);
	// Spawn animation
	powerup.alpha = 0;
	powerup.scaleX = 0;
	powerup.scaleY = 0;
	tween(powerup, {
		alpha: 1,
		scaleX: 1,
		scaleY: 1
	}, {
		duration: 300,
		easing: tween.elasticOut
	});
}
// Event handlers
game.down = function (x, y, obj) {
	// This event is primarily for tapping in empty space
	// Individual objects like bullies and powerups have their own down handlers
};
// Game update loop
game.update = function () {
	if (!gameActive) {
		return;
	}
	// Update score display
	scoreText.setText("Score: " + LK.getScore());
	// Update health bar
	healthBar.setHealth(player.health, player.maxHealth);
	// Randomly spawn powerups (independent of bullies)
	if (LK.ticks % 300 === 0 && Math.random() < powerupChance) {
		spawnPowerup();
	}
	// Update all bullies targets to follow player
	for (var i = 0; i < bullies.length; i++) {
		bullies[i].targetX = player.x;
		bullies[i].targetY = player.y;
	}
};

===================================================================
--- original.js
+++ change.js
@@ -564,11 +564,11 @@
 function spawnPowerup() {
 	if (!gameActive) {
 		return;
 	}
-	// Random position (avoiding edges)
-	var px = 200 + Math.random() * (2048 - 400);
-	var py = 200 + Math.random() * (2732 - 600);
+	// Random position close to the player
+	var px = player.x + (Math.random() * 400 - 200); // Random offset between -200 and 200
+	var py = player.y + (Math.random() * 400 - 200); // Random offset between -200 and 200
 	// Random powerup type
 	var types = ['health', 'invulnerability', 'clearScreen'];
 	var typeIndex = Math.floor(Math.random() * types.length);
 	var powerup = new PowerUp(types[typeIndex]);