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

/**** 
* Game Code
****/ 
// === SECTION: ASSETS ===
// === SECTION: GLOBAL NAMESPACE ===
var Game = {};
// === SECTION: GLOBAL MANAGERS ===
Game.ResourceManager = {
	gold: 100,
	lives: 20,
	powerProduction: 0,
	powerConsumption: 0,
	powerAvailable: 0,
	addGold: function addGold(amount) {
		this.gold += amount;
	},
	spendGold: function spendGold(amount) {
		if (this.gold >= amount) {
			this.gold -= amount;
			return true;
		}
		return false;
	},
	loseLife: function loseLife(amount) {
		this.lives -= amount;
		if (this.lives <= 0) {
			Game.EventBus.publish(Game.Events.GameOverEvent());
		}
	},
	updatePower: function updatePower() {
		// Calculate total power production
		var totalProduction = 0;
		var productionEntities = Game.EntityManager.getEntitiesWithComponents(['PowerProductionComponent']);
		for (var i = 0; i < productionEntities.length; i++) {
			var entityId = productionEntities[i];
			var powerComp = Game.EntityManager.componentStores['PowerProductionComponent'][entityId];
			totalProduction += powerComp.production_rate;
		}
		// Calculate total power consumption
		var totalConsumption = 0;
		var consumptionEntities = Game.EntityManager.getEntitiesWithComponents(['PowerConsumptionComponent']);
		for (var i = 0; i < consumptionEntities.length; i++) {
			var entityId = consumptionEntities[i];
			var powerComp = Game.EntityManager.componentStores['PowerConsumptionComponent'][entityId];
			totalConsumption += powerComp.drain_rate;
		}
		// Update power values
		this.powerProduction = totalProduction;
		this.powerConsumption = totalConsumption;
		this.powerAvailable = totalProduction - totalConsumption;
		// Publish power status event
		var newStatus = totalProduction >= totalConsumption ? 'surplus' : 'deficit';
		Game.EventBus.publish(Game.Events.PowerStatusChangedEvent(newStatus));
	},
	onEnemyKilled: function onEnemyKilled(event) {
		this.addGold(event.gold_value);
	},
	onWaveCompleted: function onWaveCompleted(event) {
		this.addGold(50);
	},
	init: function init() {
		Game.EventBus.subscribe('EnemyKilled', this.onEnemyKilled.bind(this));
		Game.EventBus.subscribe('WaveCompleted', this.onWaveCompleted.bind(this));
	}
};
Game.GridManager = {
	grid: [],
	CELL_STATES: {
		EMPTY: 0,
		PATH: 1,
		BLOCKED: 2,
		TOWER: 3
	},
	init: function init(width, height) {
		this.grid = [];
		for (var x = 0; x < width; x++) {
			this.grid[x] = [];
			for (var y = 0; y < height; y++) {
				this.grid[x][y] = this.CELL_STATES.EMPTY;
			}
		}
	},
	isBuildable: function isBuildable(x, y) {
		if (x >= 0 && x < this.grid.length && y >= 0 && y < this.grid[x].length) {
			return this.grid[x][y] === this.CELL_STATES.EMPTY;
		}
		return false;
	}
};
Game.PathManager = {
	currentPath: [],
	init: function init() {
		Game.EventBus.subscribe('TowerPlaced', this.onTowerPlaced.bind(this));
	},
	onTowerPlaced: function onTowerPlaced(event) {
		this.recalculatePath({
			x: 0,
			y: 30
		}, {
			x: 39,
			y: 30
		});
	},
	recalculatePath: function recalculatePath(start, end) {
		this.currentPath = this.findPath(start, end);
		if (this.currentPath) {
			for (var i = 0; i < this.currentPath.length; i++) {
				this.currentPath[i].x = this.currentPath[i].x * 64;
				this.currentPath[i].y = this.currentPath[i].y * 64;
			}
		}
	},
	findPath: function findPath(start, end) {
		var openSet = [];
		var closedSet = [];
		var grid = Game.GridManager.grid;
		var gridWidth = grid.length;
		var gridHeight = grid[0].length;
		// Helper function to calculate heuristic (Manhattan distance)
		function heuristic(a, b) {
			return Math.abs(a.x - b.x) + Math.abs(a.y - b.y);
		}
		// Helper function to get neighbors
		function getNeighbors(node) {
			var neighbors = [];
			var directions = [{
				x: -1,
				y: 0,
				cost: 1
			}, {
				x: 1,
				y: 0,
				cost: 1
			}, {
				x: 0,
				y: -1,
				cost: 1
			}, {
				x: 0,
				y: 1,
				cost: 1
			}, {
				x: -1,
				y: -1,
				cost: 1.4
			}, {
				x: 1,
				y: -1,
				cost: 1.4
			}, {
				x: -1,
				y: 1,
				cost: 1.4
			}, {
				x: 1,
				y: 1,
				cost: 1.4
			}];
			for (var i = 0; i < directions.length; i++) {
				var dir = directions[i];
				var newX = node.x + dir.x;
				var newY = node.y + dir.y;
				if (newX >= 0 && newX < gridWidth && newY >= 0 && newY < gridHeight) {
					var cellState = grid[newX][newY];
					if (cellState !== Game.GridManager.CELL_STATES.BLOCKED && cellState !== Game.GridManager.CELL_STATES.TOWER) {
						neighbors.push({
							x: newX,
							y: newY,
							cost: dir.cost
						});
					}
				}
			}
			return neighbors;
		}
		// Helper function to find node in array
		function findNodeInArray(array, node) {
			for (var i = 0; i < array.length; i++) {
				if (array[i].x === node.x && array[i].y === node.y) {
					return array[i];
				}
			}
			return null;
		}
		// Helper function to reconstruct path
		function reconstructPath(cameFrom, current) {
			var path = [];
			while (current) {
				path.unshift({
					x: current.x,
					y: current.y
				});
				current = cameFrom[current.x + '_' + current.y];
			}
			return path;
		}
		// Initialize start node
		var startNode = {
			x: start.x,
			y: start.y,
			g: 0,
			h: heuristic(start, end),
			f: 0
		};
		startNode.f = startNode.g + startNode.h;
		openSet.push(startNode);
		var cameFrom = {};
		while (openSet.length > 0) {
			// Find node with lowest f score
			var current = openSet[0];
			var currentIndex = 0;
			for (var i = 1; i < openSet.length; i++) {
				if (openSet[i].f < current.f) {
					current = openSet[i];
					currentIndex = i;
				}
			}
			// Remove current from openSet
			openSet.splice(currentIndex, 1);
			closedSet.push(current);
			// Check if we reached the goal
			if (current.x === end.x && current.y === end.y) {
				return reconstructPath(cameFrom, current);
			}
			// Check neighbors
			var neighbors = getNeighbors(current);
			for (var i = 0; i < neighbors.length; i++) {
				var neighbor = neighbors[i];
				// Skip if in closed set
				if (findNodeInArray(closedSet, neighbor)) {
					continue;
				}
				var tentativeG = current.g + neighbor.cost;
				var existingNode = findNodeInArray(openSet, neighbor);
				if (!existingNode) {
					// New node
					var newNode = {
						x: neighbor.x,
						y: neighbor.y,
						g: tentativeG,
						h: heuristic(neighbor, end),
						f: 0
					};
					newNode.f = newNode.g + newNode.h;
					openSet.push(newNode);
					cameFrom[neighbor.x + '_' + neighbor.y] = current;
				} else if (tentativeG < existingNode.g) {
					// Better path found
					existingNode.g = tentativeG;
					existingNode.f = existingNode.g + existingNode.h;
					cameFrom[neighbor.x + '_' + neighbor.y] = current;
				}
			}
		}
		// No path found
		return null;
	}
};
Game.Debug = {
	logText: null,
	init: function init() {
		this.logText = new Text2('Debug Log Initialized', {
			size: 40,
			fill: 0x00FF00
		}); // Green text
		this.logText.anchor.set(0, 1); // Anchor to bottom-left
		LK.gui.bottomLeft.addChild(this.logText);
		this.logText.x = 20;
		this.logText.y = -20;
	},
	log: function log(message) {
		if (this.logText) {
			this.logText.setText(String(message));
		}
	}
};
// === SECTION: ENTITY-COMPONENT-SYSTEM SCAFFOLDING ===
Game.EntityManager = {
	nextEntityId: 1,
	activeEntities: [],
	componentStores: {},
	createEntity: function createEntity() {
		var entityId = this.nextEntityId++;
		this.activeEntities.push(entityId);
		return entityId;
	},
	addComponent: function addComponent(entityId, component) {
		if (!this.componentStores[component.name]) {
			this.componentStores[component.name] = {};
		}
		this.componentStores[component.name][entityId] = component;
	},
	getEntitiesWithComponents: function getEntitiesWithComponents(componentNames) {
		var result = [];
		for (var i = 0; i < this.activeEntities.length; i++) {
			var entityId = this.activeEntities[i];
			var hasAllComponents = true;
			for (var j = 0; j < componentNames.length; j++) {
				var componentName = componentNames[j];
				if (!this.componentStores[componentName] || !this.componentStores[componentName][entityId]) {
					hasAllComponents = false;
					break;
				}
			}
			if (hasAllComponents) {
				result.push(entityId);
			}
		}
		return result;
	}
};
Game.Components = {
	TransformComponent: function TransformComponent(x, y, rotation) {
		return {
			name: 'TransformComponent',
			x: x || 0,
			y: y || 0,
			rotation: rotation || 0
		};
	},
	RenderComponent: function RenderComponent(sprite_id, layer, scale, is_visible) {
		return {
			name: 'RenderComponent',
			sprite_id: sprite_id || '',
			layer: layer || 0,
			scale: scale || 1.0,
			is_visible: is_visible !== undefined ? is_visible : true
		};
	},
	HealthComponent: function HealthComponent(current_hp, max_hp) {
		return {
			name: 'HealthComponent',
			current_hp: current_hp || 100,
			max_hp: max_hp || 100
		};
	},
	AttackComponent: function AttackComponent(damage, range, attack_speed, last_attack_time, projectile_id, target_id) {
		return {
			name: 'AttackComponent',
			damage: damage || 10,
			range: range || 100,
			attack_speed: attack_speed || 1.0,
			last_attack_time: last_attack_time || 0,
			projectile_id: projectile_id || '',
			target_id: target_id || -1
		};
	},
	MovementComponent: function MovementComponent(speed, path_index) {
		return {
			name: 'MovementComponent',
			speed: speed || 50,
			path_index: path_index || 0
		};
	},
	PowerProductionComponent: function PowerProductionComponent(rate) {
		return {
			name: 'PowerProductionComponent',
			production_rate: rate || 0
		};
	},
	PowerConsumptionComponent: function PowerConsumptionComponent(rate) {
		return {
			name: 'PowerConsumptionComponent',
			drain_rate: rate || 0
		};
	},
	TowerComponent: function TowerComponent(cost, sellValue) {
		return {
			name: 'TowerComponent',
			cost: cost || 50,
			sell_value: sellValue || 25
		};
	},
	ProjectileComponent: function ProjectileComponent(target_id, speed, damage, directionX, directionY) {
		return {
			name: 'ProjectileComponent',
			target_id: target_id || -1,
			speed: speed || 200,
			damage: damage || 10,
			directionX: directionX || 0,
			directionY: directionY || 0
		};
	}
};
Game.Systems = {
	MovementSystem: {
		update: function update() {
			var movableEntities = Game.EntityManager.getEntitiesWithComponents(['TransformComponent', 'MovementComponent']);
			for (var i = 0; i < movableEntities.length; i++) {
				var entityId = movableEntities[i];
				var transformComponent = Game.EntityManager.componentStores['TransformComponent'][entityId];
				var movementComponent = Game.EntityManager.componentStores['MovementComponent'][entityId];
				if (Game.PathManager.currentPath && Game.PathManager.currentPath.length > 0) {
					var targetWaypoint = Game.PathManager.currentPath[movementComponent.path_index];
					if (targetWaypoint) {
						var dx = targetWaypoint.x - transformComponent.x;
						var dy = targetWaypoint.y - transformComponent.y;
						var distance = Math.sqrt(dx * dx + dy * dy);
						if (distance > 1) {
							var moveX = dx / distance * movementComponent.speed;
							var moveY = dy / distance * movementComponent.speed;
							transformComponent.x += moveX;
							transformComponent.y += moveY;
						} else {
							movementComponent.path_index++;
							if (movementComponent.path_index >= Game.PathManager.currentPath.length) {
								Game.EventBus.publish(Game.Events.EnemyReachedEndEvent(entityId));
							}
						}
					}
				}
			}
		}
	},
	RenderSystem: {
		displayObjects: {},
		update: function update() {
			var renderableEntities = Game.EntityManager.getEntitiesWithComponents(['TransformComponent', 'RenderComponent']);
			for (var i = 0; i < renderableEntities.length; i++) {
				var entityId = renderableEntities[i];
				var transform = Game.EntityManager.componentStores['TransformComponent'][entityId];
				var render = Game.EntityManager.componentStores['RenderComponent'][entityId];
				// Get the visual sprite, or create it if it doesn't exist
				var sprite = this.displayObjects[entityId];
				if (!sprite) {
					sprite = game.attachAsset(render.sprite_id, {});
					this.displayObjects[entityId] = sprite;
				}
				// Sync the sprite's properties with the component data
				sprite.x = transform.x;
				sprite.y = transform.y;
				sprite.visible = render.is_visible;
			}
		}
	},
	TowerBuildSystem: {
		tryBuildAt: function tryBuildAt(gridX, gridY) {
			// 1. Check if the location is buildable
			if (!Game.GridManager.isBuildable(gridX, gridY)) {
				return; // Exit if not buildable
			}
			// 2. Check if the player can afford the tower
			var towerCost = 50; // We'll use a fixed cost for now
			if (!Game.ResourceManager.spendGold(towerCost)) {
				return; // Exit if not enough gold
			}
			// 3. If checks pass, create the tower entity
			var towerId = Game.EntityManager.createEntity();
			// 4. Mark the grid cell as occupied by a tower
			Game.GridManager.grid[gridX][gridY] = Game.GridManager.CELL_STATES.TOWER;
			// 5. Create and add all necessary components
			var transform = Game.Components.TransformComponent(gridX * 64, gridY * 64);
			var render = Game.Components.RenderComponent('arrow_tower', 2, 1.0, true);
			var tower = Game.Components.TowerComponent(towerCost);
			var attack = Game.Components.AttackComponent(10, 150, 1.0); // dmg, range, speed
			var power = Game.Components.PowerConsumptionComponent(2);
			Game.EntityManager.addComponent(towerId, transform);
			Game.EntityManager.addComponent(towerId, render);
			Game.EntityManager.addComponent(towerId, tower);
			Game.EntityManager.addComponent(towerId, attack);
			Game.EntityManager.addComponent(towerId, power);
			// 6. Announce that a tower has been placed
			var event = Game.Events.TowerPlacedEvent(towerId, towerCost, transform.x, transform.y);
			Game.EventBus.publish(event);
		}
	},
	TargetingSystem: {
		update: function update() {
			var towers = Game.EntityManager.getEntitiesWithComponents(['AttackComponent', 'TransformComponent']);
			for (var i = 0; i < towers.length; i++) {
				var towerId = towers[i];
				var towerAttack = Game.EntityManager.componentStores['AttackComponent'][towerId];
				var towerTransform = Game.EntityManager.componentStores['TransformComponent'][towerId];
				// Find best target (closest to end of path)
				var bestTarget = -1;
				var bestPathIndex = -1;
				var enemies = Game.EntityManager.getEntitiesWithComponents(['TransformComponent', 'MovementComponent']);
				for (var j = 0; j < enemies.length; j++) {
					var enemyId = enemies[j];
					var enemyTransform = Game.EntityManager.componentStores['TransformComponent'][enemyId];
					var enemyMovement = Game.EntityManager.componentStores['MovementComponent'][enemyId];
					// Check if enemy is within range
					var dx = enemyTransform.x - towerTransform.x;
					var dy = enemyTransform.y - towerTransform.y;
					var distance = Math.sqrt(dx * dx + dy * dy);
					if (distance <= towerAttack.range) {
						// Check if this enemy is closer to the end
						if (enemyMovement.path_index > bestPathIndex) {
							bestTarget = enemyId;
							bestPathIndex = enemyMovement.path_index;
						}
					}
				}
				// Update tower's target
				towerAttack.target_id = bestTarget;
			}
		}
	},
	CombatSystem: {
		update: function update() {
			var currentTime = LK.ticks / 60; // Convert ticks to seconds
			var towers = Game.EntityManager.getEntitiesWithComponents(['AttackComponent', 'TransformComponent']);
			for (var i = 0; i < towers.length; i++) {
				var towerId = towers[i];
				var towerAttack = Game.EntityManager.componentStores['AttackComponent'][towerId];
				var towerTransform = Game.EntityManager.componentStores['TransformComponent'][towerId];
				// Check if tower has a valid target and can fire
				if (towerAttack.target_id !== -1 && currentTime - towerAttack.last_attack_time >= 1.0 / towerAttack.attack_speed) {
					// Get target position to calculate initial direction
					var targetTransform = Game.EntityManager.componentStores['TransformComponent'][towerAttack.target_id];
					if (targetTransform) {
						// Calculate direction vector
						var dx = targetTransform.x - towerTransform.x;
						var dy = targetTransform.y - towerTransform.y;
						var distance = Math.sqrt(dx * dx + dy * dy);
						var directionX = dx / distance;
						var directionY = dy / distance;
						// Create projectile
						var projectileId = Game.EntityManager.createEntity();
						var projectileTransform = Game.Components.TransformComponent(towerTransform.x, towerTransform.y);
						var projectileRender = Game.Components.RenderComponent('arrow_projectile', 1, 1.0, true);
						var projectileComponent = Game.Components.ProjectileComponent(towerAttack.target_id, 200, towerAttack.damage, directionX, directionY);
						Game.EntityManager.addComponent(projectileId, projectileTransform);
						Game.EntityManager.addComponent(projectileId, projectileRender);
						Game.EntityManager.addComponent(projectileId, projectileComponent);
						// Update tower's last attack time
						towerAttack.last_attack_time = currentTime;
					}
				}
			}
			// Move projectiles and check for impacts
			var projectiles = Game.EntityManager.getEntitiesWithComponents(['ProjectileComponent', 'TransformComponent']);
			for (var i = projectiles.length - 1; i >= 0; i--) {
				var projectileId = projectiles[i];
				var projectileComp = Game.EntityManager.componentStores['ProjectileComponent'][projectileId];
				var projectileTransform = Game.EntityManager.componentStores['TransformComponent'][projectileId];
				// Check if target still exists
				var targetExists = false;
				for (var j = 0; j < Game.EntityManager.activeEntities.length; j++) {
					if (Game.EntityManager.activeEntities[j] === projectileComp.target_id) {
						targetExists = true;
						break;
					}
				}
				if (!targetExists) {
					// Remove projectile if target no longer exists
					Game.EntityManager.activeEntities.splice(Game.EntityManager.activeEntities.indexOf(projectileId), 1);
					if (Game.Systems.RenderSystem.displayObjects[projectileId]) {
						Game.Systems.RenderSystem.displayObjects[projectileId].destroy();
						delete Game.Systems.RenderSystem.displayObjects[projectileId];
					}
					continue;
				}
				// Move projectile towards target
				var targetTransform = Game.EntityManager.componentStores['TransformComponent'][projectileComp.target_id];
				if (targetTransform) {
					var dx = targetTransform.x - projectileTransform.x;
					var dy = targetTransform.y - projectileTransform.y;
					var distance = Math.sqrt(dx * dx + dy * dy);
					if (distance < 5) {
						// Hit target - apply damage and remove projectile
						var targetHealth = Game.EntityManager.componentStores['HealthComponent'][projectileComp.target_id];
						if (targetHealth) {
							targetHealth.current_hp -= projectileComp.damage;
							if (targetHealth.current_hp <= 0) {
								// Enemy killed
								Game.EventBus.publish(Game.Events.EnemyKilledEvent(projectileComp.target_id, 10));
								// Remove enemy
								Game.EntityManager.activeEntities.splice(Game.EntityManager.activeEntities.indexOf(projectileComp.target_id), 1);
								if (Game.Systems.RenderSystem.displayObjects[projectileComp.target_id]) {
									Game.Systems.RenderSystem.displayObjects[projectileComp.target_id].destroy();
									delete Game.Systems.RenderSystem.displayObjects[projectileComp.target_id];
								}
							}
						}
						// Remove projectile
						Game.EntityManager.activeEntities.splice(Game.EntityManager.activeEntities.indexOf(projectileId), 1);
						if (Game.Systems.RenderSystem.displayObjects[projectileId]) {
							Game.Systems.RenderSystem.displayObjects[projectileId].destroy();
							delete Game.Systems.RenderSystem.displayObjects[projectileId];
						}
					} else {
						// Move projectile using stored direction
						var moveX = projectileComp.directionX * projectileComp.speed;
						var moveY = projectileComp.directionY * projectileComp.speed;
						projectileTransform.x += moveX;
						projectileTransform.y += moveY;
					}
				}
			}
		}
	}
};
// === SECTION: GRID DRAWING ===
function drawGrid() {
	// Draw the grid cells
	for (var x = 0; x < Game.GridManager.grid.length; x++) {
		for (var y = 0; y < Game.GridManager.grid[x].length; y++) {
			var cellSprite = game.attachAsset('grid_cell', {});
			cellSprite.x = x * 64;
			cellSprite.y = y * 64;
			cellSprite.anchor.set(0, 0); // Anchor to top-left
			// Add these new lines to make cells interactive
			cellSprite.gridX = x; // Store grid coordinates on the sprite
			cellSprite.gridY = y;
			cellSprite.down = function () {
				Game.Systems.TowerBuildSystem.tryBuildAt(this.gridX, this.gridY);
			};
		}
	}
	// Highlight the path cells
	if (Game.PathManager.currentPath) {
		for (var i = 0; i < Game.PathManager.currentPath.length; i++) {
			var pathNode = Game.PathManager.currentPath[i];
			var pathSprite = game.attachAsset('path_cell', {});
			// Note: PathManager coordinates are already in pixels
			pathSprite.x = pathNode.x;
			pathSprite.y = pathNode.y;
			pathSprite.anchor.set(0, 0);
		}
	}
}
// === SECTION: GLOBAL EVENT BUS ===
Game.EventBus = {
	listeners: {},
	subscribe: function subscribe(eventType, listener) {
		if (!this.listeners[eventType]) {
			this.listeners[eventType] = [];
		}
		this.listeners[eventType].push(listener);
	},
	unsubscribe: function unsubscribe(eventType, listener) {
		if (this.listeners[eventType]) {
			var index = this.listeners[eventType].indexOf(listener);
			if (index !== -1) {
				this.listeners[eventType].splice(index, 1);
			}
		}
	},
	publish: function publish(event) {
		if (this.listeners[event.type]) {
			for (var i = 0; i < this.listeners[event.type].length; i++) {
				this.listeners[event.type][i](event);
			}
		}
	}
};
Game.Events = {
	EnemyReachedEndEvent: function EnemyReachedEndEvent(enemy_id) {
		return {
			type: 'EnemyReachedEnd',
			enemy_id: enemy_id
		};
	},
	EnemyKilledEvent: function EnemyKilledEvent(enemy_id, gold_value) {
		return {
			type: 'EnemyKilled',
			enemy_id: enemy_id,
			gold_value: gold_value
		};
	},
	TowerPlacedEvent: function TowerPlacedEvent(tower_id, cost, position_x, position_y) {
		return {
			type: 'TowerPlaced',
			tower_id: tower_id,
			cost: cost,
			position_x: position_x,
			position_y: position_y
		};
	},
	TowerSoldEvent: function TowerSoldEvent(tower_id, refund_value) {
		return {
			type: 'TowerSold',
			tower_id: tower_id,
			refund_value: refund_value
		};
	},
	PowerStatusChangedEvent: function PowerStatusChangedEvent(new_status) {
		return {
			type: 'PowerStatusChanged',
			new_status: new_status
		};
	},
	WaveCompletedEvent: function WaveCompletedEvent(wave_number) {
		return {
			type: 'WaveCompleted',
			wave_number: wave_number
		};
	},
	GameOverEvent: function GameOverEvent() {
		return {
			type: 'GameOver'
		};
	}
};
// === SECTION: STACK-BASED GAME STATE MANAGER ===
// === SECTION: DIRECT GAME INITIALIZATION ===
// Initialize managers
Game.GridManager.init(40, 60);
Game.ResourceManager.init();
Game.PathManager.init();
Game.PathManager.recalculatePath({
	x: 0,
	y: 30
}, {
	x: 39,
	y: 30
});
drawGrid();
// Create the Heads-Up Display (HUD)
var goldText = new Text2('Gold: 100', {
	size: 40,
	fill: 0xFFD700
});
goldText.anchor.set(1, 0); // Align to the right
LK.gui.topRight.addChild(goldText);
goldText.x = -20; // 20px padding from the right edge
goldText.y = 20; // 20px padding from the top edge
var livesText = new Text2('Lives: 20', {
	size: 40,
	fill: 0xFF4136
});
livesText.anchor.set(1, 0); // Align to the right
LK.gui.topRight.addChild(livesText);
livesText.x = -20; // 20px padding from the right edge
livesText.y = 70; // Position below the gold text
// Create a test enemy
var enemyId = Game.EntityManager.createEntity();
var transform = Game.Components.TransformComponent(0 * 64, 30 * 64);
var movement = Game.Components.MovementComponent(2, 0);
var render = Game.Components.RenderComponent('enemy', 1, 1.0, true);
var health = Game.Components.HealthComponent(30, 30);
Game.EntityManager.addComponent(enemyId, transform);
Game.EntityManager.addComponent(enemyId, movement);
Game.EntityManager.addComponent(enemyId, render);
Game.EntityManager.addComponent(enemyId, health);
// Set up main game loop
var powerUpdateTimer = 0;
game.update = function () {
	Game.Systems.TargetingSystem.update();
	Game.Systems.CombatSystem.update();
	Game.Systems.MovementSystem.update();
	Game.Systems.RenderSystem.update();
	// Update HUD every frame
	goldText.setText('Gold: ' + Game.ResourceManager.gold);
	livesText.setText('Lives: ' + Game.ResourceManager.lives);
	// Update power system once per second (every 60 frames)
	powerUpdateTimer++;
	if (powerUpdateTimer >= 60) {
		Game.ResourceManager.updatePower();
		powerUpdateTimer = 0;
	}
};

