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

/**** 
* Game Code
****/ 
// Make sure the game has a stage property
// Add sparkle asset
if (!game.stage) {
	game.stage = new Container();
}
// --- Global Variables ---
/** 
* Cat Defender - Idle Game
*
* A game where cats automatically defend against incoming birds and UFOs.
* Features idle point accumulation, upgrades, and progressive difficulty.
*/ 
// Sound assets (already defined)
// Image assets
var cats = [];
var kittens = [];
var birds = [];
var ufos = [];
var powerUps = [];
var sparkles = [];
// Game State Variables
var score = 0;
var level = 1;
var multiplier = 1.0; // Starts at 1.0, increases by 0.1 per level
var idlePoints = 0;
var enemiesDefeated = 0;
var lastUpdateTime = Date.now();
var idlePointsLastCalculated = Date.now();
// Game Constants
var ENEMIES_PER_LEVEL = 11;
var BASE_IDLE_POINTS_RATE = 0.5; // Points per cat per second
var BIRD_POINTS = 10;
var UFO_POINTS = 20;
var BIRD_SPAWN_INTERVAL = 2000; // ms
var UFO_SPAWN_INTERVAL = 15000; // ms
var MAX_BIRDS = 10;
var MAX_UFOS = 3;
// Timers
var birdSpawnTimer = 0;
var ufoSpawnTimer = 0;
// --- Utility Functions ---
function distance(x1, y1, x2, y2) {
	var dx = x1 - x2;
	var dy = y1 - y2;
	return Math.sqrt(dx * dx + dy * dy);
}
// --- Game Classes ---
/** 
* Base class for game entities
*/ 
function GameObject(x, y, width, height, assetId) {
	this.x = x;
	this.y = y;
	this.width = width;
	this.height = height;
	this.assetId = assetId;
	this.active = true;
	this.lastX = x; // Track last X position
	this.lastY = y; // Track last Y position
	console.log("GameObject created:", this.constructor.name, "with asset:", assetId);
}
GameObject.prototype.update = function (deltaTime) {
	this.lastX = this.x; // Update last X position
	this.lastY = this.y; // Update last Y position
	// Override in subclasses
};
GameObject.prototype.render = function () {
	if (!this.active) {
		return;
	}
	try {
		// Draw the sprite using LK.getAsset
		var sprite = LK.getAsset(this.assetId, {});
		if (!sprite) {
			console.error("Failed to get asset:", this.assetId);
			return;
		}
		sprite.x = this.x;
		sprite.y = this.y;
		sprite.width = this.width;
		sprite.height = this.height;
		// Add the sprite directly to the game stage
		game.stage.addChild(sprite);
		console.log("Rendered:", this.constructor.name, "at", this.x, this.y);
	} catch (e) {
		console.error("Error rendering", this.constructor.name, ":", e);
	}
};
GameObject.prototype.isColliding = function (other) {
	return this.x < other.x + other.width && this.x + this.width > other.x && this.y < other.y + other.height && this.y + this.height > other.y;
};
/** 
* Base class for defenders (Cats and Kittens)
*/ 
function Defender(x, y, width, height, assetId, attackRange, attackCooldown, attackDamage, moveSpeed) {
	GameObject.call(this, x, y, width, height, assetId);
	this.attackRange = attackRange;
	this.attackCooldown = attackCooldown;
	this.attackDamage = attackDamage;
	this.moveSpeed = moveSpeed;
	this.attackTimer = 0;
	this.target = null;
}
Defender.prototype = Object.create(GameObject.prototype);
Defender.prototype.constructor = Defender;
Defender.prototype.update = function (deltaTime) {
	if (!this.active) {
		return;
	}
	// Handle attack cooldown
	if (this.attackTimer > 0) {
		this.attackTimer -= deltaTime;
	}
	// Find target if none exists
	if (!this.target || !this.target.active) {
		this.findTarget();
	}
	// Move towards target or attack
	if (this.target) {
		var dist = distance(this.x + this.width / 2, this.y + this.height / 2, this.target.x + this.target.width / 2, this.target.y + this.target.height / 2);
		if (dist <= this.attackRange) {
			this.attack();
		} else {
			this.moveTowardsTarget(deltaTime);
		}
	}
};
Defender.prototype.findTarget = function () {
	// Find closest enemy
	var closestDist = Infinity;
	var closest = null;
	// Check birds first
	for (var i = 0; i < birds.length; i++) {
		var bird = birds[i];
		if (!bird.active) {
			continue;
		}
		var dist = distance(this.x + this.width / 2, this.y + this.height / 2, bird.x + bird.width / 2, bird.y + bird.height / 2);
		if (dist < closestDist) {
			closestDist = dist;
			closest = bird;
		}
	}
	// Check UFOs if no birds found or if this is a kitten (kittens prefer UFOs)
	if ((!closest || this instanceof Kitten) && ufos.length > 0) {
		for (var i = 0; i < ufos.length; i++) {
			var ufo = ufos[i];
			if (!ufo.active) {
				continue;
			}
			var dist = distance(this.x + this.width / 2, this.y + this.height / 2, ufo.x + ufo.width / 2, ufo.y + ufo.height / 2);
			if (dist < closestDist) {
				closestDist = dist;
				closest = ufo;
			}
		}
	}
	this.target = closest;
};
Defender.prototype.moveTowardsTarget = function (deltaTime) {
	if (!this.target) {
		return;
	}
	var targetX = this.target.x + this.target.width / 2;
	var targetY = this.target.y + this.target.height / 2;
	var dx = targetX - (this.x + this.width / 2);
	var dy = targetY - (this.y + this.height / 2);
	var dist = Math.sqrt(dx * dx + dy * dy);
	if (dist > 0) {
		var moveX = dx / dist * this.moveSpeed * deltaTime;
		var moveY = dy / dist * this.moveSpeed * deltaTime;
		this.x += moveX;
		this.y += moveY;
	}
};
Defender.prototype.attack = function () {
	if (this.attackTimer <= 0 && this.target && this.target.active) {
		this.target.takeDamage(this.attackDamage);
		this.attackTimer = this.attackCooldown;
		// Create attack effect
		createSparkle(this.target.x + this.target.width / 2, this.target.y + this.target.height / 2, 'attack');
	}
};
/** 
* Cat Class - Standard defender
*/ 
function Cat(x, y) {
	Defender.call(this, x, y, 64, 64, 'cat', 100, 1.0, 2, 2);
}
Cat.prototype = Object.create(Defender.prototype);
Cat.prototype.constructor = Cat;
/** 
* Kitten Class - Faster but weaker defender
*/ 
function Kitten(x, y) {
	Defender.call(this, x, y, 48, 48, 'kitten', 60, 0.5, 1, 3);
}
Kitten.prototype = Object.create(Defender.prototype);
Kitten.prototype.constructor = Kitten;
/** 
* Enemy base class
*/ 
function Enemy(x, y, width, height, assetId, health, speed, pointValue) {
	GameObject.call(this, x, y, width, height, assetId);
	this.health = health;
	this.maxHealth = health;
	this.speed = speed;
	this.pointValue = pointValue;
	this.targetX = LK.canvas.width / 2;
	this.targetY = LK.canvas.height / 2;
}
Enemy.prototype = Object.create(GameObject.prototype);
Enemy.prototype.constructor = Enemy;
Enemy.prototype.update = function (deltaTime) {
	if (!this.active) {
		return;
	}
	// Move towards center
	var dx = this.targetX - (this.x + this.width / 2);
	var dy = this.targetY - (this.y + this.height / 2);
	var dist = Math.sqrt(dx * dx + dy * dy);
	if (dist > 10) {
		// Not too close to center
		var moveX = dx / dist * this.speed * deltaTime;
		var moveY = dy / dist * this.speed * deltaTime;
		this.x += moveX;
		this.y += moveY;
	} else {
		// Reached center, remove
		this.active = false;
	}
};
Enemy.prototype.takeDamage = function (amount) {
	this.health -= amount;
	if (this.health <= 0) {
		this.defeat();
	}
};
Enemy.prototype.defeat = function () {
	this.active = false;
	// Add points
	var pointsEarned = this.pointValue * multiplier;
	score += pointsEarned;
	enemiesDefeated++;
	// Check for level up
	if (enemiesDefeated >= ENEMIES_PER_LEVEL) {
		levelUp();
	}
	// Create sparkles
	for (var i = 0; i < 5; i++) {
		createSparkle(this.x + Math.random() * this.width, this.y + Math.random() * this.height, 'defeat');
	}
	// Chance to spawn power-up
	if (Math.random() < 0.2) {
		// 20% chance
		spawnPowerUp(this.x, this.y);
	}
};
/** 
* Bird Class - Basic enemy
*/ 
function Bird(x, y) {
	GameObject.call(this, x, y, 80, 80, 'bird');
	this.health = 20;
	this.speed = 50 + Math.random() * 30;
	this.targetX = LK.canvas.width / 2 + (Math.random() - 0.5) * 200;
	this.targetY = LK.canvas.height / 2 + (Math.random() - 0.5) * 200;
}
Bird.prototype = Object.create(GameObject.prototype);
Bird.prototype.constructor = Bird;
Bird.prototype.update = function (deltaTime) {
	this.lastX = this.x; // Update last X position
	this.lastY = this.y; // Update last Y position
	// Move towards target
	var dx = this.targetX - this.x;
	var dy = this.targetY - this.y;
	var dist = Math.sqrt(dx * dx + dy * dy);
	if (dist > 5) {
		this.x += dx / dist * this.speed * deltaTime;
		this.y += dy / dist * this.speed * deltaTime;
	} else {
		// Pick a new target
		this.targetX = Math.random() * LK.canvas.width;
		this.targetY = Math.random() * LK.canvas.height;
	}
	// Check if bird reached a specific X position
	if (this.lastX <= 100 && this.x > 100) {
		console.log("Bird reached X position 100");
	}
};
Bird.prototype.takeDamage = function (amount) {
	this.health -= amount;
	if (this.health <= 0) {
		this.active = false;
		enemiesDefeated++;
		// Check for level up
		if (enemiesDefeated >= ENEMIES_PER_LEVEL) {
			levelUp();
		}
		// Chance to spawn power-up
		if (Math.random() < 0.2) {
			var powerUpType = ['speed', 'damage', 'range', 'multi', 'time', 'chain'][Math.floor(Math.random() * 6)];
			spawnPowerUp(this.x, this.y, powerUpType);
		}
	}
};
/** 
* UFO Class - Advanced enemy
*/ 
function UFO(x, y) {
	GameObject.call(this, x, y, 120, 120, 'ufo');
	this.health = 50;
	this.speed = 30 + Math.random() * 20;
	this.targetX = LK.canvas.width / 2 + (Math.random() - 0.5) * 300;
	this.targetY = LK.canvas.height / 2 + (Math.random() - 0.5) * 300;
}
UFO.prototype = Object.create(GameObject.prototype);
UFO.prototype.constructor = UFO;
UFO.prototype.update = function (deltaTime) {
	this.lastX = this.x; // Update last X position
	this.lastY = this.y; // Update last Y position
	// Similar to Bird but with different values
	var dx = this.targetX - this.x;
	var dy = this.targetY - this.y;
	var dist = Math.sqrt(dx * dx + dy * dy);
	if (dist > 5) {
		this.x += dx / dist * this.speed * deltaTime;
		this.y += dy / dist * this.speed * deltaTime;
	} else {
		this.targetX = Math.random() * LK.canvas.width;
		this.targetY = Math.random() * LK.canvas.height;
	}
	// Check if UFO reached a specific Y position
	if (this.lastY <= 200 && this.y > 200) {
		console.log("UFO reached Y position 200");
	}
};
UFO.prototype.takeDamage = function (amount) {
	this.health -= amount;
	if (this.health <= 0) {
		this.active = false;
		enemiesDefeated++;
		if (enemiesDefeated >= ENEMIES_PER_LEVEL) {
			levelUp();
		}
		// Higher chance to spawn power-up
		if (Math.random() < 0.4) {
			var powerUpType = ['speed', 'damage', 'range', 'multi', 'time', 'chain'][Math.floor(Math.random() * 6)];
			spawnPowerUp(this.x, this.y, powerUpType);
		}
	}
};
/** 
* PowerUp Class
*/ 
function PowerUp(x, y, type) {
	GameObject.call(this, x, y, 50, 50, 'powerup_' + type);
	this.type = type;
	this.lifetime = 10; // Disappears after 10 seconds
}
PowerUp.prototype = Object.create(GameObject.prototype);
PowerUp.prototype.constructor = PowerUp;
PowerUp.prototype.update = function (deltaTime) {
	this.lastX = this.x; // Update last X position
	this.lastY = this.y; // Update last Y position
	this.lifetime -= deltaTime;
	if (this.lifetime <= 0) {
		this.active = false;
	}
	// Check for collision with cats or kittens
	for (var i = 0; i < cats.length; i++) {
		if (this.isColliding(cats[i])) {
			this.applyPowerUp(cats[i]);
			this.active = false;
			return;
		}
	}
	for (var i = 0; i < kittens.length; i++) {
		if (this.isColliding(kittens[i])) {
			this.applyPowerUp(kittens[i]);
			this.active = false;
			return;
		}
	}
	// Check if PowerUp reached a specific X, Y position
	if (this.lastX <= 150 && this.x > 150 && this.lastY <= 150 && this.y > 150) {
		console.log("PowerUp reached X, Y position 150, 150");
	}
};
PowerUp.prototype.applyPowerUp = function (target) {
	// Apply power-up effect based on type
	switch (this.type) {
		case 'speed':
			target.attackInterval *= 0.8;
			break;
		case 'damage':
			// Would need to add a damage property to cats/kittens
			break;
		case 'range':
			target.attackRange *= 1.2;
			break;
		case 'multi':
			multiplier += 0.1;
			break;
		case 'time':
			// Would need to implement a time slow effect
			break;
		case 'chain':
			// Would need to implement chain attack
			break;
	}
	// Create sparkle effect
	createSparkle(this.x, this.y, 'powerup');
};
/** 
* Sparkle Class - Visual effects
*/ 
function Sparkle(x, y, type) {
	GameObject.call(this, x, y, 30, 30, 'sparkle');
	this.type = type;
	this.lifetime = 0.5; // Disappears after 0.5 seconds
	this.scale = 1.0;
}
Sparkle.prototype = Object.create(GameObject.prototype);
Sparkle.prototype.constructor = Sparkle;
Sparkle.prototype.update = function (deltaTime) {
	this.lifetime -= deltaTime;
	this.scale -= deltaTime * 1.5;
	if (this.lifetime <= 0 || this.scale <= 0) {
		this.active = false;
		// Remove from sparkles array
		var index = sparkles.indexOf(this);
		if (index !== -1) {
			sparkles.splice(index, 1);
		}
	}
};
Sparkle.prototype.render = function () {
	// Override render to add scaling effect
	if (!this.active) {
		return;
	}
	try {
		var sprite = LK.getAsset(this.assetId, {});
		if (!sprite) {
			console.error("Failed to get asset:", this.assetId);
			return;
		}
		sprite.x = this.x;
		sprite.y = this.y;
		sprite.width = this.width * this.scale;
		sprite.height = this.height * this.scale;
		// Add the sprite directly to the game stage
		game.stage.addChild(sprite);
	} catch (e) {
		console.error("Error rendering", this.constructor.name, ":", e);
	}
};
// --- Game Functions ---
// Spawn a bird at a random edge position
function spawnBird() {
	if (birds.length >= MAX_BIRDS) {
		return null;
	}
	var x, y;
	var side = Math.floor(Math.random() * 4);
	switch (side) {
		case 0:
			// Top
			x = Math.random() * LK.canvas.width;
			y = -32;
			break;
		case 1:
			// Right
			x = LK.canvas.width + 32;
			y = Math.random() * LK.canvas.height;
			break;
		case 2:
			// Bottom
			x = Math.random() * LK.canvas.width;
			y = LK.canvas.height + 32;
			break;
		case 3:
			// Left
			x = -32;
			y = Math.random() * LK.canvas.height;
			break;
	}
	var bird = new Bird(x, y);
	birds.push(bird);
	return bird;
}
// Spawn a UFO at a random edge position
function spawnUFO() {
	if (ufos.length >= MAX_UFOS) {
		return;
	}
	var x, y;
	var side = Math.floor(Math.random() * 4);
	switch (side) {
		case 0:
			// Top
			x = Math.random() * LK.canvas.width;
			y = -32;
			break;
		case 1:
			// Right
			x = LK.canvas.width + 64;
			y = Math.random() * LK.canvas.height;
			break;
		case 2:
			// Bottom
			x = Math.random() * LK.canvas.width;
			y = LK.canvas.height + 32;
			break;
		case 3:
			// Left
			x = -64;
			y = Math.random() * LK.canvas.height;
			break;
	}
	var ufo = new UFO(x, y);
	ufos.push(ufo);
	return ufo;
}
// Spawn a power-up
function spawnPowerUp(x, y, type) {
	// If type not specified, choose random
	if (!type) {
		var types = ['speed', 'damage', 'range', 'multi', 'chain', 'time'];
		type = types[Math.floor(Math.random() * types.length)];
	}
	var powerUp = new PowerUp(x, y, type);
	powerUps.push(powerUp);
	return powerUp;
}
// Level up function
function levelUp() {
	level++;
	multiplier = 1.0 + (level - 1) * 0.1;
	// Create level up effect
	var centerX = LK.canvas.width / 2;
	var centerY = LK.canvas.height / 2;
	// Create sparkles for level up effect
	for (var i = 0; i < 20; i++) {
		createSparkle(centerX + (Math.random() - 0.5) * 200, centerY + (Math.random() - 0.5) * 200, 'powerup');
	}
	// Reset enemy counter
	enemiesDefeated = 0;
	// Play level up sound
	LK.playSound('teslacoil');
}
// Calculate idle points
function calculateIdlePoints() {
	var now = Date.now();
	var elapsed = (now - idlePointsLastCalculated) / 1000; // Convert to seconds
	if (elapsed > 0) {
		var pointsPerSecond = cats.length * BASE_IDLE_POINTS_RATE * multiplier;
		idlePoints += pointsPerSecond * elapsed;
		idlePointsLastCalculated = now;
	}
}
// Update game state
function updateGame(deltaTime) {
	// Calculate idle points
	calculateIdlePoints();
	// Update all game objects
	// Update cats
	for (var i = cats.length - 1; i >= 0; i--) {
		var cat = cats[i];
		cat.update(deltaTime);
	}
	// Update kittens
	for (var i = kittens.length - 1; i >= 0; i--) {
		var kitten = kittens[i];
		kitten.update(deltaTime);
	}
	// Update birds and remove inactive ones
	for (var i = birds.length - 1; i >= 0; i--) {
		var bird = birds[i];
		bird.update(deltaTime);
		if (!bird.active) {
			birds.splice(i, 1);
		}
	}
	// Update UFOs and remove inactive ones
	for (var i = ufos.length - 1; i >= 0; i--) {
		var ufo = ufos[i];
		ufo.update(deltaTime);
		if (!ufo.active) {
			ufos.splice(i, 1);
		}
	}
	// Update power-ups and remove inactive ones
	for (var i = powerUps.length - 1; i >= 0; i--) {
		var powerUp = powerUps[i];
		powerUp.update(deltaTime);
		if (!powerUp.active) {
			powerUps.splice(i, 1);
		}
	}
	// Update sparkles and remove inactive ones
	for (var i = sparkles.length - 1; i >= 0; i--) {
		var sparkle = sparkles[i];
		sparkle.update(deltaTime);
		if (!sparkle.active) {
			sparkles.splice(i, 1);
		}
	}
	// Spawn birds
	birdSpawnTimer += deltaTime * 1000; // Convert to milliseconds
	if (birds.length < MAX_BIRDS && birdSpawnTimer >= BIRD_SPAWN_INTERVAL) {
		spawnBird();
		birdSpawnTimer = 0;
		LK.playSound('wings1', {
			volume: 0.2
		});
	}
	// Spawn UFOs
	ufoSpawnTimer += deltaTime * 1000; // Convert to milliseconds
	if (ufos.length < MAX_UFOS && ufoSpawnTimer >= UFO_SPAWN_INTERVAL && level >= 3) {
		spawnUFO();
		ufoSpawnTimer = 0;
		LK.playSound('ufo1');
	}
}
// Render game
function renderGame() {
	// Clear the stage before rendering
	game.stage.removeChildren();
	// Draw background
	var background = new Graphics();
	background.beginFill(0x1a1a2e);
	background.drawRect(0, 0, LK.canvas.width, LK.canvas.height);
	background.endFill();
	game.stage.addChild(background);
	// Render all game objects
	// Render sparkles first (background layer)
	for (var i = 0; i < sparkles.length; i++) {
		var sparkle = sparkles[i];
		sparkle.render();
	}
	// Render power-ups
	for (var i = 0; i < powerUps.length; i++) {
		var powerUp = powerUps[i];
		powerUp.render();
	}
	// Render birds
	for (var i = 0; i < birds.length; i++) {
		var bird = birds[i];
		bird.render();
	}
	// Render UFOs
	for (var i = 0; i < ufos.length; i++) {
		var ufo = ufos[i];
		ufo.render();
	}
	// Render cats
	for (var i = 0; i < cats.length; i++) {
		var cat = cats[i];
		cat.render();
	}
	// Render kittens
	for (var i = 0; i < kittens.length; i++) {
		var kitten = kittens[i];
		kitten.render();
	}
	// Render UI
	renderUI();
}
// Render UI elements
function renderUI() {
	// Create text objects for UI elements
	// Score
	var scoreText = new Text("Score: " + Math.floor(score), {
		fontFamily: 'Arial',
		fontSize: 24,
		fill: 0xFFFFFF,
		align: 'center'
	});
	scoreText.x = LK.canvas.width / 2 - scoreText.width / 2;
	scoreText.y = 30;
	game.stage.addChild(scoreText);
	// Level
	var levelText = new Text("Level: " + level, {
		fontFamily: 'Arial',
		fontSize: 18,
		fill: 0xFFFFFF,
		align: 'right'
	});
	levelText.x = LK.canvas.width - 20 - levelText.width;
	levelText.y = 30;
	game.stage.addChild(levelText);
	// Multiplier
	var multiplierText = new Text("Multiplier: x" + multiplier.toFixed(1), {
		fontFamily: 'Arial',
		fontSize: 18,
		fill: 0xFFFFFF,
		align: 'right'
	});
	multiplierText.x = LK.canvas.width - 20 - multiplierText.width;
	multiplierText.y = 60;
	game.stage.addChild(multiplierText);
	// Idle Points
	var idlePointsText = new Text("Idle Points: " + Math.floor(idlePoints), {
		fontFamily: 'Arial',
		fontSize: 18,
		fill: 0xFFFFFF,
		align: 'right'
	});
	idlePointsText.x = LK.canvas.width - 20 - idlePointsText.width;
	idlePointsText.y = LK.canvas.height - 20;
	game.stage.addChild(idlePointsText);
	// Enemies Defeated
	var enemiesText = new Text("Enemies: " + enemiesDefeated + "/" + ENEMIES_PER_LEVEL, {
		fontFamily: 'Arial',
		fontSize: 18,
		fill: 0xFFFFFF,
		align: 'left'
	});
	enemiesText.x = 20;
	enemiesText.y = 30;
	game.stage.addChild(enemiesText);
	// Cat Count
	var catCountText = new Text("Cats: " + cats.length, {
		fontFamily: 'Arial',
		fontSize: 18,
		fill: 0xFFFFFF,
		align: 'left'
	});
	catCountText.x = 20;
	catCountText.y = 60;
	game.stage.addChild(catCountText);
	// Kitten Count
	var kittenCountText = new Text("Kittens: " + kittens.length, {
		fontFamily: 'Arial',
		fontSize: 18,
		fill: 0xFFFFFF,
		align: 'left'
	});
	kittenCountText.x = 20;
	kittenCountText.y = 90;
	game.stage.addChild(kittenCountText);
	// Spawn buttons
	renderButton("Add Cat (50)", 20, LK.canvas.height - 60, 120, 40, idlePoints >= 50);
	renderButton("Add Kitten (30)", 150, LK.canvas.height - 60, 120, 40, idlePoints >= 30);
}
// Render a button
function renderButton(text, x, y, width, height, enabled) {
	// Create a graphics object for the button
	var button = new Graphics();
	// Button background
	button.beginFill(enabled ? 0x33aa33 : 0x666666);
	button.drawRect(x, y, width, height);
	button.endFill();
	// Button border
	button.lineStyle(1, 0xFFFFFF);
	button.drawRect(x, y, width, height);
	// Add button to stage
	game.stage.addChild(button);
	// Button text
	var buttonText = new Text(text, {
		fontFamily: 'Arial',
		fontSize: 14,
		fill: 0xFFFFFF,
		align: 'center'
	});
	buttonText.x = x + width / 2 - buttonText.width / 2;
	buttonText.y = y + height / 2 - buttonText.height / 2;
	game.stage.addChild(buttonText);
}
// Handle mouse click
function handleMouseClick(x, y) {
	// Check if cat spawn button clicked
	if (x >= 20 && x <= 140 && y >= LK.canvas.height - 60 && y <= LK.canvas.height - 20) {
		if (idlePoints >= 50) {
			var cat = spawnCat(Math.random() * LK.canvas.width, Math.random() * LK.canvas.height);
			if (cat) {
				LK.playSound('chitter');
			}
		}
	}
	// Check if kitten spawn button clicked
	if (x >= 150 && x <= 270 && y >= LK.canvas.height - 60 && y <= LK.canvas.height - 20) {
		if (idlePoints >= 30) {
			var kitten = spawnKitten(Math.random() * LK.canvas.width, Math.random() * LK.canvas.height);
			if (kitten) {
				LK.playSound('chitter', {
					pitch: 1.5
				});
			}
		}
	}
}
// Initialize game
function initGame() {
	console.log("Initializing game...");
	// Reset game state
	cats = [];
	kittens = [];
	birds = [];
	ufos = [];
	powerUps = [];
	sparkles = [];
	score = 0;
	level = 1;
	multiplier = 1.0;
	idlePoints = 100; // Start with enough for 2 cats or 3 kittens
	enemiesDefeated = 0;
	lastUpdateTime = Date.now();
	idlePointsLastCalculated = Date.now();
	birdSpawnTimer = 0;
	ufoSpawnTimer = 0;
	// Create initial cats
	var initialCat = spawnCat(LK.canvas.width / 2, LK.canvas.height / 2);
	console.log("Initial cat created:", initialCat);
	// Create initial kittens
	var initialKitten = spawnKitten(LK.canvas.width / 2 + 100, LK.canvas.height / 2);
	console.log("Initial kitten created:", initialKitten);
	// Force spawn a bird for testing
	var testBird = spawnBird();
	console.log("Test bird created:", testBird);
	// Force spawn a UFO for testing
	var testUFO = spawnUFO();
	console.log("Test UFO created:", testUFO);
	// Force spawn a power-up for testing
	var testPowerUp = spawnPowerUp(LK.canvas.width / 2, LK.canvas.height / 2, 'speed');
	console.log("Test power-up created:", testPowerUp);
	// Create initial sparkle for testing
	var testSparkle = createSparkle(LK.canvas.width / 2, LK.canvas.height / 2, 'test');
	console.log("Test sparkle created:", testSparkle);
	// Setup mouse click handler
	LK.onMouseDown = function (event) {
		console.log("Mouse clicked at:", event.x, event.y);
		handleMouseClick(event.x, event.y);
	};
	// Start game loop
	startGameLoop();
	console.log("Game loop started");
}
// Game loop
var lastFrameTime = 0;
function gameLoop(timestamp) {
	// Calculate delta time
	var deltaTime = (timestamp - lastFrameTime) / 1000; // Convert to seconds
	lastFrameTime = timestamp;
	// Cap delta time to prevent large jumps
	if (deltaTime > 0.1) {
		deltaTime = 0.1;
	}
	// Update game state
	updateGame(deltaTime);
	// Render game
	renderGame();
	// Log game state for debugging
	console.log("Game state - Cats:", cats.length, "Birds:", birds.length, "UFOs:", ufos.length);
	// Request next frame
	requestAnimationFrame(gameLoop);
}
// Start game loop
function startGameLoop() {
	lastFrameTime = performance.now();
	requestAnimationFrame(gameLoop);
}
// Initialize game when page loads
window.onload = function () {
	console.log("Game initializing...");
	initGame();
};
// Spawn a cat at the specified position
function spawnCat(x, y) {
	if (idlePoints >= 50) {
		idlePoints -= 50;
		var cat = new Cat(x, y);
		cats.push(cat);
		console.log("Cat spawned at:", x, y);
		return cat;
	}
	return null;
}
// Spawn a kitten at the specified position
function spawnKitten(x, y) {
	if (idlePoints >= 30) {
		idlePoints -= 30;
		var kitten = new Kitten(x, y);
		kittens.push(kitten);
		return kitten;
	}
	return null;
}
// Create a sparkle effect
function createSparkle(x, y, type) {
	var sparkle = new Sparkle(x, y, type);
	sparkles.push(sparkle);
	return sparkle;
}
/** 
* Base class for game entities
*/ 
GameObject.prototype.update = function (deltaTime) {
	this.lastX = this.x; // Update last X position
	this.lastY = this.y; // Update last Y position
	// Override in subclasses
};
GameObject.prototype.render = function () {
	if (!this.active) {
		return;
	}
	try {
		// Draw the sprite using LK.getAsset
		var sprite = LK.getAsset(this.assetId, {});
		if (!sprite) {
			console.error("Failed to get asset:", this.assetId);
			return;
		}
		sprite.x = this.x;
		sprite.y = this.y;
		sprite.width = this.width;
		sprite.height = this.height;
		// Add the sprite directly to the game stage
		game.stage.addChild(sprite);
		console.log("Rendered:", this.constructor.name, "at", this.x, this.y);
	} catch (e) {
		console.error("Error rendering", this.constructor.name, ":", e);
	}
};
GameObject.prototype.isColliding = function (other) {
	return this.x < other.x + other.width && this.x + this.width > other.x && this.y < other.y + other.height && this.y + this.height > other.y;
};

