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

/**** 
* Classes
****/ 
var FireParticle = Container.expand(function () {
	var self = Container.call(this);
	// Create particle graphics based on type
	var graphics;
	self.particleType = 'fire'; // default type
	self.setType = function (type) {
		if (self.graphics) {
			self.removeChild(self.graphics);
		}
		self.particleType = type;
		if (type === 'fire') {
			self.graphics = self.attachAsset('fireParticle', {
				anchorX: 0.5,
				anchorY: 0.5
			});
		} else if (type === 'core') {
			self.graphics = self.attachAsset('fireCore', {
				anchorX: 0.5,
				anchorY: 0.5
			});
		} else if (type === 'smoke') {
			self.graphics = self.attachAsset('smoke', {
				anchorX: 0.5,
				anchorY: 0.5
			});
		}
	};
	// Initialize with default type
	self.setType('fire');
	// Particle properties
	self.velocityX = 0;
	self.velocityY = 0;
	self.life = 1.0;
	self.maxLife = 1.0;
	self.update = function () {
		// Move particle
		self.x += self.velocityX;
		self.y += self.velocityY;
		// Reduce life
		self.life -= 0.02;
		// Update appearance based on life
		if (self.graphics) {
			self.graphics.alpha = Math.max(0, self.life);
			self.graphics.scaleX = self.life;
			self.graphics.scaleY = self.life;
		}
		// Add some randomness to movement
		self.velocityX += (Math.random() - 0.5) * 0.5;
		self.velocityY += (Math.random() - 0.5) * 0.3;
		// Gravity effect for smoke
		if (self.particleType === 'smoke') {
			self.velocityY -= 0.1;
		}
	};
	return self;
});

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

