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

/**** 
* Classes
****/ 
var Boss = Container.expand(function () {
	var self = Container.call(this);
	var bossGraphic = self.attachAsset('boss', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	self.speed = 1.5;
	self.health = 10;
	self.attackCooldown = 0;
	self.attackPattern = 0;
	self.scoreValue = 2000;
	self.active = true;
	self.init = function (x, y) {
		self.x = x;
		self.y = y;
		return self;
	};
	self.takeDamage = function () {
		if (!self.active) {
			return;
		}
		// Increased damage based on hero's dash combo
		var damageAmount = 1;
		if (hero && hero.consecutiveDashes > 0) {
			damageAmount = Math.min(3, 1 + Math.floor(hero.consecutiveDashes / 2));
		}
		self.health -= damageAmount;
		// Flash boss
		LK.effects.flashObject(self, 0xffffff, 300);
		LK.getSound('hit').play();
		if (self.health <= 0) {
			self.die();
		} else {
			// Speed up as health decreases
			self.speed = 1.5 + (10 - self.health) * 0.2;
		}
	};
	self.die = function () {
		if (!self.active) {
			return;
		}
		self.active = false;
		LK.getSound('bossDeath').play();
		// Flash and fade out
		LK.effects.flashObject(self, 0xffff00, 500);
		tween(self, {
			alpha: 0
		}, {
			duration: 1000,
			onFinish: function onFinish() {
				self.destroy();
			}
		});
		currentWave++;
		bossDefeated = true;
		nextWaveTimer = 180; // 3 seconds until next wave
		return self.scoreValue;
	};
	self.update = function () {
		if (!self.active) {
			return;
		}
		// Move toward hero but more intelligently
		if (hero) {
			var dx = hero.x - self.x;
			var dy = hero.y - self.y;
			var dist = Math.sqrt(dx * dx + dy * dy);
			// Different movement patterns
			if (self.attackPattern === 0) {
				// Direct approach
				if (dist > 0) {
					self.x += dx / dist * self.speed;
					self.y += dy / dist * self.speed;
				}
			} else if (self.attackPattern === 1) {
				// Circle around
				var angle = Math.atan2(dy, dx) + Math.PI / 4;
				self.x += Math.cos(angle) * self.speed * 1.5;
				self.y += Math.sin(angle) * self.speed * 1.5;
			} else if (self.attackPattern === 2) {
				// Charge attack
				if (self.attackCooldown > 30) {
					self.x += dx / dist * self.speed * 2.5;
					self.y += dy / dist * self.speed * 2.5;
				} else {
					// Wait
				}
			}
			if (hero.invulnerable <= 0 && !hero.isDashing) {
				if (self.intersects(hero)) {
					hero.takeDamage();
				}
			}
		}
		// Attack pattern cooldown
		self.attackCooldown--;
		if (self.attackCooldown <= 0) {
			self.attackPattern = (self.attackPattern + 1) % 3;
			self.attackCooldown = 120; // 2 seconds per pattern
		}
		// Keep within screen bounds
		self.x = Math.max(100, Math.min(2048 - 100, self.x));
		self.y = Math.max(100, Math.min(2732 - 100, self.y));
	};
	return self;
});
var Bullet = Container.expand(function () {
	var self = Container.call(this);
	var bulletGraphic = self.attachAsset('bullet', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	bulletGraphic.tint = 0x3498db; // Blue bullet for the hero
	self.speed = 15;
	self.damage = 1;
	self.active = true;
	self.init = function (x, y, direction) {
		self.x = x;
		self.y = y;
		self.direction = direction || {
			x: 0,
			y: -1
		}; // Default direction is up
		return self;
	};
	self.update = function () {
		if (!self.active) {
			return;
		}
		// Move in the specified direction
		self.x += self.direction.x * self.speed;
		self.y += self.direction.y * self.speed;
		// Remove if off-screen
		if (self.x < -50 || self.x > 2048 + 50 || self.y < -50 || self.y > 2732 + 50) {
			self.destroy();
		}
	};
	return self;
});
var DashTrail = Container.expand(function () {
	var self = Container.call(this);
	var trailGraphic = self.attachAsset('dashTrail', {
		anchorX: 0.5,
		anchorY: 0.5,
		alpha: 0.7
	});
	self.init = function (x, y) {
		self.x = x;
		self.y = y;
		self.lifetime = 20; // frames the trail will live
		return self;
	};
	self.update = function () {
		self.lifetime--;
		trailGraphic.alpha = self.lifetime / 20 * 0.7;
		if (self.lifetime <= 0) {
			self.destroy();
		}
	};
	return self;
});
var Enemy = Container.expand(function () {
	var self = Container.call(this);
	var enemyGraphic = self.attachAsset('enemy', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	self.speed = 2;
	self.health = 1;
	self.scoreValue = 100;
	self.active = true;
	self.init = function (x, y) {
		self.x = x;
		self.y = y;
		return self;
	};
	self.takeDamage = function () {
		if (!self.active) {
			return;
		}
		// Increased damage when hero has consecutive dashes
		var damageAmount = 1;
		if (hero && hero.consecutiveDashes > 0) {
			damageAmount = Math.min(3, 1 + hero.consecutiveDashes);
		}
		self.health -= damageAmount;
		if (self.health <= 0) {
			self.die();
		} else {
			// Flash enemy
			LK.effects.flashObject(self, 0xffffff, 200);
		}
	};
	self.die = function () {
		if (!self.active) {
			return;
		}
		self.active = false;
		LK.getSound('hit').play();
		// Flash and fade out
		tween(self, {
			alpha: 0
		}, {
			duration: 300,
			onFinish: function onFinish() {
				self.destroy();
			}
		});
		return self.scoreValue;
	};
	self.update = function () {
		if (!self.active) {
			return;
		}
		// Move toward hero
		if (hero && !hero.isDashing) {
			var dx = hero.x - self.x;
			var dy = hero.y - self.y;
			var dist = Math.sqrt(dx * dx + dy * dy);
			if (dist > 0) {
				self.x += dx / dist * self.speed;
				self.y += dy / dist * self.speed;
			}
		}
		// Check for collision with hero
		if (hero && !hero.isDashing && hero.invulnerable <= 0) {
			if (self.intersects(hero)) {
				hero.takeDamage();
			}
		}
	};
	return self;
});
var Hero = Container.expand(function () {
	var self = Container.call(this);
	var heroGraphic = self.attachAsset('hero', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	// Simple click handler that does nothing (placeholder)
	self.down = function (x, y, obj) {
		// No auto-shoot toggle functionality
	};
	self.shootSpeed = 15; // Bullet speed
	self.fireRate = 15; // Frames between shots
	self.shootCooldown = 0;
	self.health = 3;
	self.invulnerable = 0;
	self.combo = 0;
	self.score = 0;
	self.powerBoost = 1; // Base power multiplier
	self.shootBullet = function (targetX, targetY) {
		if (self.shootCooldown > 0) {
			return;
		}
		var dx = targetX - self.x;
		var dy = targetY - self.y;
		var distance = Math.sqrt(dx * dx + dy * dy);
		// Normalize direction
		var dirX = dx / distance;
		var dirY = dy / distance;
		// Create bullet
		var bullet = new Bullet().init(self.x, self.y, {
			x: dirX,
			y: dirY
		});
		bullet.damage = self.powerBoost; // Apply power boost to bullet damage
		// Visual shooting effect
		tween(heroGraphic, {
			scaleX: 1.2,
			scaleY: 0.9
		}, {
			duration: 100,
			easing: tween.easeOut,
			onFinish: function onFinish() {
				tween(heroGraphic, {
					scaleX: 1,
					scaleY: 1
				}, {
					duration: 200,
					easing: tween.elasticOut
				});
			}
		});
		// Set cooldown
		self.shootCooldown = self.fireRate;
		// Add bullet to game
		game.addChild(bullet);
		if (!bullets) {
			bullets = [];
		}
		bullets.push(bullet);
		// Play shoot sound
		LK.getSound('hit').play();
	};
	self.takeDamage = function () {
		if (self.invulnerable > 0) {
			return;
		}
		self.health--;
		self.invulnerable = 60; // invulnerable for 1 second
		self.combo = 0; // Reset combo
		// Flash hero red
		LK.effects.flashObject(self, 0xff0000, 500);
		// Play damage sound
		LK.getSound('damage').play();
		if (self.health <= 0) {
			LK.showGameOver();
		}
	};
	self.addScore = function (points) {
		self.combo++;
		var comboMultiplier = Math.min(4, 1 + self.combo * 0.1);
		var scoreToAdd = Math.floor(points * comboMultiplier);
		self.score += scoreToAdd;
		LK.setScore(self.score);
	};
	self.update = function () {
		// Keep within screen bounds
		self.x = Math.max(50, Math.min(2048 - 50, self.x));
		self.y = Math.max(50, Math.min(2732 - 50, self.y));
		// Cooldowns
		if (self.shootCooldown > 0) {
			self.shootCooldown--;
		}
		if (self.invulnerable > 0) {
			self.invulnerable--;
			// Flicker effect during invulnerability
			heroGraphic.alpha = LK.ticks % 6 < 3 ? 0.4 : 1;
		} else {
			// Normal appearance when not invulnerable
			heroGraphic.alpha = 1;
			heroGraphic.tint = 0xFFFFFF; // Normal color
		}
	};
	return self;
});
var PowerUp = Container.expand(function () {
	var self = Container.call(this);
	var powerUpGraphic = self.attachAsset('powerUp', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	self.type = 'health'; // Default type
	self.active = true;
	self.lifetime = 300; // 5 seconds
	self.init = function (x, y, type) {
		self.x = x;
		self.y = y;
		self.type = type || self.type;
		// Set color based on type
		if (self.type === 'health') {
			powerUpGraphic.tint = 0x2ecc71; // Green
		} else if (self.type === 'speed') {
			powerUpGraphic.tint = 0x3498db; // Blue
		} else if (self.type === 'power') {
			powerUpGraphic.tint = 0xe74c3c; // Red
		} else if (self.type === 'strength') {
			powerUpGraphic.tint = 0x9b59b6; // Purple
		}
		return self;
	};
	self.collect = function () {
		if (!self.active) {
			return;
		}
		self.active = false;
		LK.getSound('powerup').play();
		if (self.type === 'health' && hero.health < 3) {
			hero.health++;
		} else if (self.type === 'speed') {
			hero.dashSpeed = 80; // Even faster dash
			hero.dashDistance = 900; // Even longer dash
			// Visual indicator of speed boost
			tween(hero, {
				alpha: 0.7
			}, {
				duration: 200,
				onFinish: function onFinish() {
					tween(hero, {
						alpha: 1
					}, {
						duration: 200
					});
				}
			});
			// Reset after 10 seconds
			LK.setTimeout(function () {
				if (hero) {
					hero.dashSpeed = 60;
					hero.dashDistance = 700;
				}
			}, 10000);
		} else if (self.type === 'strength') {
			// Increase hero's attack strength more permanently
			hero.powerBoost = Math.min(5, hero.powerBoost + 1);
			// Visual indicator of strength boost
			tween(hero, {
				tint: 0x9b59b6
			}, {
				duration: 500,
				onFinish: function onFinish() {
					tween(hero, {
						tint: 0xFFFFFF
					}, {
						duration: 500
					});
				}
			});
			// Show strength level
			var strengthTxt = new Text2('STRENGTH +' + hero.powerBoost + '!', {
				size: 80,
				fill: 0x9b59b6
			});
			strengthTxt.anchor.set(0.5, 0.5);
			strengthTxt.x = 2048 / 2;
			strengthTxt.y = 2732 / 2;
			game.addChild(strengthTxt);
			// Fade out the text
			tween(strengthTxt, {
				alpha: 0,
				y: strengthTxt.y - 100
			}, {
				duration: 1500,
				onFinish: function onFinish() {
					strengthTxt.destroy();
				}
			});
		} else if (self.type === 'power') {
			// Clear all enemies
			for (var i = enemies.length - 1; i >= 0; i--) {
				if (enemies[i].active) {
					var points = enemies[i].die();
					hero.addScore(points);
				}
			}
			// Increase hero's attack strength
			hero.powerBoost = 3;
			// Visual indicator of power boost
			tween(hero, {
				tint: 0xFF0000
			}, {
				duration: 300
			});
			// Reset after 10 seconds
			LK.setTimeout(function () {
				if (hero) {
					hero.powerBoost = 1;
					tween(hero, {
						tint: 0xFFFFFF
					}, {
						duration: 500
					});
				}
			}, 10000);
		}
		// Flash and fade out
		tween(self, {
			alpha: 0,
			scaleX: 2,
			scaleY: 2
		}, {
			duration: 300,
			onFinish: function onFinish() {
				self.destroy();
			}
		});
	};
	self.update = function () {
		if (!self.active) {
			return;
		}
		// Floating animation
		self.y += Math.sin(LK.ticks * 0.1) * 0.5;
		// Rotate slowly
		powerUpGraphic.rotation += 0.02;
		// Check for collision with hero
		if (hero && (hero.intersects(self) || hero.isDashing && self.distanceTo(hero) < 100)) {
			self.collect();
		}
		// Expire after lifetime
		self.lifetime--;
		if (self.lifetime <= 0) {
			tween(self, {
				alpha: 0
			}, {
				duration: 300,
				onFinish: function onFinish() {
					self.destroy();
				}
			});
			self.active = false;
		}
	};
	self.distanceTo = function (target) {
		var dx = target.x - self.x;
		var dy = target.y - self.y;
		return Math.sqrt(dx * dx + dy * dy);
	};
	return self;
});

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

/**** 
* Game Code
****/ 
// Game state variables
var hero;
var enemies = [];
var bullets = [];
var powerUps = [];
var trails = [];
var currentWave = 1;
var nextWaveTimer = 0;
var spawnTimer = 0;
var bossDefeated = false;
var swipeStart = {
	x: 0,
	y: 0
};
var isSwipeActive = false;
// UI elements
var scoreTxt;
var waveTxt;
var healthTxt;
var comboTxt;
// Game constants
var SPAWN_INTERVAL = 120; // Frames between enemy spawns (increased from 60)
var POWER_UP_CHANCE = 0.15; // Chance to spawn power-up on enemy defeat
var WAVE_ENEMY_COUNT = 5; // Enemies per wave (reduced from 10)
// Initialize game elements
function initGame() {
	// Create hero
	hero = new Hero();
	hero.x = 2048 / 2;
	hero.y = 2732 / 2;
	game.addChild(hero);
	// Auto-shoot indicator removed
	// Create UI elements
	scoreTxt = new Text2('Score: 0', {
		size: 60,
		fill: 0xFFFFFF
	});
	scoreTxt.anchor.set(0, 0);
	LK.gui.topRight.addChild(scoreTxt);
	waveTxt = new Text2('Wave: 1', {
		size: 60,
		fill: 0xFFFFFF
	});
	waveTxt.anchor.set(1, 0);
	LK.gui.top.addChild(waveTxt);
	healthTxt = new Text2('❤️❤️❤️', {
		size: 60,
		fill: 0xFFFFFF
	});
	healthTxt.anchor.set(0, 0);
	LK.gui.bottom.addChild(healthTxt);
	comboTxt = new Text2('Combo: 0x', {
		size: 60,
		fill: 0xFFFFFF
	});
	comboTxt.anchor.set(1, 0);
	LK.gui.bottom.addChild(comboTxt);
	// Start the first wave
	startNewWave();
	// Play background music
	LK.playMusic('gameMusic', {
		fade: {
			start: 0,
			end: 0.5,
			duration: 1000
		}
	});
}
// Start a new wave of enemies
function startNewWave() {
	waveTxt.setText('Wave: ' + currentWave);
	if (currentWave % 3 === 0) {
		// Boss wave
		spawnBoss();
	} else {
		// Regular wave
		spawnTimer = 0;
	}
}
// Spawn a regular enemy
function spawnEnemy() {
	// Enforce a maximum number of enemies
	if (enemies.length >= 10) {
		return;
	}
	var edge = Math.floor(Math.random() * 4); // 0: top, 1: right, 2: bottom, 3: left
	var x, y;
	switch (edge) {
		case 0:
			// Top
			x = Math.random() * 2048;
			y = -50;
			break;
		case 1:
			// Right
			x = 2048 + 50;
			y = Math.random() * 2732;
			break;
		case 2:
			// Bottom
			x = Math.random() * 2048;
			y = 2732 + 50;
			break;
		case 3:
			// Left
			x = -50;
			y = Math.random() * 2732;
			break;
	}
	var enemy = new Enemy().init(x, y);
	enemy.speed = 2 + currentWave * 0.3; // Speed increases with wave
	if (currentWave > 2) {
		enemy.health = Math.min(3, 1 + Math.floor(currentWave / 3));
	}
	game.addChild(enemy);
	enemies.push(enemy);
}
// Spawn a boss
function spawnBoss() {
	var boss = new Boss().init(2048 / 2, -200);
	boss.health = 10 + currentWave / 3;
	game.addChild(boss);
	enemies.push(boss);
	// Make a dramatic entrance
	tween(boss, {
		y: 400
	}, {
		duration: 2000,
		easing: tween.bounceOut
	});
}
// Spawn a power-up
function spawnPowerUp(x, y) {
	var types = ['health', 'speed', 'power', 'strength'];
	var type = types[Math.floor(Math.random() * types.length)];
	var powerUp = new PowerUp().init(x, y, type);
	game.addChild(powerUp);
	powerUps.push(powerUp);
}
// Handle touch/mouse down
game.down = function (x, y, obj) {
	isSwipeActive = true;
	swipeStart.x = x;
	swipeStart.y = y;
};
// Handle touch/mouse up
game.up = function (x, y, obj) {
	if (isSwipeActive) {
		// Instead of dashing, shoot in the direction of the swipe
		var dx = x - swipeStart.x;
		var dy = y - swipeStart.y;
		var distance = Math.sqrt(dx * dx + dy * dy);
		// If it's a significant swipe, shoot in that direction
		if (distance > 20) {
			// Calculate target point to shoot towards
			var targetX = hero.x + dx * 10;
			var targetY = hero.y + dy * 10;
			hero.shootBullet(targetX, targetY);
		} else {
			// If it's just a tap, shoot upward
			hero.shootBullet(hero.x, hero.y - 100);
		}
		isSwipeActive = false;
	}
};
// Handle touch/mouse move
game.move = function (x, y, obj) {
	// We'll use swipe up/down instead of tracking movement
};
// Main game update loop
game.update = function () {
	// Update UI
	scoreTxt.setText('Score: ' + LK.getScore());
	comboTxt.setText('Combo: ' + hero.combo + 'x');
	// Update health display
	var healthStr = '';
	for (var i = 0; i < hero.health; i++) {
		healthStr += '❤️';
	}
	healthTxt.setText(healthStr);
	// Spawn enemies
	if (currentWave % 3 !== 0 || bossDefeated) {
		spawnTimer++;
		if (spawnTimer >= SPAWN_INTERVAL && enemies.length < WAVE_ENEMY_COUNT + Math.min(5, currentWave)) {
			// 40% chance to skip spawning
			if (Math.random() > 0.4) {
				spawnEnemy();
			}
			spawnTimer = 0;
		}
	}
	// Handle next wave
	if (nextWaveTimer > 0) {
		nextWaveTimer--;
		if (nextWaveTimer === 0) {
			bossDefeated = false;
			startNewWave();
		}
	} else if (enemies.length === 0 && currentWave % 3 !== 0) {
		// Wave completed
		currentWave++;
		nextWaveTimer = 120; // 2 seconds until next wave
	}
	// Update game objects
	updateGameObjects();
	// Detect collisions between bullets and enemies
	for (var b = bullets.length - 1; b >= 0; b--) {
		var bullet = bullets[b];
		if (!bullet.active) {
			continue;
		}
		var hitEnemy = false;
		for (var i = enemies.length - 1; i >= 0; i--) {
			var enemy = enemies[i];
			if (!enemy.active) {
				continue;
			}
			if (bullet.intersects(enemy)) {
				// Bullet hit enemy
				hitEnemy = true;
				// Apply damage based on bullet power
				enemy.health -= bullet.damage;
				// Visual feedback
				LK.effects.flashObject(enemy, 0xFFFFFF, 100);
				if (enemy.health <= 0) {
					// Award points
					hero.addScore(enemy.scoreValue * hero.powerBoost); // Multiply score by power boost
					// Maybe spawn a power-up
					if (Math.random() < POWER_UP_CHANCE) {
						spawnPowerUp(enemy.x, enemy.y);
					}
					// Remove enemy from array
					enemies.splice(i, 1);
				}
				break;
			}
		}
		// Remove bullet if it hit something
		if (hitEnemy) {
			bullet.destroy();
			bullets.splice(b, 1);
		}
	}
	// Clean up destroyed objects
	cleanupDestroyedObjects();
};
// Update all game objects
function updateGameObjects() {
	// Update hero
	if (hero) {
		hero.update();
	}
	// Update enemies
	for (var i = 0; i < enemies.length; i++) {
		if (enemies[i]) {
			enemies[i].update();
		}
	}
	// Update power-ups
	for (var i = 0; i < powerUps.length; i++) {
		if (powerUps[i]) {
			powerUps[i].update();
		}
	}
	// Update bullets
	for (var i = 0; i < bullets.length; i++) {
		if (bullets[i]) {
			bullets[i].update();
		}
	}
	// Update trails
	for (var i = 0; i < trails.length; i++) {
		if (trails[i]) {
			trails[i].update();
		}
	}
}
// Clean up destroyed objects
function cleanupDestroyedObjects() {
	// Clean up destroyed enemies
	for (var i = enemies.length - 1; i >= 0; i--) {
		if (!enemies[i] || !enemies[i].parent) {
			enemies.splice(i, 1);
		}
	}
	// Clean up destroyed power-ups
	for (var i = powerUps.length - 1; i >= 0; i--) {
		if (!powerUps[i] || !powerUps[i].parent) {
			powerUps.splice(i, 1);
		}
	}
	// Clean up destroyed trails
	for (var i = trails.length - 1; i >= 0; i--) {
		if (!trails[i] || !trails[i].parent) {
			trails.splice(i, 1);
		}
	}
	// Clean up destroyed bullets
	for (var i = bullets.length - 1; i >= 0; i--) {
		if (!bullets[i] || !bullets[i].parent) {
			bullets.splice(i, 1);
		}
	}
}
// Initialize the game
initGame();

===================================================================
--- original.js
+++ change.js
@@ -94,9 +94,8 @@
 				} else {
 					// Wait
 				}
 			}
-			// Check for collision with hero
 			if (hero.invulnerable <= 0 && !hero.isDashing) {
 				if (self.intersects(hero)) {
 					hero.takeDamage();
 				}
@@ -113,8 +112,41 @@
 		self.y = Math.max(100, Math.min(2732 - 100, self.y));
 	};
 	return self;
 });
+var Bullet = Container.expand(function () {
+	var self = Container.call(this);
+	var bulletGraphic = self.attachAsset('bullet', {
+		anchorX: 0.5,
+		anchorY: 0.5
+	});
+	bulletGraphic.tint = 0x3498db; // Blue bullet for the hero
+	self.speed = 15;
+	self.damage = 1;
+	self.active = true;
+	self.init = function (x, y, direction) {
+		self.x = x;
+		self.y = y;
+		self.direction = direction || {
+			x: 0,
+			y: -1
+		}; // Default direction is up
+		return self;
+	};
+	self.update = function () {
+		if (!self.active) {
+			return;
+		}
+		// Move in the specified direction
+		self.x += self.direction.x * self.speed;
+		self.y += self.direction.y * self.speed;
+		// Remove if off-screen
+		if (self.x < -50 || self.x > 2048 + 50 || self.y < -50 || self.y > 2732 + 50) {
+			self.destroy();
+		}
+	};
+	return self;
+});
 var DashTrail = Container.expand(function () {
 	var self = Container.call(this);
 	var trailGraphic = self.attachAsset('dashTrail', {
 		anchorX: 0.5,
@@ -217,69 +249,59 @@
 	// Simple click handler that does nothing (placeholder)
 	self.down = function (x, y, obj) {
 		// No auto-shoot toggle functionality
 	};
-	self.dashSpeed = 60;
-	self.dashDistance = 700;
-	self.isDashing = false;
-	self.dashCooldown = 0;
+	self.shootSpeed = 15; // Bullet speed
+	self.fireRate = 15; // Frames between shots
+	self.shootCooldown = 0;
 	self.health = 3;
 	self.invulnerable = 0;
 	self.combo = 0;
 	self.score = 0;
-	self.consecutiveDashes = 0;
 	self.powerBoost = 1; // Base power multiplier
-	self.lastDashTime = 0;
-	self.dashToPoint = function (targetX, targetY) {
-		if (self.dashCooldown > 0 || self.isDashing) {
+	self.shootBullet = function (targetX, targetY) {
+		if (self.shootCooldown > 0) {
 			return;
 		}
 		var dx = targetX - self.x;
 		var dy = targetY - self.y;
 		var distance = Math.sqrt(dx * dx + dy * dy);
 		// Normalize direction
 		var dirX = dx / distance;
 		var dirY = dy / distance;
-		// Set dash parameters
-		self.isDashing = true;
-		self.dashDirection = {
+		// Create bullet
+		var bullet = new Bullet().init(self.x, self.y, {
 			x: dirX,
 			y: dirY
-		};
-		self.dashRemaining = self.dashDistance;
-		// Check if this is a quick consecutive dash
-		var currentTime = LK.ticks;
-		if (currentTime - self.lastDashTime < 30) {
-			self.consecutiveDashes++;
-			// Bonus speed for consecutive dashes (up to 50% bonus)
-			var speedBonus = Math.min(0.5, self.consecutiveDashes * 0.1);
-			self.dashSpeed = 60 * (1 + speedBonus);
-			self.dashCooldown = Math.max(5, 10 - self.consecutiveDashes); // reduced cooldown for consecutive dashes
-		} else {
-			self.consecutiveDashes = 0;
-			self.dashSpeed = 60;
-			self.dashCooldown = 10; // standard cooldown
-		}
-		self.lastDashTime = currentTime;
-		// Visual dash effect
+		});
+		bullet.damage = self.powerBoost; // Apply power boost to bullet damage
+		// Visual shooting effect
 		tween(heroGraphic, {
-			scaleX: 1.3,
-			scaleY: 0.7
+			scaleX: 1.2,
+			scaleY: 0.9
 		}, {
-			duration: 200,
+			duration: 100,
 			easing: tween.easeOut,
 			onFinish: function onFinish() {
 				tween(heroGraphic, {
 					scaleX: 1,
 					scaleY: 1
 				}, {
-					duration: 300,
+					duration: 200,
 					easing: tween.elasticOut
 				});
 			}
 		});
-		// Play dash sound
-		LK.getSound('dash').play();
+		// Set cooldown
+		self.shootCooldown = self.fireRate;
+		// Add bullet to game
+		game.addChild(bullet);
+		if (!bullets) {
+			bullets = [];
+		}
+		bullets.push(bullet);
+		// Play shoot sound
+		LK.getSound('hit').play();
 	};
 	self.takeDamage = function () {
 		if (self.invulnerable > 0) {
 			return;
@@ -302,40 +324,14 @@
 		self.score += scoreToAdd;
 		LK.setScore(self.score);
 	};
 	self.update = function () {
-		// Handle dash movement
-		if (self.isDashing) {
-			var moveX = self.dashDirection.x * self.dashSpeed;
-			var moveY = self.dashDirection.y * self.dashSpeed;
-			self.x += moveX;
-			self.y += moveY;
-			self.dashRemaining -= self.dashSpeed;
-			// Create enhanced trail effect based on power boost
-			if (LK.ticks % 1 === 0) {
-				var trail = new DashTrail().init(self.x, self.y);
-				// Trail size based on power boost and randomness
-				var trailScale = (0.8 + Math.random() * 0.5) * (1 + (self.powerBoost - 1) * 0.5);
-				trail.scale.set(trailScale, trailScale);
-				// Tint trail based on power level
-				if (self.powerBoost > 1) {
-					trail.tint = 0xFF5500;
-				}
-				game.addChild(trail);
-				trails.push(trail);
-			}
-			// End dash if we've gone far enough
-			if (self.dashRemaining <= 0) {
-				self.isDashing = false;
-			}
-		}
-		// Auto-shooting functionality removed
 		// Keep within screen bounds
 		self.x = Math.max(50, Math.min(2048 - 50, self.x));
 		self.y = Math.max(50, Math.min(2732 - 50, self.y));
 		// Cooldowns
-		if (self.dashCooldown > 0) {
-			self.dashCooldown--;
+		if (self.shootCooldown > 0) {
+			self.shootCooldown--;
 		}
 		if (self.invulnerable > 0) {
 			self.invulnerable--;
 			// Flicker effect during invulnerability
@@ -525,8 +521,9 @@
 ****/ 
 // Game state variables
 var hero;
 var enemies = [];
+var bullets = [];
 var powerUps = [];
 var trails = [];
 var currentWave = 1;
 var nextWaveTimer = 0;
@@ -669,18 +666,21 @@
 };
 // Handle touch/mouse up
 game.up = function (x, y, obj) {
 	if (isSwipeActive) {
-		// Calculate swipe direction and distance
+		// Instead of dashing, shoot in the direction of the swipe
 		var dx = x - swipeStart.x;
 		var dy = y - swipeStart.y;
 		var distance = Math.sqrt(dx * dx + dy * dy);
-		// If it's a significant swipe, dash in that direction
-		if (distance > 50) {
-			// Calculate target point to dash towards
-			var targetX = hero.x + dx * 2;
-			var targetY = hero.y + dy * 2;
-			hero.dashToPoint(targetX, targetY);
+		// If it's a significant swipe, shoot in that direction
+		if (distance > 20) {
+			// Calculate target point to shoot towards
+			var targetX = hero.x + dx * 10;
+			var targetY = hero.y + dy * 10;
+			hero.shootBullet(targetX, targetY);
+		} else {
+			// If it's just a tap, shoot upward
+			hero.shootBullet(hero.x, hero.y - 100);
 		}
 		isSwipeActive = false;
 	}
 };
@@ -723,21 +723,27 @@
 		nextWaveTimer = 120; // 2 seconds until next wave
 	}
 	// Update game objects
 	updateGameObjects();
-	// Detect collisions between hero dash and enemies
-	if (hero.isDashing) {
-		// Increase dash hit area based on power boost
-		var extraHitArea = (hero.powerBoost - 1) * 30;
+	// Detect collisions between bullets and enemies
+	for (var b = bullets.length - 1; b >= 0; b--) {
+		var bullet = bullets[b];
+		if (!bullet.active) {
+			continue;
+		}
+		var hitEnemy = false;
 		for (var i = enemies.length - 1; i >= 0; i--) {
 			var enemy = enemies[i];
-			// Check for collision with expanded hit area for power boost
-			var dx = enemy.x - hero.x;
-			var dy = enemy.y - hero.y;
-			var dist = Math.sqrt(dx * dx + dy * dy);
-			var hitRange = 80 + extraHitArea; // Base hit range plus power boost extra area
-			if (enemy.active && (hero.intersects(enemy) || dist < hitRange)) {
-				enemy.takeDamage();
+			if (!enemy.active) {
+				continue;
+			}
+			if (bullet.intersects(enemy)) {
+				// Bullet hit enemy
+				hitEnemy = true;
+				// Apply damage based on bullet power
+				enemy.health -= bullet.damage;
+				// Visual feedback
+				LK.effects.flashObject(enemy, 0xFFFFFF, 100);
 				if (enemy.health <= 0) {
 					// Award points
 					hero.addScore(enemy.scoreValue * hero.powerBoost); // Multiply score by power boost
 					// Maybe spawn a power-up
@@ -746,10 +752,16 @@
 					}
 					// Remove enemy from array
 					enemies.splice(i, 1);
 				}
+				break;
 			}
 		}
+		// Remove bullet if it hit something
+		if (hitEnemy) {
+			bullet.destroy();
+			bullets.splice(b, 1);
+		}
 	}
 	// Clean up destroyed objects
 	cleanupDestroyedObjects();
 };
@@ -770,8 +782,14 @@
 		if (powerUps[i]) {
 			powerUps[i].update();
 		}
 	}
+	// Update bullets
+	for (var i = 0; i < bullets.length; i++) {
+		if (bullets[i]) {
+			bullets[i].update();
+		}
+	}
 	// Update trails
 	for (var i = 0; i < trails.length; i++) {
 		if (trails[i]) {
 			trails[i].update();
@@ -797,7 +815,13 @@
 		if (!trails[i] || !trails[i].parent) {
 			trails.splice(i, 1);
 		}
 	}
+	// Clean up destroyed bullets
+	for (var i = bullets.length - 1; i >= 0; i--) {
+		if (!bullets[i] || !bullets[i].parent) {
+			bullets.splice(i, 1);
+		}
+	}
 }
 // Initialize the game
 initGame();
\ No newline at end of file