var playerGold = 30;
var playerScore = 0;
var enemySpawnDelay = 120;
var upgradeLevel = 0;
var upgradeCost = 100;
var towerDamage = [1, 1.5, 2, 2.5, 3, 3.5, 4, 5, 8];
var TreasureChest = Container.expand(function () {
	var self = Container.call(this);
	var chestGraphics = self.createAsset('treasureChestSprite', 'Treasure Chest Sprite', 0.5, 0.5);
	self.addChild(chestGraphics);
});
var UpgradeButton = Container.expand(function () {
	var self = Container.call(this);
	var upgradeButtonGraphics = self.createAsset('buttonSprite', 'Button Sprite', 0.5, 0.5);
	self.addChild(upgradeButtonGraphics);
});
var GoldCoin = Container.expand(function (startX, startY, endX, endY, delay) {
	var self = Container.call(this);
	GoldCoin.delayIncrement = 0;
	self.game = this;
	var coinGraphics = self.createAsset('goldCoinSprite', 'Gold Coin Sprite', 0.5, 0.5);
	self.addChild(coinGraphics);
	self.x = startX;
	self.y = startY;
	var distance = Math.sqrt(Math.pow(endX - startX, 2) + Math.pow(endY - startY, 2));
	self.delayCounter = delay;
	var duration = 60 + delay;
	var vx = (endX - startX) / duration;
	var vy = (endY - startY) / duration;
	self.alpha = 0;
	self.move = function () {
		if (self.delayCounter > 0) {
			self.delayCounter--;
		} else {
			self.alpha = 1;
			self.x += vx;
			self.y += vy;
		}
		if (--duration <= 0) {
			self.destroy();
		}
	};
});
var CityWall = Container.expand(function () {
	var self = Container.call(this);
	var wallGraphics = self.createAsset('cityWallSprite', 'City Wall Sprite', 0.5, 0.5);
	self.addChild(wallGraphics);
});
var TrollEnemy = Container.expand(function () {
	var self = Container.call(this);
	var trollGraphics = self.createAsset('trollSprite', 'Troll Enemy Sprite', .5, .5);
	trollGraphics.scale.set(2.5);
	self.hitpoints = 30;
	self.move = function (towers) {
		var minDist = Infinity;
		var closestTower = null;
		for (var i = 0; i < self.game.towers.length; i++) {
			var dx = self.game.towers[i].x - self.x;
			var dy = self.game.towers[i].y - self.y;
			var dist = Math.sqrt(dx * dx + dy * dy);
			if (dist < minDist) {
				minDist = dist;
				closestTower = self.game.towers[i];
			}
		}
		if (closestTower && minDist < closestTower.width / 2 + this.width / 2) {
			closestTower.health -= 0.5;
			if (closestTower.health <= 0) {
				var towerIndex = self.game.towers.indexOf(closestTower);
				if (towerIndex > -1) {
					self.game.towers.splice(towerIndex, 1);
				}
				closestTower.destroy();
			}
		} else if (closestTower && minDist < 100) {
			var avoidanceForce = 8;
			var ax = this.x - closestTower.x;
			var ay = this.y - closestTower.y;
			var len = Math.sqrt(ax * ax + ay * ay);
			ax = ax / len * avoidanceForce;
			ay = ay / len * avoidanceForce;
			this.x += ax;
			this.y += ay;
		} else {
			this.zigzagCounter = this.zigzagCounter || 0;
			this.zigzagDirection = this.zigzagDirection || 1;
			if (this.zigzagCounter++ % self.zigzagTension === 0) this.zigzagDirection *= -1;
			this.x += 4 * this.zigzagDirection;
			this.y += 2;
			if (Math.random() < 0.01) {
				this.zigzagTension = Math.floor(Math.random() * 40) + 10;
			}
			if (this.x > 2048) {
				this.zigzagDirection = -1;
			}
			if (this.x < 0) {
				this.zigzagDirection = 1;
			}
			var scaleIncrement = (1 - 0.1) / 200;
			this.scale.x += scaleIncrement;
			this.scale.y += scaleIncrement;
			this.scale.x = Math.min(this.scale.x, 1);
			this.scale.y = Math.min(this.scale.y, 1);
		}
	};
	self.die = function () {
		playerGold += 20;
		playerScore += 1111;
		this.game.updateScoreLabel();
		this.game.updateGoldLabel();
		for (var i = 0; i < 10; i++) {
			var t = new GoldCoin(this.x, this.y, 720, 2500, i);
		}
		var index = this.game.enemies.indexOf(this);
		if (index > -1) {
			this.game.enemies.splice(index, 1);
		}
		this.destroy();
	};
});
var DeathKnightEnemy = Container.expand(function () {
	var self = Container.call(this);
	var dKnightGraphics = self.createAsset('deathKnightSprite', 'DeathKnight Enemy Sprite', .5, .5);
	dKnightGraphics.scale.set(2.5);
	self.hitpoints = 100;
	self.move = function (towers) {
		var minDist = Infinity;
		var closestTower = null;
		for (var i = 0; i < self.game.towers.length; i++) {
			var dx = self.game.towers[i].x - self.x;
			var dy = self.game.towers[i].y - self.y;
			var dist = Math.sqrt(dx * dx + dy * dy);
			if (dist < minDist) {
				minDist = dist;
				closestTower = self.game.towers[i];
			}
		}
		if (closestTower && minDist < closestTower.width / 2 + this.width / 2) {
			closestTower.health -= 1;
			if (closestTower.health <= 0) {
				var towerIndex = self.game.towers.indexOf(closestTower);
				if (towerIndex > -1) {
					self.game.towers.splice(towerIndex, 1);
				}
				closestTower.destroy();
			}
		} else if (closestTower && minDist < 100) {
			var avoidanceForce = 8;
			var ax = this.x - closestTower.x;
			var ay = this.y - closestTower.y;
			var len = Math.sqrt(ax * ax + ay * ay);
			ax = ax / len * avoidanceForce;
			ay = ay / len * avoidanceForce;
			this.x += ax;
			this.y += ay;
		} else {
			this.zigzagCounter = this.zigzagCounter || 0;
			this.zigzagDirection = this.zigzagDirection || 1;
			if (this.zigzagCounter++ % self.zigzagTension === 0) this.zigzagDirection *= -1;
			this.x += 4 * this.zigzagDirection;
			this.y += 2;
			if (Math.random() < 0.01) {
				this.zigzagTension = Math.floor(Math.random() * 40) + 10;
			}
			if (this.x > 2048) {
				this.zigzagDirection = -1;
			}
			if (this.x < 0) {
				this.zigzagDirection = 1;
			}
			var scaleIncrement = (1 - 0.1) / 200;
			this.scale.x += scaleIncrement;
			this.scale.y += scaleIncrement;
			this.scale.x = Math.min(this.scale.x, 1);
			this.scale.y = Math.min(this.scale.y, 1);
		}
	};
	self.die = function () {
		playerGold += 40;
		playerScore += 2222;
		this.game.updateScoreLabel();
		this.game.updateGoldLabel();
		for (var i = 0; i < 20; i++) {
			var t = new GoldCoin(this.x, this.y, 720, 2500, i);
		}
		var index = this.game.enemies.indexOf(this);
		if (index > -1) {
			this.game.enemies.splice(index, 1);
		}
		this.destroy();
	};
});
var Tower = Container.expand(function (gameInstance) {
	var self = Container.call(this);
	self.game = gameInstance;
	self.upgradeLevel = upgradeLevel;
	var towerGraphics = self.createAsset('towerSprite', 'Tower Sprite', .5, .5);
	var towerGraphics1 = self.createAsset('towerSprite1', 'Tower Sprite1', .5, .5);
	var towerGraphics2 = self.createAsset('towerSprite2', 'Tower Sprite2', .5, .5);
	var towerGraphics3 = self.createAsset('towerSprite3', 'Tower Sprite3', .5, .5);
	var towerGraphics4 = self.createAsset('towerSprite4', 'Tower Sprite4', .5, .5);
	var towerGraphics5 = self.createAsset('towerSprite5', 'Tower Sprite5', .5, .5);
	var towerGraphics6 = self.createAsset('towerSprite6', 'Tower Sprite6', .5, .5);
	var towerGraphics7 = self.createAsset('towerSprite7', 'Tower Sprite7', .5, .5);
	var towerGraphics8 = self.createAsset('towerSprite8', 'Tower Sprite8', .5, .5);
	towerGraphics.scale.set(2);
	towerGraphics1.scale.set(2);
	towerGraphics2.scale.set(2);
	towerGraphics3.scale.set(2);
	towerGraphics4.scale.set(2);
	towerGraphics5.scale.set(2);
	towerGraphics6.scale.set(2);
	towerGraphics7.scale.set(2);
	towerGraphics8.scale.set(2);
	towerGraphics1.alpha = 0;
	towerGraphics2.alpha = 0;
	towerGraphics3.alpha = 0;
	towerGraphics4.alpha = 0;
	towerGraphics5.alpha = 0;
	towerGraphics6.alpha = 0;
	towerGraphics7.alpha = 0;
	towerGraphics8.alpha = 0;
	var a = [towerGraphics1, towerGraphics2, towerGraphics3, towerGraphics4, towerGraphics5, towerGraphics6, towerGraphics7, towerGraphics8];
	if (upgradeLevel > 0) {
		towerGraphics.alpha = 0;
		for (var i = 0; i < 8; i++) {
			if (i + 1 == upgradeLevel) {
				a[i].alpha = 1;
			} else {
				a[i].alpha = 0;
			}
		}
	}
	self.shoot = function (enemies) {
		if (self.shootCounter++ % 60 === 0) {
			for (var i = 0; i < enemies.length; i++) {
				var enemy = enemies[i];
				var dx = enemy.x - self.x;
				var dy = enemy.y - self.y;
				var distance = Math.sqrt(dx * dx + dy * dy);
				if (distance <= 300) {
					console.log('shot');
					var bullet = new Bullet(self.upgradeLevel);
					bullet.x = self.x;
					bullet.y = self.y;
					bullet.target = enemy;
					var tx = bullet.target.x - bullet.x;
					var ty = bullet.target.y - bullet.y;
					var rad = Math.atan2(ty, tx);
					bullet.rotation = rad + Math.PI / 2;
					bullet.vx = Math.cos(rad);
					bullet.vy = Math.sin(rad);
					self.game.addBullet(bullet);
					break;
				}
			}
		}
	};
	self.upgrade = function () {};
	self.shootCounter = 0;
	self.health = 200;
});
var Enemy = Container.expand(function () {
	var self = Container.call(this);
	var enemyGraphics = self.createAsset('enemySprite', 'Enemy Sprite', .5, .5);
	enemyGraphics.scale.set(0.8);
	self.hitpoints = 3;
	self.zigzagTension = Math.floor(Math.random() * 40) + 10;
	self.move = function (towers) {
		var minDist = Infinity;
		var closestTower = null;
		for (var i = 0; i < self.game.towers.length; i++) {
			var dx = self.game.towers[i].x - self.x;
			var dy = self.game.towers[i].y - self.y;
			var dist = Math.sqrt(dx * dx + dy * dy);
			if (dist < minDist) {
				minDist = dist;
				closestTower = self.game.towers[i];
			}
		}
		if (closestTower && minDist < closestTower.width / 2 + this.width / 2) {
			closestTower.health -= 0.5;
			if (closestTower.health <= 0) {
				var towerIndex = self.game.towers.indexOf(closestTower);
				if (towerIndex > -1) {
					self.game.towers.splice(towerIndex, 1);
				}
				closestTower.destroy();
			}
		} else if (closestTower && minDist < 100) {
			var avoidanceForce = 8;
			var ax = this.x - closestTower.x;
			var ay = this.y - closestTower.y;
			var len = Math.sqrt(ax * ax + ay * ay);
			ax = ax / len * avoidanceForce;
			ay = ay / len * avoidanceForce;
			this.x += ax;
			this.y += ay;
		} else {
			this.zigzagCounter = this.zigzagCounter || 0;
			this.zigzagDirection = this.zigzagDirection || 1;
			if (this.zigzagCounter++ % self.zigzagTension === 0) this.zigzagDirection *= -1;
			this.x += 4 * this.zigzagDirection;
			this.y += 2;
			if (Math.random() < 0.01) {
				this.zigzagTension = Math.floor(Math.random() * 40) + 10;
			}
			if (this.x > 2048) {
				this.zigzagDirection = -1;
			}
			if (this.x < 0) {
				this.zigzagDirection = 1;
			}
			var scaleIncrement = (1 - 0.1) / 200;
			this.scale.x += scaleIncrement;
			this.scale.y += scaleIncrement;
			this.scale.x = Math.min(this.scale.x, 1);
			this.scale.y = Math.min(this.scale.y, 1);
		}
	};
	self.die = function () {
		playerGold += 5;
		playerScore += 100;
		this.game.updateScoreLabel();
		this.game.updateGoldLabel();
		for (var i = 0; i < 4; i++) {
			var t = new GoldCoin(this.x, this.y, 720, 2500, i);
			this.game.addChild(t);
			this.game.goldCoins.push(t);
		}
		var index = this.game.enemies.indexOf(this);
		if (index > -1) {
			this.game.enemies.splice(index, 1);
		}
		this.destroy();
	};
});
var Bullet = Container.expand(function (upgradeLevel) {
	var self = Container.call(this);
	self.game = null;
	self.damage = towerDamage[upgradeLevel];
	var bulletGraphics = self.createAsset('bullet', 'Bullet Graphics', .5, .5);
	bulletGraphics.scale.set(0.2);
	self.vx = 0;
	self.vy = 0;
	self.move = function () {
		if (this.target) {
			var tx = this.target.x - this.x;
			var ty = this.target.y - this.y;
			var dist = Math.sqrt(tx * tx + ty * ty);
			if (dist > 0) {
				this.x += this.vx * 10;
				this.y += this.vy * 10;
			}
			if (dist < this.width / 2 + this.target.width / 2) {
				this.hit();
			} else if (this.x < 0 || this.x > 2048 || this.y < 0 || this.y > 2732) {
				this.destroy();
			}
		}
	};
	self.hit = function () {
		this.target.hitpoints -= this.damage;
		if (this.target.hitpoints <= 0) {
			this.target.die();
		}
		this.destroy();
	};
});
var Game = Container.expand(function () {
	var self = Container.call(this);
	self.updateGoldLabel = function () {
		goldLabel.setText('Gold: ' + playerGold);
	};
	self.updateScoreLabel = function () {
		scoreLabel.setText('Score: ' + playerScore);
	};
	self.updateCostLabel = function () {
		costLabel.setText('Cost: ' + upgradeCost);
	};
	self.playerGold = 0;
	self.addBullet = function (bullet) {
		bullets.push(bullet);
		self.addChild(bullet);
	};
	self.sufficientDistanceToOtherTowers = function (position) {
		for (var i = 0; i < self.towers.length; i++) {
			var tower = self.towers[i];
			var dx = tower.x - position.x;
			var dy = tower.y - position.y;
			var distance = Math.sqrt(dx * dx + dy * dy);
			if (distance < 120) {
				return false;
			}
		}
		return true;
	};
	var background = self.createAsset('background', 'Background Image', 0, 0);
	background.width = 2048;
	background.height = 2732;
	background.y = 0;
	self.addChildAt(background, 0);
	self.towers = [];
	self.enemies = [];
	var bullets = [];
	self.goldCoins = [];
	var selectedTowerType = null;
	var initialEnemy = new Enemy();
	initialEnemy.game = self;
	initialEnemy.x = 300 + Math.random() * (1848 - 300);
	initialEnemy.y = 200;
	initialEnemy.scale.set(0.1);
	self.enemies.push(initialEnemy);
	self.addChild(initialEnemy);
	LK.on('tick', function () {
		self.enemySpawnCounter = self.enemySpawnCounter || 0;
		self.totalEnemiesSpawned = self.totalEnemiesSpawned || 0;
		if (++self.enemySpawnCounter >= enemySpawnDelay) {
			var newEnemy;
			if (self.totalEnemiesSpawned > 3 && self.totalEnemiesSpawned % 50 == 0) {
				newEnemy = new DeathKnightEnemy();
			} else if (self.totalEnemiesSpawned > 3 && self.totalEnemiesSpawned % 10 == 0) {
				newEnemy = new TrollEnemy();
			} else {
				newEnemy = new Enemy();
			}
			if (newEnemy) {
				newEnemy.game = self;
				newEnemy.x = 300 + Math.random() * (1848 - 300);
				newEnemy.y = 200;
				newEnemy.scale.set(0.1);
				self.enemies.push(newEnemy);
				self.addChild(newEnemy);
			}
			self.totalEnemiesSpawned++;
			if (self.totalEnemiesSpawned > 0 && self.totalEnemiesSpawned % 20 == 0) {
				enemySpawnDelay -= 4;
				if (enemySpawnDelay < 20) {
					enemySpawnDelay = 20;
				}
			}
			self.enemySpawnCounter = 0;
		}
		for (var i = 0; i < self.enemies.length; i++) {
			self.enemies[i].move();
			if (self.enemies[i].y >= 2332 - self.enemies[i].height / 2) {
				LK.showGameOver();
			}
		}
		for (var j = 0; j < self.towers.length; j++) {
			self.towers[j].shoot(self.enemies);
		}
		for (var k = bullets.length - 1; k >= 0; k--) {
			bullets[k].move();
			if (!bullets[k].parent) {
				bullets.splice(k, 1);
			}
		}
		for (var l = self.goldCoins.length - 1; l >= 0; l--) {
			self.goldCoins[l].move();
			if (!self.goldCoins[l].parent) {
				self.goldCoins.splice(l, 1);
			}
		}
	});
	stage.on('down', function (obj) {
		var position = obj.event.getLocalPosition(self);
		if (position.y >= 600 && position.y <= 2250) {
			if (playerGold >= 10) {
				if (self.sufficientDistanceToOtherTowers(position)) {
					playerGold -= 10;
					var newTower = self.addChild(new Tower(self));
					newTower.x = position.x;
					newTower.y = position.y;
					self.addChildAt(newTower, Math.min(Math.floor(newTower.y), self.children.length));
					self.towers.push(newTower);
					if (false) {
						self.towers.sort(function (a, b) {
							return a.y - b.y;
						});
						self.towers.forEach(function (tower, index) {
							self.addChildAt(tower, 6 + index);
							console.log('y and zIndex:' + tower.y + ', ' + tower.parent.getChildIndex(tower));
						});
					}
					self.updateGoldLabel();
				}
			}
		}
	});
	stage.on('move', function (obj) {});
	stage.on('up', function (obj) {});
	var cityWall = self.addChild(new CityWall());
	cityWall.y = 2632;
	cityWall.x = 332;
	cityWall.scale.y = 0.5;
	cityWall.scale.x = 0.5;
	var cityWall2 = self.addChild(new CityWall());
	cityWall2.y = 2632;
	cityWall2.x = 1012;
	cityWall2.scale.y = 0.5;
	cityWall2.scale.x = 0.5;
	var cityWall3 = self.addChild(new CityWall());
	cityWall3.y = 2632;
	cityWall3.x = 1691;
	cityWall3.scale.y = 0.5;
	cityWall3.scale.x = 0.5;
	var bottomBlackBox = self.createAsset('blackBox', 'Black Box at bottom', 0, 1);
	bottomBlackBox.width = 2048;
	bottomBlackBox.height = 400;
	bottomBlackBox.y = 2732;
	self.addChild(bottomBlackBox);
	var goldLabel = new Text2('Gold: 30', {
		size: 100,
		fill: '#ffd700',
		align: 'left',
		dropShadow: true
	});
	goldLabel.x = 120;
	goldLabel.y = 2632 - bottomBlackBox.height + (bottomBlackBox.height - goldLabel.height) / 2;
	self.addChild(goldLabel);
	var scoreLabel = new Text2('Score: 0', {
		size: 100,
		fill: '#ccbbff',
		align: 'left',
		dropShadow: true
	});
	scoreLabel.x = 120;
	scoreLabel.y = 2772 - bottomBlackBox.height + (bottomBlackBox.height - scoreLabel.height) / 2;
	self.addChild(scoreLabel);
	var instructionLabel = new Text2("Tap to build towers (cost 10 gold)\nDon't let enemies reach the City Wall!", {
		size: 58,
		fill: '#eeeeee',
		align: 'left',
		dropShadow: true
	});
	instructionLabel.x = 920;
	instructionLabel.y = 2632 - bottomBlackBox.height + (bottomBlackBox.height - instructionLabel.height) / 2;
	self.addChild(instructionLabel);
	var treasureChest = self.addChild(new TreasureChest());
	treasureChest.scale.x = 1.3;
	treasureChest.scale.y = 1.3;
	treasureChest.x = 720;
	treasureChest.y = goldLabel.y + 65;
	var upgradeButton = self.addChild(new UpgradeButton());
	upgradeButton.x = 1500;
	upgradeButton.y = 2590;
	self.upgradeLabel = new Text2("Upgrade Towers:", {
		size: 58,
		fill: '#dddddd',
		align: 'left',
		dropShadow: true
	});
	self.upgradeLabel.x = 920;
	self.upgradeLabel.y = 2552;
	self.addChild(self.upgradeLabel);
	var costLabel = new Text2("Cost: 100", {
		size: 58,
		fill: '#dddd00',
		align: 'left',
		dropShadow: true
	});
	costLabel.x = 1600;
	costLabel.y = 2552;
	self.addChild(costLabel);
	self.upgradeTowers = function () {
		if (playerGold >= upgradeCost) {
			playerGold -= upgradeCost;
			upgradeLevel += 1;
			upgradeCost *= 2;
			self.updateGoldLabel();
			self.updateCostLabel();
			if (upgradeLevel == 8) {
				self.upgradeLabel.setText('All upgraded - Go for the High Score!');
				if (upgradeButton) {
					upgradeButton.destroy();
					upgradeButton = null;
				}
				if (costLabel) {
					costLabel.destroy();
					costLabel = null;
				}
			}
		}
	};
	upgradeButton.on('down', self.upgradeTowers);
});

===================================================================
--- original.js
+++ change.js
@@ -470,10 +470,10 @@
 				if (self.sufficientDistanceToOtherTowers(position)) {
 					playerGold -= 10;
 					var newTower = self.addChild(new Tower(self));
 					newTower.x = position.x;
-					newTower.y = Math.floor(position.y);
-					self.addChildAt(newTower, self.children.length);
+					newTower.y = position.y;
+					self.addChildAt(newTower, Math.min(Math.floor(newTower.y), self.children.length));
 					self.towers.push(newTower);
 					if (false) {
 						self.towers.sort(function (a, b) {
 							return a.y - b.y;