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

/**** 
* Classes
****/ 
// Monster class
var Monster = Container.expand(function () {
	var self = Container.call(this);
	// Monster type: "normal", "fast", "slow", "giant", "tiny"
	self.type = "normal";
	// Attach monster asset
	var monsterSprite = self.attachAsset('monster', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	// Color by type after setType is called
	self.updateTypeVisual = function () {
		if (self.type === "fast") {
			monsterSprite.tint = 0x3e8ecf; // blue for fast
			monsterSprite.width = 160;
			monsterSprite.height = 160;
		} else if (self.type === "slow") {
			monsterSprite.tint = 0xcfb53e; // gold for slow
			monsterSprite.width = 160;
			monsterSprite.height = 160;
		} else if (self.type === "giant") {
			monsterSprite.tint = 0x8e44ad; // purple for giant
			monsterSprite.width = 240;
			monsterSprite.height = 240;
		} else if (self.type === "tiny") {
			monsterSprite.tint = 0xffffff; // white for tiny
			monsterSprite.width = 80;
			monsterSprite.height = 80;
		} else {
			monsterSprite.tint = 0x3ecf4c; // green for normal
			monsterSprite.width = 160;
			monsterSprite.height = 160;
		}
	};
	var _oldSetType = self.setType;
	self.setType = function (type) {
		_oldSetType(type);
		self.updateTypeVisual();
	};
	// Movement speed (pixels per tick)
	self.speed = 0;
	// Store base speed for stage scaling
	self.speedBase = 0;
	// Movement direction (radians)
	self.direction = 0;
	// Is monster alive
	self.alive = true;
	// Set monster type and speed
	self.setType = function (type) {
		self.type = type;
		if (type === "fast") {
			// Fast monsters: 5-8 px/tick
			self.speed = 5 + Math.random() * 3;
		} else if (type === "slow") {
			// Slow monsters: 1-2.5 px/tick
			self.speed = 1 + Math.random() * 1.5;
		} else if (type === "giant") {
			// Giant monsters: 1-2 px/tick (slow, big)
			self.speed = 1 + Math.random();
		} else if (type === "tiny") {
			// Tiny monsters: 7 + Math.random() * 4;
			self.speed = 7 + Math.random() * 4;
		} else {
			// Normal monsters: 2-6 px/tick
			self.speed = 2 + Math.random() * 4;
		}
		// Store base speed and apply stage multiplier
		self.speedBase = self.speed;
		var speedMultiplier = 1 + (typeof stage !== "undefined" ? stage : 0) * 0.5;
		self.speed = self.speedBase * speedMultiplier;
	};
	// Set random movement
	self.setRandomMovement = function () {
		// Randomly assign type
		var r = Math.random();
		if (r < 0.16) {
			self.setType("fast");
		} else if (r < 0.32) {
			self.setType("slow");
		} else if (r < 0.48) {
			self.setType("giant");
		} else if (r < 0.64) {
			self.setType("tiny");
		} else {
			self.setType("normal");
		}
		// Direction: 0-2PI
		self.direction = Math.random() * Math.PI * 2;
	};
	// Move monster
	self.update = function () {
		if (!self.alive) return;
		// Move
		self.x += Math.cos(self.direction) * self.speed;
		self.y += Math.sin(self.direction) * self.speed;
		// Bounce off walls
		// Left
		if (self.x - monsterSprite.width / 2 < 0) {
			self.x = monsterSprite.width / 2;
			self.direction = Math.PI - self.direction;
		}
		// Right
		if (self.x + monsterSprite.width / 2 > 2048) {
			self.x = 2048 - monsterSprite.width / 2;
			self.direction = Math.PI - self.direction;
		}
		// Top
		if (self.y - monsterSprite.height / 2 < 100) {
			// leave top 100px for menu
			self.y = 100 + monsterSprite.height / 2;
			self.direction = -self.direction;
		}
		// Bottom
		if (self.y + monsterSprite.height / 2 > 2732) {
			self.y = 2732 - monsterSprite.height / 2;
			self.direction = -self.direction;
		}
	};
	// Handle tap
	self.down = function (x, y, obj) {
		if (!self.alive) return;
		self.alive = false;
		// Show hit effect
		var hitColor = 0xff4444;
		if (self.type === "fast") hitColor = 0x3e8ecf;else if (self.type === "slow") hitColor = 0xcfb53e;else if (self.type === "giant") hitColor = 0x8e44ad;else if (self.type === "tiny") hitColor = 0xffffff;
		var hit = LK.getAsset('monsterHit', {
			anchorX: 0.5,
			anchorY: 0.5,
			x: 0,
			y: 0,
			scaleX: 1,
			scaleY: 1,
			alpha: 1,
			tint: hitColor
		});
		self.addChild(hit);
		// Animate hit effect
		tween(hit, {
			scaleX: 1.5,
			scaleY: 1.5,
			alpha: 0
		}, {
			duration: 300,
			easing: tween.easeOut,
			onFinish: function onFinish() {
				hit.destroy();
			}
		});
		// Animate monster fade out
		tween(monsterSprite, {
			alpha: 0
		}, {
			duration: 200,
			onFinish: function onFinish() {
				self.destroy();
			}
		});
		// Add time and score
		if (self.type === "fast") {
			addTime(3); // fast: +3s
		} else if (self.type === "slow") {
			addTime(1); // slow: +1s
		} else if (self.type === "giant") {
			addTime(5); // giant: +5s
		} else if (self.type === "tiny") {
			addTime(0.5); // tiny: +0.5s
		} else {
			addTime(2); // normal: +2s
		}
		setScore(getScore() + 1);
		updateScoreText();
		// Remove from monsters array
		for (var i = 0; i < monsters.length; ++i) {
			if (monsters[i] === self) {
				monsters.splice(i, 1);
				break;
			}
		}
	};
	return self;
});
// Tap effect class
var TapEffect = Container.expand(function () {
	var self = Container.call(this);
	var tap = self.attachAsset('tapEffect', {
		anchorX: 0.5,
		anchorY: 0.5,
		scaleX: 1,
		scaleY: 1,
		alpha: 0.7
	});
	// Animate
	tween(tap, {
		scaleX: 2,
		scaleY: 2,
		alpha: 0
	}, {
		duration: 300,
		easing: tween.easeOut,
		onFinish: function onFinish() {
			self.destroy();
		}
	});
	return self;
});

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

/**** 
* Game Code
****/ 
// Global variables
// Monster: green ellipse, 160x160
// Monster hit effect: red ellipse, 160x160
// Tap effect: yellow ellipse, 100x100
var monsters = [];
var monsterSpawnInterval = 120; // ticks between spawns (2s)
var monsterSpawnIntervalTarget = 120; // target interval for smooth transitions
var monsterSpawnIntervalChangeTimer = 0; // ticks until next interval change
var monsterMax = 6; // max monsters on screen
var timerMax = 20; // seconds to start
var timer = timerMax; // current timer (seconds)
var timerInterval = null;
var timerBar = null;
var timerBarBg = null;
var timerText = null;
var score = 0;
var scoreText = null;
var lastTick = 0;
// Stage system
var stage = 0; // 0: Very Easy, 1: Easy, 2: Medium, 3: Hard, 4: Very Hard
var stageNames = ["Very Easy", "Easy", "Medium", "Hard", "Very Hard"];
var stageText = null;
var stageBarBg = null;
var stageBar = null;
var stageTime = 0; // seconds since game start
var stageDuration = 20; // seconds per stage
// Helper: get/set score
function getScore() {
	return score;
}
function setScore(val) {
	score = val;
}
function updateScoreText() {
	scoreText.setText(score + "");
}
// Helper: add time
function addTime(sec) {
	timer += sec;
	if (timer > 99) timer = 99;
	updateTimerText();
}
// Helper: update timer text
function updateTimerText() {
	timerText.setText(timer > 0 ? Math.ceil(timer) + "" : "0");
}
// Helper: update timer bar
function updateTimerBar() {
	var pct = Math.max(0, Math.min(1, timer / timerMax));
	timerBar.width = 800 * pct;
	if (pct > 0.5) timerBar.tint = 0x3ecf4c;else if (pct > 0.2) timerBar.tint = 0xffe066;else timerBar.tint = 0xff4444;
}
// Spawn a monster at random position
function spawnMonster() {
	if (monsters.length >= monsterMax) return;
	var m = new Monster();
	// Avoid top 100px (menu)
	var margin = 100 + 80;
	m.x = margin + Math.random() * (2048 - margin * 2);
	m.y = margin + Math.random() * (2732 - margin * 2);
	m.setRandomMovement();
	m.updateTypeVisual && m.updateTypeVisual();
	// Store base speed and apply stage multiplier
	m.speedBase = m.speed;
	var speedMultiplier = 1 + stage * 0.5;
	m.speed = m.speedBase * speedMultiplier;
	monsters.push(m);
	game.addChild(m);
}
// GUI: Score
scoreText = new Text2("0", {
	size: 120,
	fill: "#fff"
});
scoreText.anchor.set(0.5, 0);
LK.gui.top.addChild(scoreText);
// GUI: Timer bar background
timerBarBg = LK.getAsset('monster', {
	anchorX: 0,
	anchorY: 0.5,
	x: 624,
	y: 100,
	width: 800,
	height: 40,
	tint: 0x222222
});
timerBarBg.alpha = 0.5;
game.addChild(timerBarBg);
// GUI: Timer bar
timerBar = LK.getAsset('monster', {
	anchorX: 0,
	anchorY: 0.5,
	x: 624,
	y: 100,
	width: 800,
	height: 40,
	tint: 0x3ecf4c
});
game.addChild(timerBar);
// GUI: Timer text
timerText = new Text2(timerMax + "", {
	size: 90,
	fill: "#fff"
});
timerText.anchor.set(0.5, 0.5);
timerText.x = 2048 / 2;
timerText.y = 100 + 20;
game.addChild(timerText);
// Position score at top center, below 100px
scoreText.x = 2048 / 2;
scoreText.y = 10 + 100;
// GUI: Stage label and progress bar (right top, under timer bar)
stageText = new Text2(stageNames[stage], {
	size: 70,
	fill: "#fff"
});
stageText.anchor.set(1, 0); // right align
stageText.x = 2048 - 40;
stageText.y = 160;
game.addChild(stageText);
// Spawn initial monsters
for (var i = 0; i < 3; ++i) {
	spawnMonster();
}
// Timer tick
function timerTick() {
	// Timer speed multiplier: 1.0 at stage 0, 1.5 at stage 1, 2.0 at stage 2, etc.
	var timerSpeedMultiplier = 1 + stage * 0.5;
	timer -= 0.1 * timerSpeedMultiplier;
	if (timer < 0) timer = 0;
	updateTimerText();
	updateTimerBar();
	if (timer <= 0) {
		// Game over
		LK.showGameOver();
	}
	// --- Stage progression logic ---
	stageTime += 0.1;
	var newStage = Math.floor(stageTime / stageDuration);
	if (newStage > 4) newStage = 4;
	if (newStage !== stage) {
		stage = newStage;
		stageText.setText(stageNames[stage]);
		// Optionally: make game harder here (e.g. increase monsterMax, spawn rate, etc)
		// Example: increase monsterMax by 1 per stage
		monsterMax = 6 + stage;
		// Increase monster speed for all alive monsters
		var speedMultiplier = 1 + stage * 0.5;
		for (var i = 0; i < monsters.length; ++i) {
			if (monsters[i].alive) {
				monsters[i].speed = monsters[i].speedBase * speedMultiplier;
			}
		}
	}
}
// Start timer interval
timerInterval = LK.setInterval(timerTick, 100);
// Game update
game.update = function () {
	// Randomly change spawn interval every 3-6 seconds
	if (monsterSpawnIntervalChangeTimer <= 0) {
		// Pick a new target interval between 40 and 180 ticks (0.67s to 3s)
		monsterSpawnIntervalTarget = 40 + Math.floor(Math.random() * 140);
		// Next change in 180-360 ticks (3-6s)
		monsterSpawnIntervalChangeTimer = 180 + Math.floor(Math.random() * 180);
	}
	monsterSpawnIntervalChangeTimer--;
	// Smoothly approach target interval for a less abrupt change
	if (monsterSpawnInterval !== monsterSpawnIntervalTarget) {
		if (monsterSpawnInterval < monsterSpawnIntervalTarget) monsterSpawnInterval++;else monsterSpawnInterval--;
	}
	// Spawn monsters
	if (LK.ticks - lastTick >= monsterSpawnInterval) {
		spawnMonster();
		lastTick = LK.ticks;
	}
	// Move monsters
	for (var i = 0; i < monsters.length; ++i) {
		monsters[i].update();
	}
	// Update timer bar
	updateTimerBar();
};
// Handle tap on monsters or empty space
game.down = function (x, y, obj) {
	// Check if tap hits a monster (from topmost to bottom)
	var tapped = false;
	for (var i = monsters.length - 1; i >= 0; --i) {
		var m = monsters[i];
		// Only alive monsters
		if (!m.alive) continue;
		// Convert tap to monster local coords
		var local = m.toLocal(game.toGlobal({
			x: x,
			y: y
		}));
		// Check if inside monster ellipse
		var rx = m.children[0].width / 2;
		var ry = m.children[0].height / 2;
		if (local.x * local.x / (rx * rx) + local.y * local.y / (ry * ry) <= 1) {
			m.down(x, y, obj);
			tapped = true;
			break;
		}
	}
	// Tap effect
	var tapFx = new TapEffect();
	tapFx.x = x;
	tapFx.y = y;
	game.addChild(tapFx);
};
// Clean up on game over
game.on('destroy', function () {
	LK.clearInterval(timerInterval);
	monsters = [];
	score = 0;
	timer = timerMax;
	updateScoreText();
	updateTimerText();
	updateTimerBar();
	// Reset stage system
	stage = 0;
	stageTime = 0;
	stageText.setText(stageNames[stage]);
	monsterMax = 6;
});

===================================================================
--- original.js
+++ change.js
@@ -46,8 +46,10 @@
 		self.updateTypeVisual();
 	};
 	// Movement speed (pixels per tick)
 	self.speed = 0;