===================================================================
--- original.js
+++ change.js
@@ -7,10 +7,10 @@
 
 /**** 
 * Game Code
 ****/ 
-// === SECTION: GLOBAL NAMESPACE ===
 // === SECTION: ASSETS ===
+// === SECTION: GLOBAL NAMESPACE ===
 var Game = {};
 // === SECTION: GLOBAL MANAGERS ===
 Game.ResourceManager = {
 	gold: 100,
@@ -377,14 +377,16 @@
 			cost: cost || 50,
 			sell_value: sellValue || 25
 		};
 	},
-	ProjectileComponent: function ProjectileComponent(target_id, speed, damage) {
+	ProjectileComponent: function ProjectileComponent(target_id, speed, damage, directionX, directionY) {
 		return {
 			name: 'ProjectileComponent',
 			target_id: target_id || -1,
 			speed: speed || 200,
-			damage: damage || 10
+			damage: damage || 10,
+			directionX: directionX || 0,
+			directionY: directionY || 0
 		};
 	}
 };
 Game.Systems = {
@@ -510,18 +512,28 @@
 				var towerAttack = Game.EntityManager.componentStores['AttackComponent'][towerId];
 				var towerTransform = Game.EntityManager.componentStores['TransformComponent'][towerId];
 				// Check if tower has a valid target and can fire
 				if (towerAttack.target_id !== -1 && currentTime - towerAttack.last_attack_time >= 1.0 / towerAttack.attack_speed) {
-					// Create projectile
-					var projectileId = Game.EntityManager.createEntity();
-					var projectileTransform = Game.Components.TransformComponent(towerTransform.x, towerTransform.y);
-					var projectileRender = Game.Components.RenderComponent('arrow_projectile', 1, 1.0, true);
-					var projectileComponent = Game.Components.ProjectileComponent(towerAttack.target_id, 200, towerAttack.damage);
-					Game.EntityManager.addComponent(projectileId, projectileTransform);
-					Game.EntityManager.addComponent(projectileId, projectileRender);
-					Game.EntityManager.addComponent(projectileId, projectileComponent);
-					// Update tower's last attack time
-					towerAttack.last_attack_time = currentTime;
+					// Get target position to calculate initial direction
+					var targetTransform = Game.EntityManager.componentStores['TransformComponent'][towerAttack.target_id];
+					if (targetTransform) {
+						// Calculate direction vector
+						var dx = targetTransform.x - towerTransform.x;
+						var dy = targetTransform.y - towerTransform.y;
+						var distance = Math.sqrt(dx * dx + dy * dy);
+						var directionX = dx / distance;
+						var directionY = dy / distance;
+						// Create projectile
+						var projectileId = Game.EntityManager.createEntity();
+						var projectileTransform = Game.Components.TransformComponent(towerTransform.x, towerTransform.y);
+						var projectileRender = Game.Components.RenderComponent('arrow_projectile', 1, 1.0, true);
+						var projectileComponent = Game.Components.ProjectileComponent(towerAttack.target_id, 200, towerAttack.damage, directionX, directionY);
+						Game.EntityManager.addComponent(projectileId, projectileTransform);
+						Game.EntityManager.addComponent(projectileId, projectileRender);
+						Game.EntityManager.addComponent(projectileId, projectileComponent);
+						// Update tower's last attack time
+						towerAttack.last_attack_time = currentTime;
+					}
 				}
 			}
 			// Move projectiles and check for impacts
 			var projectiles = Game.EntityManager.getEntitiesWithComponents(['ProjectileComponent', 'TransformComponent']);
@@ -574,11 +586,11 @@
 							Game.Systems.RenderSystem.displayObjects[projectileId].destroy();
 							delete Game.Systems.RenderSystem.displayObjects[projectileId];
 						}
 					} else {
-						// Move projectile
-						var moveX = dx / distance * projectileComp.speed;
-						var moveY = dy / distance * projectileComp.speed;
+						// Move projectile using stored direction
+						var moveX = projectileComp.directionX * projectileComp.speed;
+						var moveY = projectileComp.directionY * projectileComp.speed;
 						projectileTransform.x += moveX;
 						projectileTransform.y += moveY;
 					}
 				}