/**** 
* Classes
****/ 
var Arrow = Container.expand(function (target) {
	var self = Container.call(this);
	var arrowGraphics = self.attachAsset('arrow', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	self.speed = 18;
	self.angle = 0;
	self.target = target;
	self.lastX = self.x;
	self.lastY = self.y;
	self._move_migrated = function () {
		// Move in the direction of angle
		self.lastX = self.x;
		self.lastY = self.y;
		self.x += self.speed * Math.cos(self.angle);
		self.y += self.speed * Math.sin(self.angle);
		self.rotation = self.angle;
	};
	return self;
});
var Bullet = Container.expand(function () {
	var self = Container.call(this);
	var bulletGraphics = self.attachAsset('bullet', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	self.speed = 20;
	self.isSpinning = false;
	self.orbitRadius = 220;
	self.orbitSpeed = 0.07;
	self.orbitAngle = 0;
	self._move_migrated = function () {
		if (self.isSpinning) {
			// Orbit around hero
			self.orbitAngle += self.orbitSpeed;
			self.x = hero.x + self.orbitRadius * Math.cos(self.orbitAngle);
			self.y = hero.y + self.orbitRadius * Math.sin(self.orbitAngle);
			self.rotation += 0.2;
		} else {
			self.x += self.speed * Math.cos(self.angle);
			self.y += self.speed * Math.sin(self.angle);
			self.rotation += 0.1;
		}
	};
});
var Enemy = Container.expand(function (hero) {
	var self = Container.call(this);
	var enemyGraphics = self.attachAsset('enemy', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	self.health = 1; // Enemy needs 1 hit to die
	self._move_migrated = function () {
		var dx = hero.x - self.x;
		var dy = hero.y - self.y;
		var distance = Math.sqrt(dx * dx + dy * dy);
		// Enemy does NOT stop or fire arrows, just moves toward hero
		self.x += dx / distance * 1.8;
		self.y += dy / distance * 1.8;
	};
});
var Enemy2 = Container.expand(function (hero) {
	var self = Container.call(this);
	var enemy2Graphics = self.attachAsset('enemy2', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	self.health = 3; // Enemy2 needs 3 hits to die
	self._move_migrated = function () {
		var dx = hero.x - self.x;
		var dy = hero.y - self.y;
		var distance = Math.sqrt(dx * dx + dy * dy);
		// Enemy2 does NOT stop or fire arrows, just moves toward hero
		self.x += dx / distance * 1.25;
		self.y += dy / distance * 1.25;
	};
});
var Enemy3 = Container.expand(function (hero) {
	var self = Container.call(this);
	var enemy3Graphics = self.attachAsset('enemy3', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	self.health = 2; // Enemy3 needs 2 hits to die
	self.arrowCooldown = 0;
	self._move_migrated = function () {
		var dx = hero.x - self.x;
		var dy = hero.y - self.y;
		var distance = Math.sqrt(dx * dx + dy * dy);
		// --- Enemy3 stop and arrow logic ---
		if (typeof self.stopTimer === "undefined") self.stopTimer = 0;
		if (distance <= heroStopRadius) {
			if (self.stopTimer === 0) {
				self.stopTimer = 180; // 3 seconds at 60fps
			}
			if (self.stopTimer > 0) {
				self.stopTimer--;
				// After 3 seconds, fire an arrow at the hero and reset timer
				if (self.stopTimer === 0) {
					var arrow = new Arrow(hero);
					arrow.x = self.x;
					arrow.y = self.y;
					arrow.angle = Math.atan2(hero.y - self.y, hero.x - self.x);
					enemyBullets.push(arrow);
					game.addChild(arrow);
					// Double the arrow sending time for next time
					self.stopTimer = 360; // 6 seconds
				}
				return; // Enemy3 stays stopped
			}
		} else {
			self.stopTimer = 0; // Reset timer if out of radius
		}
		self.x += dx / distance * 2.5;
		self.y += dy / distance * 2.5;
		// Remove original arrow attack logic for Enemy3
	};
});
var Hero = Container.expand(function () {
	var self = Container.call(this);
	var heroGraphics = self.attachAsset('hero', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	self._move_migrated = function () {
		if (self.targetPos) {
			var dx = self.targetPos.x - self.x;
			var dy = self.targetPos.y - self.y;
			var distance = Math.sqrt(dx * dx + dy * dy);
			if (distance > 5) {
				self.x += dx / distance * 10;
				self.y += dy / distance * 10;
			} else {
				self.x = self.targetPos.x;
				self.y = self.targetPos.y;
				self.targetPos = null;
			}
		}
	};
});

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

/**** 
* Game Code
****/ 
// You should replace id with a unique asset for enemy2
game.setBackgroundColor(0xE2C275);
var hero = game.addChild(new Hero());
hero.enemies = [];
var heroBullets = [];
var enemyBullets = [];
// No bullet pool needed for spinning bullet logic
// Create a container to group all hero bullets
var gameBulletsContainer = new Container();
game.addChild(gameBulletsContainer);
hero.x = 2048 / 2;
hero.y = 2732 / 2;
game.targetPos = null;
// Arrow hit counter UI
var arrowCounterTxt = new Text2('0', {
	size: 100,
	fill: 0xFFFFFF
});
arrowCounterTxt.anchor.set(1, 0.5); // right-aligned, vertically centered
LK.gui.left.addChild(arrowCounterTxt);
// Show a label for clarity
var arrowCounterLabel = new Text2('Arrow Hits', {
	size: 50,
	fill: 0xFFFFFF
});
arrowCounterLabel.anchor.set(1, 0.5);
LK.gui.left.addChild(arrowCounterLabel);
arrowCounterLabel.y = -80;
// Total points counter UI
var pointsCounterTxt = new Text2('0', {
	size: 120,
	fill: 0x000000
});
pointsCounterTxt.anchor.set(0.5, 0); // center top
LK.gui.top.addChild(pointsCounterTxt);
var pointsCounterLabel = new Text2('Points', {
	size: 50,
	fill: 0xFFD700
});
pointsCounterLabel.anchor.set(0.5, 0);
pointsCounterLabel.y = 110;
LK.gui.top.addChild(pointsCounterLabel);
// Add a large invisible circle radius for enemy stop logic (3x original size)
var heroStopRadius = 750; // large size, 3x original
game.on('down', function (x, y, obj) {
	hero.targetPos = game.toLocal(obj.global);
});
var spawnEnemy = function spawnEnemy() {
	var side = Math.floor(Math.random() * 4);
	var enemy;
	var rand = Math.random();
	// --- Enemy Pooling for Enemy type 1 ---
	if (typeof game.enemyPool === "undefined") {
		game.enemyPool = [];
	}
	// Helper to get an inactive Enemy from the pool
	function getEnemyFromPool() {
		for (var i = 0; i < game.enemyPool.length; i++) {
			if (!game.enemyPool[i].active) {
				return game.enemyPool[i];
			}
		}
		return null;
	}
	// Use pool for Enemy (type 1 only) for now
	if (rand < 0.6) {
		enemy = getEnemyFromPool();
		if (enemy) {
			// Reset health and state
			enemy.health = 1;
			enemy.active = true;
			enemy.visible = true;
		} else {
			enemy = new Enemy(hero);
			game.enemyPool.push(enemy);
		}
	} else if (rand < 0.85) {
		// For Enemy2 and Enemy3, still create new (or you can pool them separately if desired)
		enemy = new Enemy2(hero);
	} else {
		enemy = new Enemy3(hero);
	}
	switch (side) {
		case 0:
			enemy.x = Math.random() * 2048;
			enemy.y = 0;
			break;
		case 1:
			enemy.x = 2048;
			enemy.y = Math.random() * 2732;
			break;
		case 2:
			enemy.x = Math.random() * 2048;
			enemy.y = 2732;
			break;
		case 3:
			enemy.x = 0;
			enemy.y = Math.random() * 2732;
			break;
	}
	hero.enemies.push(enemy);
	game.addChild(enemy);
};
LK.on('tick', function () {
	hero._move_migrated();
	for (var i = 0; i < heroBullets.length; i++) {
		heroBullets[i]._move_migrated();
	}
	for (var i = 0; i < enemyBullets.length; i++) {
		enemyBullets[i]._move_migrated();
	}
	// Track arrow hits on hero
	if (typeof hero.arrowHits === "undefined") {
		hero.arrowHits = 0;
	}
	arrowCounterTxt.setText(hero.arrowHits + "");
	// Use toDestroy arrays for batch removals
	var toDestroyEnemyBullets = [];
	for (var i = enemyBullets.length - 1; i >= 0; i--) {
		if (enemyBullets[i].intersects(hero)) {
			// Deactivate and hide enemy bullet instead of destroy
			enemyBullets[i].active = false;
			enemyBullets[i].visible = false;
			toDestroyEnemyBullets.push(i);
			hero.arrowHits++;
			if (hero.arrowHits >= 10) {
				LK.showGameOver();
			}
			arrowCounterTxt.setText(hero.arrowHits + "");
		}
	}
	for (var idx = 0; idx < toDestroyEnemyBullets.length; idx++) {
		enemyBullets.splice(toDestroyEnemyBullets[idx], 1);
	}
	toDestroyEnemyBullets = [];
	// Track Enemy2 kills for arrow reset
	if (typeof hero.enemy2Kills === "undefined") {
		hero.enemy2Kills = 0;
	}
	// Track total kills for bullet upgrades
	if (typeof hero.totalKills === "undefined") {
		hero.totalKills = 0;
	}
	// Use toDestroy arrays for enemies and heroBullets
	var toDestroyEnemies = [];
	var toDestroyHeroBullets = [];
	if (typeof game.totalPoints === "undefined") {
		game.totalPoints = 0;
	}
	for (var i = 0; i < hero.enemies.length; i++) {
		hero.enemies[i]._move_migrated();
		// Check all spinning bullets for collision
		var killed = false;
		for (var b = 0; b < heroBullets.length; b++) {
			var bullet = heroBullets[b];
			if (bullet && bullet.intersects(hero.enemies[i])) {
				// Instantly destroy enemy on contact with spinning bullet
				if (typeof hero.enemies[i].health === "number") {
					hero.enemies[i].health = 0;
				}
				// Deactivate and hide enemy instead of destroy
				hero.enemies[i].active = false;
				hero.enemies[i].visible = false;
				toDestroyEnemies.push(i);
				// Points logic
				if (hero.enemies[i].attachAsset && hero.enemies[i].attachAsset.toString().indexOf("enemy2") !== -1) {
					hero.enemy2Kills++;
					if (hero.enemy2Kills >= 3) {
						hero.arrowHits = 0;
						hero.enemy2Kills = 0;
						arrowCounterTxt.setText(hero.arrowHits + "");
					}
					game.totalPoints += 5; // Enemy2 = 5 points
				} else if (hero.enemies[i].attachAsset && hero.enemies[i].attachAsset.toString().indexOf("enemy3") !== -1) {
					game.totalPoints += 7; // Enemy3 = 7 points
				} else {
					game.totalPoints += 1; // Enemy = 1 point
				}
				hero.totalKills++; // Increment total kills
				pointsCounterTxt.setText(game.totalPoints + "");
				killed = true;
				break; // Only kill once per enemy
			}
		}
		if (killed) continue;
		if (hero.intersects(hero.enemies[i])) {
			LK.showGameOver();
		}
	}
	// Remove heroBullets marked for destruction (from highest to lowest index)
	heroBullets = heroBullets.filter(function (bullet, idx) {
		return toDestroyHeroBullets.indexOf(idx) === -1;
	});
	toDestroyHeroBullets = [];
	// Remove enemies marked for destruction (from highest to lowest index)
	hero.enemies = hero.enemies.filter(function (enemy, idx) {
		return toDestroyEnemies.indexOf(idx) === -1;
	});
	toDestroyEnemies = [];
	if (LK.ticks % 30 === 0) {
		if (hero.enemies.length < 25) {
			spawnEnemy();
		}
	}
	// --- VU mode timer logic ---
	if (typeof game.vuModeActive !== "undefined" && game.vuModeActive) {
		if (typeof game.vuModeTimer === "undefined") game.vuModeTimer = 0;
		game.vuModeTimer--;
		if (game.vuModeTimer <= 0) {
			game.vuModeActive = false;
			game.vuModeTimer = 0;
		}
	}
	// --- CYCLE COUNTER ---
	if (typeof game.cycleCount === "undefined") {
		game.cycleCount = 0;
	}
	// --- END CYCLE COUNTER ---
	// --- SPINNING BULLET LOGIC ---
	// Track how many spinning bullets we should have
	if (typeof game.spinningBulletCount === "undefined") {
		game.spinningBulletCount = 1;
	}
	if (typeof game.lastSpinningBulletUpgradeKills === "undefined") {
		game.lastSpinningBulletUpgradeKills = 0;
	}
	// Check if we need to increase the number of spinning bullets
	if (typeof hero.totalKills !== "undefined" && hero.totalKills - game.lastSpinningBulletUpgradeKills >= 10) {
		var newCount = Math.floor(hero.totalKills / 10) + 1;
		if (newCount > game.spinningBulletCount) {
			game.spinningBulletCount = newCount;
			game.lastSpinningBulletUpgradeKills = Math.floor(hero.totalKills / 10) * 10;
		}
		// No reset or special logic after 100 kills; spinning bullet count can increase indefinitely
	}
	// Ensure we have the correct number of spinning bullets
	if (!Array.isArray(game.spinningBullets)) {
		game.spinningBullets = [];
	}
	// Add bullets if needed
	while (game.spinningBullets.length < game.spinningBulletCount) {
		var idx = game.spinningBullets.length;
		var spinningBullet = new Bullet();
		spinningBullet.isSpinning = true;
		spinningBullet.active = true;
		spinningBullet.visible = true;
		spinningBullet.angle = 0;
		spinningBullet.orbitRadius = 220;
		spinningBullet.orbitSpeed = 0.07;
		spinningBullet.orbitAngle = 2 * Math.PI * idx / game.spinningBulletCount;
		spinningBullet._move_migrated = function () {
			// Orbit around hero
			this.orbitAngle += this.orbitSpeed;
			// Distribute bullets evenly
			var myIndex = game.spinningBullets.indexOf(this);
			var total = game.spinningBullets.length;
			var baseAngle = 2 * Math.PI * myIndex / total;
			this.x = hero.x + this.orbitRadius * Math.cos(this.orbitAngle + baseAngle);
			this.y = hero.y + this.orbitRadius * Math.sin(this.orbitAngle + baseAngle);
			this.rotation += 0.2;
		};
		game.spinningBullets.push(spinningBullet);
		gameBulletsContainer.addChild(spinningBullet);
	}
	// Remove bullets if needed
	while (game.spinningBullets.length > game.spinningBulletCount) {
		var removed = game.spinningBullets.pop();
		if (removed && removed.parent) {
			removed.parent.removeChild(removed);
		}
	}
	// Always keep the spinning bullets in heroBullets for collision logic
	heroBullets = game.spinningBullets.slice();
	// --- END SPINNING BULLET LOGIC ---
});
function performanceOptimization() {
	// Her 60 saniyede bir çalıştır
	heroBullets = heroBullets.filter(function (b) {
		return b.active;
	});
	hero.enemies = hero.enemies.filter(function (e) {
		return e.active;
	});
	if (typeof GC !== "undefined" && typeof GC.clean === "function") {
		GC.clean();
	}
}
// 60 saniyede bir çalıştırmak için interval ekle
LK.setInterval(performanceOptimization, 60000);

===================================================================
--- original.js
+++ change.js
@@ -385,8 +385,9 @@
 		if (newCount > game.spinningBulletCount) {
 			game.spinningBulletCount = newCount;
 			game.lastSpinningBulletUpgradeKills = Math.floor(hero.totalKills / 10) * 10;
 		}
+		// No reset or special logic after 100 kills; spinning bullet count can increase indefinitely
 	}
 	// Ensure we have the correct number of spinning bullets
 	if (!Array.isArray(game.spinningBullets)) {
 		game.spinningBullets = [];