+	// Store base speed for stage scaling
+	self.speedBase = 0;
 	// Movement direction (radians)
 	self.direction = 0;
 	// Is monster alive
 	self.alive = true;
@@ -63,14 +65,18 @@
 		} else if (type === "giant") {
 			// Giant monsters: 1-2 px/tick (slow, big)
 			self.speed = 1 + Math.random();
 		} else if (type === "tiny") {
-			// Tiny monsters: 7-11 px/tick (very fast, small)
+			// Tiny monsters: 7 + Math.random() * 4;
 			self.speed = 7 + Math.random() * 4;
 		} else {
 			// Normal monsters: 2-6 px/tick
 			self.speed = 2 + Math.random() * 4;
 		}
+		// Store base speed and apply stage multiplier
+		self.speedBase = self.speed;
+		var speedMultiplier = 1 + (typeof stage !== "undefined" ? stage : 0) * 0.5;
+		self.speed = self.speedBase * speedMultiplier;
 	};
 	// Set random movement
 	self.setRandomMovement = function () {
 		// Randomly assign type
@@ -277,8 +283,12 @@
 	m.x = margin + Math.random() * (2048 - margin * 2);
 	m.y = margin + Math.random() * (2732 - margin * 2);
 	m.setRandomMovement();
 	m.updateTypeVisual && m.updateTypeVisual();
+	// Store base speed and apply stage multiplier
+	m.speedBase = m.speed;
+	var speedMultiplier = 1 + stage * 0.5;
+	m.speed = m.speedBase * speedMultiplier;
 	monsters.push(m);
 	game.addChild(m);
 }
 // GUI: Score
@@ -337,9 +347,11 @@
 	spawnMonster();
 }
 // Timer tick
 function timerTick() {
-	timer -= 0.1;
+	// Timer speed multiplier: 1.0 at stage 0, 1.5 at stage 1, 2.0 at stage 2, etc.
+	var timerSpeedMultiplier = 1 + stage * 0.5;
+	timer -= 0.1 * timerSpeedMultiplier;
 	if (timer < 0) timer = 0;
 	updateTimerText();
 	updateTimerBar();
 	if (timer <= 0) {
@@ -355,8 +367,15 @@
 		stageText.setText(stageNames[stage]);
 		// Optionally: make game harder here (e.g. increase monsterMax, spawn rate, etc)
 		// Example: increase monsterMax by 1 per stage
 		monsterMax = 6 + stage;
+		// Increase monster speed for all alive monsters
+		var speedMultiplier = 1 + stage * 0.5;
+		for (var i = 0; i < monsters.length; ++i) {
+			if (monsters[i].alive) {
+				monsters[i].speed = monsters[i].speedBase * speedMultiplier;
+			}
+		}
 	}
 }
 // Start timer interval
 timerInterval = LK.setInterval(timerTick, 100);