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

/**** 
* Classes
****/ 
var Bunny = Container.expand(function () {
	var self = Container.call(this);
	var bunnyGraphics = self.attachAsset('bunny', {
		anchorX: 0.5,
		anchorY: 0.5,
		scaleX: 1.5,
		scaleY: 1.5
	});
	self.berriesGiven = 0;
	self.update = function () {
		// Gentle bouncing animation
		self.y += Math.sin(LK.ticks * 0.15) * 0.3;
		// Move bunny around in a gentle pattern
		if (LK.ticks % 120 === 0) {
			// Every 2 seconds, move to a new position
			var newX = Math.random() * (1800 - 200) + 200;
			var newY = Math.random() * (2400 - 200) + 200;
			tween(self, {
				x: newX,
				y: newY
			}, {
				duration: 2000,
				easing: tween.easeInOut
			});
		}
	};
	return self;
});
var Fox = Container.expand(function () {
	var self = Container.call(this);
	var foxGraphics = self.attachAsset('fox', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	return self;
});
var NPC = Container.expand(function (type) {
	var self = Container.call(this);
	self.type = type;
	self.multiplier = type === 'mouse' ? 3 : 2;
	self.inCabin = false;
	self.frozen = false;
	self.hitPoints = type === 'dog' ? 2 : 1;
	self.isTargeted = false;
	self.rarity = 'common'; // Default rarity, will be set when spawned
	var npcGraphics = self.attachAsset(type, {
		anchorX: 0.5,
		anchorY: 0.5
	});
	// Add rarity visual indicator after graphics are created
	self.setRarityVisual = function () {
		if (self.rarity === 'uncommon') {
			npcGraphics.tint = 0x00FF00; // Green tint for uncommon
		} else if (self.rarity === 'rare') {
			npcGraphics.tint = 0xFF00FF; // Purple tint for rare
		}
		// Common NPCs keep default white tint (0xFFFFFF)
	};
	self.update = function () {
		if (self.frozen || self.inCabin) return;
		// Dog behavior during night/blood moon
		if (self.type === 'dog' && (isNight || isBloodMoon) && !self.isTargeted) {
			// Check for nearby wolves or wendigo
			var nearestThreat = null;
			var minDistance = Infinity;
			// Check wolves
			for (var w = 0; w < wolves.length; w++) {
				if (!wolves[w].stunned) {
					var dist = Math.sqrt(Math.pow(wolves[w].x - self.x, 2) + Math.pow(wolves[w].y - self.y, 2));
					if (dist < minDistance) {
						minDistance = dist;
						nearestThreat = wolves[w];
					}
				}
			}
			// Check wendigo
			if (wendigo && !wendigo.stunned) {
				var wendigoDist = Math.sqrt(Math.pow(wendigo.x - self.x, 2) + Math.pow(wendigo.y - self.y, 2));
				if (wendigoDist < minDistance) {
					minDistance = wendigoDist;
					nearestThreat = wendigo;
				}
			}
			// If threat is close enough (within 300 pixels), attack it
			if (nearestThreat && minDistance < 300) {
				self.isTargeted = true;
				// Move towards threat to stun it
				var dx = nearestThreat.x - self.x;
				var dy = nearestThreat.y - self.y;
				var distance = Math.sqrt(dx * dx + dy * dy);
				if (distance > 0) {
					self.x += dx / distance * 4; // Dog moves fast when attacking
					self.y += dy / distance * 4;
				}
				return;
			}
		}
		// Normal movement when not attacking
		if (!self.isTargeted) {
			// Gentle movement animation
			self.y += Math.sin(LK.ticks * 0.1 + self.x * 0.01) * 0.3;
			if (LK.ticks % 200 === 0) {
				var newX = Math.random() * (1800 - 200) + 200;
				var newY = Math.random() * (2400 - 200) + 200;
				tween(self, {
					x: newX,
					y: newY
				}, {
					duration: 3000,
					easing: tween.easeInOut
				});
			}
		}
	};
	self.enterCabin = function () {
		self.inCabin = true;
		tween(self, {
			x: cabin.x,
			y: cabin.y,
			alpha: 0.3
		}, {
			duration: 1000
		});
	};
	self.exitCabin = function () {
		self.inCabin = false;
		var newX = Math.random() * (1800 - 200) + 200;
		var newY = Math.random() * (2400 - 200) + 200;
		tween(self, {
			x: newX,
			y: newY,
			alpha: 1
		}, {
			duration: 1000
		});
	};
	self.freeze = function () {
		self.frozen = true;
		npcGraphics.tint = 0x4444ff;
	};
	self.takeDamage = function () {
		self.hitPoints--;
		if (self.hitPoints <= 0) {
			return true; // NPC is killed
		} else {
			// Flash red to show damage
			tween(npcGraphics, {
				tint: 0xFF0000
			}, {
				duration: 200,
				onFinish: function onFinish() {
					tween(npcGraphics, {
						tint: 0xFFFFFF
					}, {
						duration: 200
					});
				}
			});
			return false;
		}
	};
	self.stunThreat = function (threat) {
		if (threat === wendigo) {
			threat.stunned = true;
			threat.stunnedUntil = LK.ticks + 180; // 3 seconds at 60fps
		} else {
			threat.stunned = true;
			threat.stunnedUntil = LK.ticks + 300; // 5 seconds at 60fps
		}
		// Make threat flash blue to show it's stunned
		tween(threat.children[0], {
			tint: 0x4444FF
		}, {
			duration: 300
		});
		// Dog retreats after stunning
		self.isTargeted = true;
		var retreatX = Math.random() * (1800 - 200) + 200;
		var retreatY = Math.random() * (2400 - 200) + 200;
		tween(self, {
			x: retreatX,
			y: retreatY
		}, {
			duration: 1000,
			onFinish: function onFinish() {
				self.isTargeted = false;
			}
		});
	};
	return self;
});
var NormalBerry = Container.expand(function () {
	var self = Container.call(this);
	var berryGraphics = self.attachAsset('normalBerry', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	self.update = function () {
		// Gentle floating animation
		self.y += Math.sin(LK.ticks * 0.1 + self.x * 0.01) * 0.5;
	};
	return self;
});
var Wendigo = Container.expand(function () {
	var self = Container.call(this);
	// Create a scary looking wendigo using a dark red box shape
	var wendigoGraphics = self.attachAsset('wendigoBody', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	self.speed = 3;
	self.lastFoxX = 0;
	self.lastFoxY = 0;
	self.update = function () {
		if (!isBloodMoon) return;
		if (self.stunned && LK.ticks < self.stunnedUntil) {
			// Wendigo is stunned, can't move
			return;
		} else if (self.stunned) {
			// Stun expired, remove stun
			self.stunned = false;
			tween(wendigoGraphics, {
				tint: 0xFFFFFF
			}, {
				duration: 300
			});
		}
		// Check for dog collision for stunning
		for (var d = 0; d < npcs.length; d++) {
			if (npcs[d].type === 'dog' && npcs[d].isTargeted && self.intersects(npcs[d])) {
				npcs[d].stunThreat(self);
				break;
			}
		}
		// Calculate survival time and increase speed accordingly
		var survivalTime = (LK.ticks - bloodMoonStartTime) / 60; // Convert to seconds
		var currentSpeed = self.speed + survivalTime * wendigoSpeedIncreaseRate;
		// Target frozen NPC first, then fox
		var target = null;
		for (var i = 0; i < npcs.length; i++) {
			if (npcs[i].frozen && !npcs[i].killed) {
				target = npcs[i];
				break;
			}
		}
		if (!target) {
			target = fox;
		}
		if (!target) return;
		// Move towards target
		var dx = target.x - self.x;
		var dy = target.y - self.y;
		var distance = Math.sqrt(dx * dx + dy * dy);
		if (distance > 0) {
			// Normalize direction and apply increasing speed
			self.x += dx / distance * currentSpeed;
			self.y += dy / distance * currentSpeed;
		}
		// Check if wendigo caught frozen NPC
		for (var i = 0; i < npcs.length; i++) {
			var npc = npcs[i];
			if (npc.frozen && !npc.killed && self.intersects(npc)) {
				// Attack the NPC (dogs take 2 hits, others die in 1)
				var isKilled = npc.takeDamage();
				if (isKilled) {
					npc.killed = true;
					// Make NPC disappear with death effect
					tween(npc, {
						alpha: 0,
						scaleX: 0,
						scaleY: 0
					}, {
						duration: 500,
						onFinish: function onFinish() {
							npc.destroy();
							npcs.splice(npcs.indexOf(npc), 1);
						}
					});
				}
				// Play kill sound
				LK.getSound('wendigoGrowl').play();
				break;
			}
		}
		// Check if wendigo caught the fox
		if (self.intersects(fox)) {
			// Fox is caught - create jumpscare effect
			LK.effects.flashScreen(0xffffff, 500);
			// Scale wendigo up for jumpscare
			tween(wendigo, {
				scaleX: 3,
				scaleY: 3
			}, {
				duration: 200
			});
			// Play jumpscare sound
			LK.getSound('wendigoGrowl').play();
			// Show scary game over after jumpscare
			LK.setTimeout(function () {
				LK.showGameOver();
			}, 1000);
			return;
		}
		// Add scary breathing/pulsing effect
		wendigoGraphics.scaleX = 1 + Math.sin(LK.ticks * 0.2) * 0.1;
		wendigoGraphics.scaleY = 1 + Math.cos(LK.ticks * 0.2) * 0.1;
	};
	return self;
});
var Wolf = Container.expand(function () {
	var self = Container.call(this);
	var wolfGraphics = self.attachAsset('wolf', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	self.speed = 2;
	self.update = function () {
		if (!isNight) return;
		if (self.stunned && LK.ticks < self.stunnedUntil) {
			// Wolf is stunned, can't move
			return;
		} else if (self.stunned) {
			// Stun expired, remove stun
			self.stunned = false;
			tween(wolfGraphics, {
				tint: 0xFFFFFF
			}, {
				duration: 300
			});
		}
		// Check for dog collision for stunning
		for (var d = 0; d < npcs.length; d++) {
			if (npcs[d].type === 'dog' && npcs[d].isTargeted && self.intersects(npcs[d])) {
				npcs[d].stunThreat(self);
				break;
			}
		}
		// Chase fox during night
		var dx = fox.x - self.x;
		var dy = fox.y - self.y;
		var distance = Math.sqrt(dx * dx + dy * dy);
		if (distance > 0) {
			self.x += dx / distance * self.speed;
			self.y += dy / distance * self.speed;
		}
		// Check if wolf caught the fox for jumpscare
		if (self.intersects(fox)) {
			// Wolf jumpscare effect
			LK.effects.flashScreen(0xffffff, 300);
			// Scale wolf up for jumpscare
			tween(self, {
				scaleX: 2.5,
				scaleY: 2.5
			}, {
				duration: 150
			});
			// Play wolf roar sound
			LK.getSound('wolfRoar').play();
			// Show game over after jumpscare
			LK.setTimeout(function () {
				LK.showGameOver();
			}, 800);
			return;
		}
		// Add prowling animation
		wolfGraphics.scaleX = 1 + Math.sin(LK.ticks * 0.1) * 0.1;
	};
	return self;
});

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

/**** 
* Game Code
****/ 
// Game state variables
var fox;
var normalBerries = [];
var wolves = [];
var npcs = [];
var dragNode = null;
var berrySpawnTimer = 0;
var wendigo;
var wendigoSpeedIncreaseRate = 0.02;
var bunny;
var cabin;
// Day/Night cycle variables
var isNight = false;
var isBloodMoon = false;
var nightCount = 0;
var berriesCollectedInCycle = 0;
var scoreMultiplier = 1;
var bloodMoonStartTime = 0;
var bloodMoonCount = 0;
var dayLengthMultiplier = 1;
// NPC types organized by rarity
var commonNPCs = ['cat', 'bunny', 'squirrel'];
var uncommonNPCs = ['deer', 'fennec'];
var rareNPCs = ['dog', 'mouse'];
// Add forest background
var background = game.attachAsset('forestBackground', {
	x: 0,
	y: 0
});
// Create score display
var scoreTxt = new Text2('Score: 0 (x1)', {
	size: 80,
	fill: 0xFFFFFF
});
scoreTxt.anchor.set(0.5, 0);
LK.gui.top.addChild(scoreTxt);
// Create day/night indicator
var dayNightTxt = new Text2('Day', {
	size: 60,
	fill: 0xFFFF00
});
dayNightTxt.anchor.set(0.5, 0);
dayNightTxt.y = 100;
LK.gui.top.addChild(dayNightTxt);
// Add cabin for NPCs
cabin = game.attachAsset('cabin', {
	anchorX: 0.5,
	anchorY: 0.5,
	x: 1650,
	y: 450
});
// Spawn bunny
bunny = game.addChild(new Bunny());
bunny.x = 200;
bunny.y = 200;
// Initialize fox
fox = game.addChild(new Fox());
fox.x = 1024;
fox.y = 1366;
// Spawn normal berry function
function spawnNormalBerry() {
	var berry = new NormalBerry();
	berry.x = Math.random() * (2048 - 120) + 60;
	berry.y = Math.random() * (2732 - 120) + 60;
	normalBerries.push(berry);
	game.addChild(berry);
}
// Spawn wolf function
function spawnWolf() {
	var wolf = new Wolf();
	wolf.x = Math.random() * (2048 - 120) + 60;
	wolf.y = Math.random() * (2732 - 120) + 60;
	wolves.push(wolf);
	game.addChild(wolf);
}
// Spawn NPC function
function spawnNPC() {
	// Determine rarity first
	var rarity;
	var selectedType;
	var rarityRand = Math.random();
	if (rarityRand <= 0.5) {
		rarity = 'common';
		selectedType = commonNPCs[Math.floor(Math.random() * commonNPCs.length)];
	} else if (rarityRand <= 0.85) {
		rarity = 'uncommon';
		selectedType = uncommonNPCs[Math.floor(Math.random() * uncommonNPCs.length)];
	} else {
		rarity = 'rare';
		selectedType = rareNPCs[Math.floor(Math.random() * rareNPCs.length)];
	}
	var npc = new NPC(selectedType);
	npc.rarity = rarity;
	npc.setRarityVisual(); // Apply visual indication based on rarity
	npc.x = Math.random() * (1800 - 200) + 200;
	npc.y = Math.random() * (2400 - 200) + 200;
	npcs.push(npc);
	game.addChild(npc);
}
// Transition to night
function startNight() {
	isNight = true;
	nightCount++;
	berriesCollectedInCycle = 0;
	// Check for blood moon (randomized timing after day 3, but can appear later)
	var shouldBeBloodMoon = false;
	if (nightCount >= 3) {
		// After day 3, blood moon can appear with increasing chance
		var bloodMoonChance = Math.min(0.4, (nightCount - 2) * 0.1);
		shouldBeBloodMoon = Math.random() < bloodMoonChance;
	}
	if (shouldBeBloodMoon) {
		bloodMoonCount++;
		// Double the day length multiplier after each blood moon
		dayLengthMultiplier *= 2;
		isBloodMoon = true;
		bloodMoonStartTime = LK.ticks;
		// Reset multiplier during blood moon
		scoreMultiplier = 1;
		updateScoreDisplay();
		// Freeze one random NPC
		if (npcs.length > 0) {
			var randomNPC = npcs[Math.floor(Math.random() * npcs.length)];
			randomNPC.freeze();
		}
		// Move other NPCs to cabin
		for (var i = 0; i < npcs.length; i++) {
			if (!npcs[i].frozen) {
				npcs[i].enterCabin();
			}
		}
		// Spawn wendigo
		wendigo = new Wendigo();
		wendigo.x = -100;
		wendigo.y = Math.random() * 2000 + 300;
		game.addChild(wendigo);
		// Change background to blood red
		game.setBackgroundColor(0x330000);
		tween(background, {
			tint: 0x660000,
			alpha: 0.8
		}, {
			duration: 1500
		});
		dayNightTxt.setText('Blood Moon');
		dayNightTxt.fill = 0xFF0000;
	} else {
		// Regular night
		// Spawn wolves
		spawnWolf();
		spawnWolf();
		if (Math.random() < 0.5) spawnWolf();
		// Move NPCs to cabin
		for (var i = 0; i < npcs.length; i++) {
			npcs[i].enterCabin();
		}
		// Change background to dark blue night
		game.setBackgroundColor(0x001122);
		tween(background, {
			tint: 0x223355,
			alpha: 0.7
		}, {
			duration: 1500
		});
		dayNightTxt.setText('Night');
		dayNightTxt.fill = 0x6666FF;
	}
}
// Transition to day
function startDay() {
	isNight = false;
	isBloodMoon = false;
	berriesCollectedInCycle = 0;
	// Remove wolves
	for (var i = 0; i < wolves.length; i++) {
		wolves[i].destroy();
	}
	wolves = [];
	// Remove wendigo if exists
	if (wendigo) {
		wendigo.destroy();
		wendigo = null;
	}
	// Bring NPCs out of cabin
	for (var i = 0; i < npcs.length; i++) {
		if (!npcs[i].killed) {
			npcs[i].exitCabin();
		}
	}
	// Spawn new NPC with chance
	if (Math.random() < 0.7) {
		spawnNPC();
	}
	// Change background back to day
	game.setBackgroundColor(0x228b22);
	tween(background, {
		tint: 0xFFFFFF,
		alpha: 1
	}, {
		duration: 1500
	});
	dayNightTxt.setText('Day');
	dayNightTxt.fill = 0xFFFF00;
}
// Update score display with multiplier
function updateScoreDisplay() {
	scoreTxt.setText('Score: ' + LK.getScore() + ' (x' + scoreMultiplier + ')');
}
// Keyboard state tracking
var keys = {
	left: false,
	right: false,
	up: false,
	down: false
};
// Handle mouse/touch move
function handleMove(x, y, obj) {
	if (dragNode) {
		dragNode.x = x;
		dragNode.y = y;
		// Keep fox within bounds
		if (dragNode.x < 60) dragNode.x = 60;
		if (dragNode.x > 1988) dragNode.x = 1988;
		if (dragNode.y < 60) dragNode.y = 60;
		if (dragNode.y > 2672) dragNode.y = 2672;
	}
}
// Mouse/touch events
game.move = handleMove;
game.down = function (x, y, obj) {
	dragNode = fox;
	handleMove(x, y, obj);
};
game.up = function (x, y, obj) {
	dragNode = null;
};
// Initial berry spawning
spawnNormalBerry();
spawnNormalBerry();
spawnNormalBerry();
// Main game update loop
game.update = function () {
	// Spawn berries over time with random intervals between 1.5-5 seconds
	berrySpawnTimer++;
	var randomSpawnTime = Math.random() * (300 - 90) + 90; // 90-300 ticks (1.5-5 seconds)
	if (berrySpawnTimer >= randomSpawnTime) {
		spawnNormalBerry();
		berrySpawnTimer = 0;
	}
	// Check collisions with normal berries
	for (var i = normalBerries.length - 1; i >= 0; i--) {
		var berry = normalBerries[i];
		if (fox.intersects(berry)) {
			// Collect berry and increase score with multiplier
			var scoreGain = 1 * scoreMultiplier;
			LK.setScore(LK.getScore() + scoreGain);
			berriesCollectedInCycle++;
			updateScoreDisplay();
			LK.getSound('berryCollect').play();
			// Remove berry from array first, then destroy
			normalBerries.splice(i, 1);
			berry.destroy();
			// Check for day/night transitions
			var dayRequirement = 10 * dayLengthMultiplier;
			var nightRequirement = isBloodMoon ? dayRequirement : 5;
			if (!isNight && berriesCollectedInCycle >= dayRequirement) {
				startNight();
			} else if (isNight && berriesCollectedInCycle >= nightRequirement) {
				startDay();
			}
		}
	}
	// Check collisions with NPCs for score multiplier
	for (var i = 0; i < npcs.length; i++) {
		var npc = npcs[i];
		if (!npc.inCabin && !npc.frozen && fox.intersects(npc)) {
			// Update multiplier but cap at 4x
			if (scoreMultiplier < 4) {
				scoreMultiplier = Math.min(4, scoreMultiplier + (npc.multiplier === 3 ? 1 : npc.multiplier === 2 ? 0.5 : 0));
				if (npc.multiplier === 3) scoreMultiplier = Math.min(4, scoreMultiplier + 1); // Mouse gives +1 extra
				updateScoreDisplay();
			}
			// Give visual feedback
			tween(npc, {
				scaleX: 1.5,
				scaleY: 1.5
			}, {
				duration: 200,
				onFinish: function onFinish() {
					tween(npc, {
						scaleX: 1,
						scaleY: 1
					}, {
						duration: 200
					});
				}
			});
		}
	}
	// Wolf collision is now handled in Wolf class update method
};

===================================================================
--- original.js
+++ change.js
@@ -406,11 +406,12 @@
 var scoreMultiplier = 1;
 var bloodMoonStartTime = 0;
 var bloodMoonCount = 0;
 var dayLengthMultiplier = 1;
-// NPC spawn chances (mouse is rarest)
-var npcTypes = ['bunny', 'deer', 'dog', 'cat', 'mouse'];
-var npcSpawnChances = [0.3, 0.25, 0.25, 0.15, 0.05];
+// NPC types organized by rarity
+var commonNPCs = ['cat', 'bunny', 'squirrel'];
+var uncommonNPCs = ['deer', 'fennec'];
+var rareNPCs = ['dog', 'mouse'];
 // Add forest background
 var background = game.attachAsset('forestBackground', {
 	x: 0,
 	y: 0
@@ -462,27 +463,21 @@
 	game.addChild(wolf);
 }
 // Spawn NPC function
 function spawnNPC() {
-	var rand = Math.random();
-	var cumulativeChance = 0;
-	var selectedType = 'bunny';
-	for (var i = 0; i < npcTypes.length; i++) {
-		cumulativeChance += npcSpawnChances[i];
-		if (rand <= cumulativeChance) {
-			selectedType = npcTypes[i];
-			break;
-		}
-	}
-	// Determine rarity
+	// Determine rarity first
 	var rarity;
+	var selectedType;
 	var rarityRand = Math.random();
 	if (rarityRand <= 0.5) {
 		rarity = 'common';
+		selectedType = commonNPCs[Math.floor(Math.random() * commonNPCs.length)];
 	} else if (rarityRand <= 0.85) {
 		rarity = 'uncommon';
+		selectedType = uncommonNPCs[Math.floor(Math.random() * uncommonNPCs.length)];
 	} else {
 		rarity = 'rare';
+		selectedType = rareNPCs[Math.floor(Math.random() * rareNPCs.length)];
 	}
 	var npc = new NPC(selectedType);
 	npc.rarity = rarity;
 	npc.setRarityVisual(); // Apply visual indication based on rarity