/**** 
* Game Code
****/ 
// Add background image fullscreen
var background = game.attachAsset('background1', {
	x: 0,
	y: 0,
	width: 2048,
	height: 2732
});
// Fire animation system
var fireParticles = [];
var fireBaseX = 1024; // Center of screen
var fireBaseY = 1800; // Center of screen vertically
var baseFireScale = 0.2; // Base scale factor for fire size (20x20)
var fireScale = baseFireScale; // Current fire scale (will increase with burning wood)
var burningWoodCount = 0; // Track number of burning wood pieces
var lastWoodPlacedTime = LK.ticks; // Track when wood was last placed on fire
var fireReductionTimer = 10 * 60; // 10 seconds at 60fps
var gameStartTime = LK.ticks; // Track when game started
var initialFireReductionStarted = true; // Track if initial reduction has started
var fireGrowthTimer = null; // Timer for automatic fire growth
var maxFireScale = 5.0; // Maximum fire scale (500x500 pixels)
// Play fire sound repeatedly
var fireSoundTimer = LK.setInterval(function () {
	LK.getSound('Firesound').play();
}, 2000); // Play every 2 seconds
// Start automatic fire growth timer to increase fire size over time
fireGrowthTimer = LK.setInterval(function () {
	// Only grow if fire hasn't reached maximum size
	if (fireScale < maxFireScale) {
		var growthAmount = 30.0 / 100.0; // Increase by 30 pixels worth of scale
		fireScale += growthAmount;
		// Cap at maximum size
		if (fireScale > maxFireScale) {
			fireScale = maxFireScale;
			// Stop the growth timer when max size is reached
			LK.clearInterval(fireGrowthTimer);
			fireGrowthTimer = null;
			// Vanish fire when it reaches 500x500 pixels
			var fireScaleObj = {
				value: fireScale
			};
			tween(fireScaleObj, {
				value: 0
			}, {
				duration: 2000,
				easing: tween.linear,
				onFinish: function onFinish() {
					// Create dark overlay for screen fade
					var darkOverlay = LK.getAsset('smoke', {
						anchorX: 0,
						anchorY: 0,
						scaleX: 20.48,
						scaleY: 27.32,
						alpha: 0,
						x: 0,
						y: 0
					});
					darkOverlay.tint = 0x000000;
					game.addChild(darkOverlay);
					// Fade screen to black then show game over
					tween(darkOverlay, {
						alpha: 1
					}, {
						duration: 1500,
						easing: tween.easeIn,
						onFinish: function onFinish() {
							LK.showGameOver();
						}
					});
				}
			});
			game.fireScaleObj = fireScaleObj;
		}
	}
}, 1000); // Grow every 1 second
// Create fire particles continuously
var fireTimer = LK.setInterval(function () {
	// Create main fire particles
	for (var i = 0; i < 8; i++) {
		var particle = new FireParticle();
		// Use different fire color assets randomly
		var fireTypes = ['fireParticle', 'fireOrange', 'fireLightOrange', 'fireGold', 'fireBlue', 'fireGreen', 'fireMagenta', 'fireCyan', 'firePurple'];
		var randomFireType = fireTypes[Math.floor(Math.random() * fireTypes.length)];
		if (particle.graphics) {
			particle.removeChild(particle.graphics);
		}
		particle.graphics = particle.attachAsset(randomFireType, {
			anchorX: 0.5,
			anchorY: 0.5
		});
		particle.x = fireBaseX + (Math.random() - 0.5) * 400 * fireScale;
		particle.y = fireBaseY + (Math.random() - 0.5) * 160 * fireScale;
		particle.velocityX = (Math.random() - 0.5) * 8;
		particle.velocityY = -Math.random() * 20 - 8;
		particle.life = 1.0;
		particle.maxLife = 1.0;
		// Scale animation - much bigger particles
		particle.graphics.scaleX = 2.0 + Math.random() * 2.0;
		particle.graphics.scaleY = 2.0 + Math.random() * 2.0;
		tween(particle.graphics, {
			scaleX: particle.graphics.scaleX * 3.0,
			scaleY: particle.graphics.scaleY * 3.0
		}, {
			duration: 500 + Math.random() * 500,
			easing: tween.easeOut
		});
		fireParticles.push(particle);
		game.addChild(particle);
	}
	// Create core fire particles (yellow/white)
	for (var j = 0; j < 5; j++) {
		var coreParticle = new FireParticle();
		// Use core fire assets randomly
		var coreTypes = ['fireCore', 'fireYellowWhite', 'whiteParticle'];
		var randomCoreType = coreTypes[Math.floor(Math.random() * coreTypes.length)];
		if (coreParticle.graphics) {
			coreParticle.removeChild(coreParticle.graphics);
		}
		coreParticle.graphics = coreParticle.attachAsset(randomCoreType, {
			anchorX: 0.5,
			anchorY: 0.5
		});
		coreParticle.x = fireBaseX + (Math.random() - 0.5) * 250 * fireScale;
		coreParticle.y = fireBaseY + (Math.random() - 0.5) * 120 * fireScale;
		coreParticle.velocityX = (Math.random() - 0.5) * 6;
		coreParticle.velocityY = -Math.random() * 18 - 10;
		coreParticle.life = 1.0;
		coreParticle.maxLife = 1.0;
		// Much bigger core particles
		coreParticle.graphics.scaleX = 2.5;
		coreParticle.graphics.scaleY = 2.5;
		fireParticles.push(coreParticle);
		game.addChild(coreParticle);
	}
	// Create bright white hot center particles
	for (var k = 0; k < 3; k++) {
		var whiteParticle = new FireParticle();
		if (whiteParticle.graphics) {
			whiteParticle.removeChild(whiteParticle.graphics);
		}
		whiteParticle.graphics = whiteParticle.attachAsset('whiteParticle', {
			anchorX: 0.5,
			anchorY: 0.5
		});
		whiteParticle.x = fireBaseX + (Math.random() - 0.5) * 150 * fireScale;
		whiteParticle.y = fireBaseY + (Math.random() - 0.5) * 80 * fireScale;
		whiteParticle.velocityX = (Math.random() - 0.5) * 4;
		whiteParticle.velocityY = -Math.random() * 15 - 8;
		whiteParticle.life = 1.0;
		whiteParticle.maxLife = 1.0;
		// Intense white hot center particles
		whiteParticle.graphics.scaleX = 1.8;
		whiteParticle.graphics.scaleY = 1.8;
		// Add white glow effect with tween
		tween(whiteParticle.graphics, {
			scaleX: whiteParticle.graphics.scaleX * 2.5,
			scaleY: whiteParticle.graphics.scaleY * 2.5
		}, {
			duration: 400 + Math.random() * 300,
			easing: tween.easeOut
		});
		fireParticles.push(whiteParticle);
		game.addChild(whiteParticle);
	}
	// Create white base particles at the bottom of the fire
	for (var m = 0; m < 6; m++) {
		var whiteBaseParticle = new FireParticle();
		if (whiteBaseParticle.graphics) {
			whiteBaseParticle.removeChild(whiteBaseParticle.graphics);
		}
		whiteBaseParticle.graphics = whiteBaseParticle.attachAsset('whiteParticle', {
			anchorX: 0.5,
			anchorY: 0.5
		});
		whiteBaseParticle.x = fireBaseX + (Math.random() - 0.5) * 200 * fireScale;
		whiteBaseParticle.y = fireBaseY + 150 * fireScale + (Math.random() - 0.5) * 100 * fireScale;
		whiteBaseParticle.velocityX = (Math.random() - 0.5) * 3;
		whiteBaseParticle.velocityY = -Math.random() * 5 - 2;
		whiteBaseParticle.life = 1.0;
		whiteBaseParticle.maxLife = 1.0;
		// Base white particles same size as other fire particles
		whiteBaseParticle.graphics.scaleX = 2.0 + Math.random() * 1.0;
		whiteBaseParticle.graphics.scaleY = 2.0 + Math.random() * 1.0;
		// Add gentle scaling animation
		tween(whiteBaseParticle.graphics, {
			scaleX: whiteBaseParticle.graphics.scaleX * 2.0,
			scaleY: whiteBaseParticle.graphics.scaleY * 2.0
		}, {
			duration: 600 + Math.random() * 400,
			easing: tween.easeOut
		});
		fireParticles.push(whiteBaseParticle);
		game.addChild(whiteBaseParticle);
		// Move white base particles to back (behind fire)
		game.setChildIndex(whiteBaseParticle, 1);
	}
	// Create smoke particles (black/dark)
	if (Math.random() < 0.5) {
		var smokeParticle = new FireParticle();
		// Use different smoke color assets randomly
		var smokeTypes = ['smoke', 'smokeGray', 'smokeLightGray', 'smokePurple', 'smokeTeal', 'smokeYellow'];
		var randomSmokeType = smokeTypes[Math.floor(Math.random() * smokeTypes.length)];
		if (smokeParticle.graphics) {
			smokeParticle.removeChild(smokeParticle.graphics);
		}
		smokeParticle.graphics = smokeParticle.attachAsset(randomSmokeType, {
			anchorX: 0.5,
			anchorY: 0.5
		});
		smokeParticle.x = fireBaseX + (Math.random() - 0.5) * 320 * fireScale;
		smokeParticle.y = fireBaseY - 300 * fireScale - Math.random() * 200 * fireScale;
		smokeParticle.velocityX = (Math.random() - 0.5) * 10;
		smokeParticle.velocityY = -Math.random() * 10 - 4;
		smokeParticle.life = 1.0;
		smokeParticle.maxLife = 1.0;
		// Smoke grows as it rises - much bigger smoke
		tween(smokeParticle.graphics, {
			scaleX: 5,
			scaleY: 5
		}, {
			duration: 2000,
			easing: tween.easeOut
		});
		fireParticles.push(smokeParticle);
		game.addChild(smokeParticle);
	}
}, 80);
// Update fire system
game.update = function () {
	// Count burning wood pieces and update fire scale
	burningWoodCount = 0;
	for (var w = 0; w < woodPieces.length; w++) {
		if (woodPieces[w].isBurning) {
			burningWoodCount++;
		}
	}
	// Start fire reduction only after no wood has been placed for a while AND fire has stopped growing
	var timeSinceLastWood = LK.ticks - lastWoodPlacedTime;
	var delayBeforeReduction = 5 * 60; // 5 seconds delay before starting reduction
	var fireFinishedGrowing = fireScale >= maxFireScale || fireGrowthTimer === null;
	if (!initialFireReductionStarted && timeSinceLastWood >= delayBeforeReduction && burningWoodCount === 0 && fireFinishedGrowing) {
		// Create a dummy object to tween the fireScale value
		var fireScaleObj = {
			value: fireScale
		};
		// Begin fire reduction after delay using tween - first phase to 5x5 size
		var minSize = 5.0 / 100.0; // 5x5 pixels out of 100 pixel base asset
		tween(fireScaleObj, {
			value: minSize
		}, {
			duration: 8000,
			// 8 seconds to reach minimum size
			easing: tween.linear,
			onFinish: function onFinish() {
				// Start second phase: reduce from 5x5 to 0x0
				tween(fireScaleObj, {
					value: 0
				}, {
					duration: 2000,
					// 2 seconds to reach 0
					easing: tween.linear,
					onFinish: function onFinish() {
						// Create dark overlay for screen fade
						var darkOverlay = LK.getAsset('smoke', {
							anchorX: 0,
							anchorY: 0,
							scaleX: 20.48,
							scaleY: 27.32,
							alpha: 0,
							x: 0,
							y: 0
						});
						darkOverlay.tint = 0x000000;
						game.addChild(darkOverlay);
						// Fade screen to black then show game over
						tween(darkOverlay, {
							alpha: 1
						}, {
							duration: 1500,
							easing: tween.easeIn,
							onFinish: function onFinish() {
								LK.showGameOver();
							}
						});
					}
				});
			}
		});
		// Store reference to update fireScale each frame
		game.fireScaleObj = fireScaleObj;
		initialFireReductionStarted = true;
	}
	// Update fire scale from tween if active
	if (game.fireScaleObj) {
		fireScale = game.fireScaleObj.value;
	}
	// Add scale increase from burning wood
	var scaleIncrease = burningWoodCount * (30.0 / 100.0); // 30 pixels out of 100 pixel base asset
	fireScale = Math.max(0, fireScale + scaleIncrease);
	// Fire continues burning even at 400x400 pixels - no cleanup needed
	// Update and clean up particles
	for (var i = fireParticles.length - 1; i >= 0; i--) {
		var particle = fireParticles[i];
		// Remove dead particles
		if (particle.life <= 0) {
			particle.destroy();
			fireParticles.splice(i, 1);
			continue;
		}
	}
	// Update wood burning particles - wood now burns indefinitely
	for (var w = woodPieces.length - 1; w >= 0; w--) {
		var wood = woodPieces[w];
		if (wood.isBurning) {
			// Clean up dead burn particles
			for (var b = wood.burnParticles.length - 1; b >= 0; b--) {
				var burnParticle = wood.burnParticles[b];
				if (burnParticle.life <= 0) {
					wood.burnParticles.splice(b, 1);
				}
			}
		}
	}
	// Add flickering effect to the fire base
	if (LK.ticks % 10 === 0) {
		fireBaseX = 1024 + (Math.random() - 0.5) * 120 * fireScale;
	}
};
// Array to track wood pieces
var woodPieces = [];
var draggedWood = null; // Track currently dragged wood
var woodButton = game.attachAsset('woodButton', {
	x: 2048 - 100 - 100,
	y: 2732 - 100 - 50,
	// Adjusted Y to account for button height
	anchorX: 0.5,
	anchorY: 0.5
});
// Ensure wood button is visible on top of background
game.setChildIndex(woodButton, game.children.length - 1);
// Wood button click handler
woodButton.down = function (x, y, obj) {
	// Create new wood piece at button position
	var newWood = game.attachAsset('Wood', {
		x: woodButton.x,
		y: woodButton.y,
		anchorX: 0.5,
		anchorY: 0.5
	});
	// Add wood piece properties
	newWood.isBurning = false;
	newWood.burnParticles = [];
	newWood.isDragging = true; // Mark as dragging
	woodPieces.push(newWood);
	// Ensure wood piece is visible on top of background
	game.setChildIndex(newWood, game.children.length - 1);
	// Set as active dragged wood
	draggedWood = newWood;
};
// Game move handler for dragging wood
game.move = function (x, y, obj) {
	if (draggedWood) {
		draggedWood.x = x;
		draggedWood.y = y;
	}
};
// Game touch handler to start dragging existing wood pieces
game.down = function (x, y, obj) {
	// Check if touch is on any existing wood piece
	for (var i = 0; i < woodPieces.length; i++) {
		var wood = woodPieces[i];
		// Check if touch is within wood bounds
		var woodLeft = wood.x - wood.width / 2;
		var woodRight = wood.x + wood.width / 2;
		var woodTop = wood.y - wood.height / 2;
		var woodBottom = wood.y + wood.height / 2;
		if (x >= woodLeft && x <= woodRight && y >= woodTop && y <= woodBottom) {
			// Set this wood as the dragged piece
			draggedWood = wood;
			wood.isDragging = true;
			// Stop current burning if it was burning
			if (wood.isBurning && wood.fireTimer) {
				LK.clearInterval(wood.fireTimer);
				wood.fireTimer = null;
				// Clean up current burn particles
				for (var b = wood.burnParticles.length - 1; b >= 0; b--) {
					var burnParticle = wood.burnParticles[b];
					burnParticle.destroy();
					wood.burnParticles.splice(b, 1);
				}
			}
			// Reset burning state to allow re-placement
			wood.isBurning = false;
			wood.burnStartTime = null;
			break;
		}
	}
};
// Game up handler to stop dragging and check for fire placement
game.up = function (x, y, obj) {
	if (draggedWood) {
		// Check if wood is placed on fire area when released
		var fireDistance = Math.sqrt(Math.pow(draggedWood.x - fireBaseX, 2) + Math.pow(draggedWood.y - fireBaseY, 2));
		if (fireDistance < 200 * fireScale) {
			// Always allow placement on fire, regardless of previous burning state
			draggedWood.isBurning = true;
			lastWoodPlacedTime = LK.ticks; // Update last wood placement time
			// Stop and reset the fire reduction system when wood is placed
			if (initialFireReductionStarted && game.fireScaleObj) {
				tween.stop(game.fireScaleObj, {
					value: true
				});
				// Reset fire scale to a stable value while wood is burning
				game.fireScaleObj.value = Math.max(baseFireScale, game.fireScaleObj.value);
				// Reset the reduction system to allow it to restart after delay
				initialFireReductionStarted = false;
				game.fireScaleObj = null;
			}
			// Restart automatic fire growth if it was stopped and fire isn't at max size
			if (fireGrowthTimer === null && fireScale < maxFireScale) {
				fireGrowthTimer = LK.setInterval(function () {
					if (fireScale < maxFireScale) {
						var growthAmount = 30.0 / 100.0; // Increase by 30 pixels worth of scale
						fireScale += growthAmount;
						// Cap at maximum size
						if (fireScale > maxFireScale) {
							fireScale = maxFireScale;
							// Stop the growth timer when max size is reached
							LK.clearInterval(fireGrowthTimer);
							fireGrowthTimer = null;
						}
					}
				}, 1000); // Grow every 1 second
			}
			// Increase fire size when wood is placed - survival mechanic
			var fireGrowthAmount = 30.0 / 100.0; // Increase by 30 pixels worth of scale
			if (game.fireScaleObj) {
				game.fireScaleObj.value += fireGrowthAmount;
			} else {
				fireScale += fireGrowthAmount;
			}
			// Ensure fireScale is always updated regardless of tween state
			fireScale += fireGrowthAmount;
			// Check if fire has reached 500x500 and trigger vanish
			if (fireScale >= maxFireScale) {
				fireScale = maxFireScale;
				// Vanish fire when it reaches 500x500 pixels
				var fireScaleObj = {
					value: fireScale
				};
				tween(fireScaleObj, {
					value: 0
				}, {
					duration: 2000,
					easing: tween.linear,
					onFinish: function onFinish() {
						// Create dark overlay for screen fade
						var darkOverlay = LK.getAsset('smoke', {
							anchorX: 0,
							anchorY: 0,
							scaleX: 20.48,
							scaleY: 27.32,
							alpha: 0,
							x: 0,
							y: 0
						});
						darkOverlay.tint = 0x000000;
						game.addChild(darkOverlay);
						// Fade screen to black then show game over
						tween(darkOverlay, {
							alpha: 1
						}, {
							duration: 1500,
							easing: tween.easeIn,
							onFinish: function onFinish() {
								LK.showGameOver();
							}
						});
					}
				});
				game.fireScaleObj = fireScaleObj;
			}
			startWoodBurning(draggedWood, draggedWood.x, draggedWood.y);
		}
		draggedWood.isDragging = false;
		draggedWood = null;
	}
};
// Function to start wood burning at touch position
function startWoodBurning(wood, touchX, touchY) {
	// Wood now burns indefinitely - no destruction timer needed
	// Create fire particles on the touched side of the wood
	var fireTimer = LK.setInterval(function () {
		for (var j = 0; j < 3; j++) {
			var burnParticle = new FireParticle();
			// Use different fire color assets randomly for burning wood
			var fireTypes = ['fireParticle', 'fireOrange', 'fireLightOrange', 'fireGold', 'fireBlue', 'fireGreen', 'fireMagenta', 'fireCyan', 'firePurple'];
			var randomFireType = fireTypes[Math.floor(Math.random() * fireTypes.length)];
			if (burnParticle.graphics) {
				burnParticle.removeChild(burnParticle.graphics);
			}
			burnParticle.graphics = burnParticle.attachAsset(randomFireType, {
				anchorX: 0.5,
				anchorY: 0.5
			});
			burnParticle.x = touchX + (Math.random() - 0.5) * 60;
			burnParticle.y = touchY + (Math.random() - 0.5) * 30;
			burnParticle.velocityX = (Math.random() - 0.5) * 4;
			burnParticle.velocityY = -Math.random() * 8 - 2;
			burnParticle.life = 1.0;
			burnParticle.maxLife = 1.0;
			burnParticle.graphics.scaleX = 0.5 + Math.random() * 0.5;
			burnParticle.graphics.scaleY = 0.5 + Math.random() * 0.5;
			wood.burnParticles.push(burnParticle);
			fireParticles.push(burnParticle);
			game.addChild(burnParticle);
		}
	}, 200);
	wood.fireTimer = fireTimer;
}