===================================================================
--- original.js
+++ change.js
@@ -7,10 +7,10 @@
 
 /**** 
 * Game Code
 ****/ 
-// Add sparkle asset
 // Make sure the game has a stage property
+// Add sparkle asset
 if (!game.stage) {
 	game.stage = new Container();
 }
 // --- Global Variables ---
@@ -902,5 +902,38 @@
 function createSparkle(x, y, type) {
 	var sparkle = new Sparkle(x, y, type);
 	sparkles.push(sparkle);
 	return sparkle;
-}
\ No newline at end of file
+}
+/** 
+* Base class for game entities
+*/ 
+GameObject.prototype.update = function (deltaTime) {
+	this.lastX = this.x; // Update last X position
+	this.lastY = this.y; // Update last Y position
+	// Override in subclasses
+};
+GameObject.prototype.render = function () {
+	if (!this.active) {
+		return;
+	}
+	try {
+		// Draw the sprite using LK.getAsset
+		var sprite = LK.getAsset(this.assetId, {});
+		if (!sprite) {
+			console.error("Failed to get asset:", this.assetId);
+			return;
+		}
+		sprite.x = this.x;
+		sprite.y = this.y;
+		sprite.width = this.width;
+		sprite.height = this.height;
+		// Add the sprite directly to the game stage
+		game.stage.addChild(sprite);
+		console.log("Rendered:", this.constructor.name, "at", this.x, this.y);
+	} catch (e) {
+		console.error("Error rendering", this.constructor.name, ":", e);
+	}
+};
+GameObject.prototype.isColliding = function (other) {
+	return this.x < other.x + other.width && this.x + this.width > other.x && this.y < other.y + other.height && this.y + this.height > other.y;
+};
\ No newline at end of file