===================================================================
--- original.js
+++ change.js
@@ -91,9 +91,9 @@
 var fireReductionTimer = 10 * 60; // 10 seconds at 60fps
 var gameStartTime = LK.ticks; // Track when game started
 var initialFireReductionStarted = true; // Track if initial reduction has started
 var fireGrowthTimer = null; // Timer for automatic fire growth
-var maxFireScale = 4.0; // Maximum fire scale (400x400 pixels)
+var maxFireScale = 5.0; // Maximum fire scale (500x500 pixels)
 // Play fire sound repeatedly
 var fireSoundTimer = LK.setInterval(function () {
 	LK.getSound('Firesound').play();
 }, 2000); // Play every 2 seconds
@@ -108,8 +108,43 @@
 			fireScale = maxFireScale;
 			// Stop the growth timer when max size is reached
 			LK.clearInterval(fireGrowthTimer);
 			fireGrowthTimer = null;
+			// Vanish fire when it reaches 500x500 pixels
+			var fireScaleObj = {
+				value: fireScale
+			};
+			tween(fireScaleObj, {
+				value: 0
+			}, {
+				duration: 2000,
+				easing: tween.linear,
+				onFinish: function onFinish() {
+					// Create dark overlay for screen fade
+					var darkOverlay = LK.getAsset('smoke', {
+						anchorX: 0,
+						anchorY: 0,
+						scaleX: 20.48,
+						scaleY: 27.32,
+						alpha: 0,
+						x: 0,
+						y: 0
+					});
+					darkOverlay.tint = 0x000000;
+					game.addChild(darkOverlay);
+					// Fade screen to black then show game over
+					tween(darkOverlay, {
+						alpha: 1
+					}, {
+						duration: 1500,
+						easing: tween.easeIn,
+						onFinish: function onFinish() {
+							LK.showGameOver();
+						}
+					});
+				}
+			});
+			game.fireScaleObj = fireScaleObj;
 		}
 	}
 }, 1000); // Grow every 1 second
 // Create fire particles continuously
@@ -479,8 +514,47 @@
 				fireScale += fireGrowthAmount;
 			}
 			// Ensure fireScale is always updated regardless of tween state
 			fireScale += fireGrowthAmount;
+			// Check if fire has reached 500x500 and trigger vanish
+			if (fireScale >= maxFireScale) {
+				fireScale = maxFireScale;
+				// Vanish fire when it reaches 500x500 pixels
+				var fireScaleObj = {
+					value: fireScale
+				};
+				tween(fireScaleObj, {
+					value: 0
+				}, {
+					duration: 2000,
+					easing: tween.linear,
+					onFinish: function onFinish() {
+						// Create dark overlay for screen fade
+						var darkOverlay = LK.getAsset('smoke', {
+							anchorX: 0,
+							anchorY: 0,
+							scaleX: 20.48,
+							scaleY: 27.32,
+							alpha: 0,
+							x: 0,
+							y: 0
+						});
+						darkOverlay.tint = 0x000000;
+						game.addChild(darkOverlay);
+						// Fade screen to black then show game over
+						tween(darkOverlay, {
+							alpha: 1
+						}, {
+							duration: 1500,
+							easing: tween.easeIn,
+							onFinish: function onFinish() {
+								LK.showGameOver();
+							}
+						});
+					}
+				});
+				game.fireScaleObj = fireScaleObj;
+			}
 			startWoodBurning(draggedWood, draggedWood.x, draggedWood.y);
 		}
 		draggedWood.isDragging = false;
 		draggedWood = null;