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

/**** 
* Classes
****/ 
var BlockManager = Container.expand(function () {
	var self = Container.call(this);
	var blockRows = [];
	var index = 0;
	for (var i = 0; i < ROW_COUNT; i++) {
		addRow({
			x: game.width / 2,
			y: LAVA_LINE - i * (BLOCK_SIZE * BLOCK_SCALE + BLOCK_MARGIN),
			index: index++
		});
	}
	blockRows[0].blocks[Math.floor(ROW_SPAN / 2)].onLit();
	self.popRow = popRow;
	function addRow(settings) {
		var prevRow = blockRows[blockRows.length - 1];
		var newRow = self.addChild(new BlockRow(settings));
		blockRows.push(newRow);
		if (prevRow) {
			newRow.setDown(prevRow);
			prevRow.setUp(newRow);
		}
	}
	function popRow() {
		blockRows.pop();
		blockRows[0].blocks.forEach(function (block) {
			if (block) {
				block.downBlock = undefined;
			}
		});
		addRow({
			y: blockRows[blockRows.length - 1].y - i * BLOCK_SIZE * BLOCK_SCALE,
			index: index++
		});
	}
	return self;
});
var ConfigContainer = Container.expand(function (config) {
	var self = Container.call(this);
	config = config || {};
	var destroyCalled = false;
	self.tags = {};
	self.x = config.x || 0;
	self.y = config.y || 0;
	self.rotation = config.rotation || 0;
	self.alpha = config.alpha !== undefined ? config.alpha : 1.0;
	if (config.scale !== undefined || config.scaleX !== undefined || config.scaleY !== undefined) {
		var scaleX = config.scaleX !== undefined ? config.scaleX : config.scale !== undefined ? config.scale : 1;
		var scaleY = config.scaleY !== undefined ? config.scaleY : config.scale !== undefined ? config.scale : 1;
		self.scale.set(scaleX, scaleY);
	}
	self.callDestroy = function () {
		if (!destroyCalled) {
			destroyCalled = true;
			self.onDestroy();
			self.destroy();
		}
	};
	self.onDestroy = function () {};
	return self;
});
var Light = ConfigContainer.expand(function (config) {
	var self = ConfigContainer.call(this, config);
	var lightShape = self.attachAsset('shapeEllipse', {
		y: -LIGHT_OFFSET,
		width: BLOCK_SIZE - 2 * LIGHT_OFFSET,
		height: BLOCK_SIZE - 2 * LIGHT_OFFSET,
		anchorX: 0.5,
		anchorY: 1,
		scaleX: 0,
		scaleY: 0
	});
	tween(lightShape, {
		scaleX: 1,
		scaleY: 1
	}, {
		duration: LIGHT_GROW_SPEED,
		onFinish: function onFinish() {
			if (self.parent) {
				config.callback();
			}
		}
	});
	return self;
});
var LavaSlice = ConfigContainer.expand(function (config) {
	var self = ConfigContainer.call(this, config);
	self.attachAsset('lava' + config.index, {
		anchorX: 0.5,
		anchorY: 0,
		width: LAVA_SLICE_WIDTH,
		tint: 0xFFA500
	});
	self.attachAsset('shapeBox', {
		width: LAVA_SLICE_WIDTH,
		height: 10,
		anchorX: 0.5,
		anchorY: 0,
		tint: 0xFF4D00
	});
	self.addChild(new Glow({
		anchorX: 0.5,
		anchorY: 0.75,
		height: 20,
		rangeY: 150,
		width: 3 * LAVA_SLICE_WIDTH,
		alpha: 0.35,
		tint: 0xFF4D00
	}));
	self.update = function () {
		self.y = Math.sin(LK.ticks * LAVA_BOB_PERIOD + config.index * LAVA_BOB_OFFSET) * LAVA_BOB_HEIGHT;
	};
	return self;
});
var Lava = ConfigContainer.expand(function (config) {
	var self = ConfigContainer.call(this, config);
	var position = Math.round((-0.5 - LAVA_SLICE_COUNT / 2) * LAVA_SLICE_WIDTH);
	for (var i = 1; i <= LAVA_SLICE_COUNT; i++) {
		var lavaSlice = self.addChild(new LavaSlice({
			x: position += LAVA_SLICE_WIDTH,
			index: i
		}));
	}
	return self;
});
var Glow = ConfigContainer.expand(function (config) {
	var self = ConfigContainer.call(this, config);
	var layers = Math.max(2, config.layers || 10);
	var layerAlpha = 1 / layers;
	var widthStep = (config.rangeX || 0) * layerAlpha;
	var heightStep = (config.rangeY || 0) * layerAlpha;
	for (var i = 0; i < layers; i++) {
		self.attachAsset(config.asset || 'shapeBox', {
			width: config.width + widthStep * i,
			height: config.height + heightStep * i,
			anchorX: config.anchorX,
			anchorY: config.anchorY,
			tint: config.tint,
			alpha: i === 0 && config.solid ? 1 : layerAlpha
		});
	}
	return self;
});
var BlockRow = ConfigContainer.expand(function (config) {
	var self = ConfigContainer.call(this, config);
	var blockClasses = generateBlockClasses(config.index);
	self.blocks = [];
	for (var i = 0; i < ROW_SPAN; i++) {
		var blockClass = blockClasses[i];
		self.blocks[i] = self.addChild(new blockClass({
			x: (0.5 + i - ROW_SPAN / 2) * (BLOCK_SIZE * BLOCK_SCALE + BLOCK_MARGIN),
			scale: BLOCK_SCALE
		}));
	}
	for (var i = 0; i < ROW_SPAN; i++) {
		var block = self.blocks[i];
		if (i > 0) {
			block.leftBlock = self.blocks[i - 1];
		}
		if (i < ROW_SPAN - 1) {
			block.rightBlock = self.blocks[i + 1];
		}
	}
	self.setUp = function (upRow) {
		for (var i = 0; i < ROW_SPAN; i++) {
			var selfBlock = self.blocks[i];
			var upBlock = upRow.blocks[i];
			upBlock.downBlock = selfBlock;
			selfBlock.upBlock = upBlock;
		}
	};
	self.setDown = function (downRow) {
		for (var i = 0; i < ROW_SPAN; i++) {
			var selfBlock = self.blocks[i];
			var downBlock = downRow.blocks[i];
			downBlock.upBlock = selfBlock;
			selfBlock.downBlock = downBlock;
		}
	};
	return self;
});
var Block = ConfigContainer.expand(function (config) {
	var self = ConfigContainer.call(this, config);
	var isRotating = false;
	self.orientation = config.orientation !== undefined ? config.orientation : Math.floor(4 * Math.random());
	self.upPath = false;
	self.rightPath = false;
	self.downPath = false;
	self.leftPath = false;
	self.upBlock;
	self.rightBlock;
	self.downBlock;
	self.leftBlock;
	self.attachAsset('shapeBox', {
		width: BLOCK_SIZE,
		height: BLOCK_SIZE,
		anchorX: 0.5,
		anchorY: 0.5,
		alpha: 0
	});
	self.lightContainer = lightManager.addChild(new Container());
	self.blockContainer = self.addChild(new ConfigContainer({
		rotation: self.orientation * Math.PI / 2
	}));
	self.rotate = function () {
		if (!self.lit && !isRotating) {
			isRotating = true;
			self.lightContainer.removeChildren();
			tween(self.blockContainer, {
				rotation: self.blockContainer.rotation + Math.PI / 2
			}, {
				duration: BLOCK_ROTATE_SPEED,
				onFinish: function onFinish() {
					isRotating = false;
					self.orientation = (self.orientation + 1) % 4;
					self.onSettle();
				}
			});
		}
	};
	self.update = function () {
		self.lightContainer.x = self.x + parent.x;
		self.lightContainer.y = self.y + parent.y;
	};
	self.down = function () {
		self.rotate();
	};
	self.onLit = function () {
		if (!self.lit && (self.upPath || self.downPath || self.leftPath || self.rightPath)) {
			self.lit = true;
			self.lightContainer.removeChildren();
			self.lightContainer.attachAsset('shapeEllipse', {
				width: BLOCK_SIZE - 2 * LIGHT_OFFSET,
				height: BLOCK_SIZE - 2 * LIGHT_OFFSET,
				anchorX: 0.5,
				anchorY: 0.5
			});
			if (self.upPath && (!self.upBlock || !self.upBlock.lit || !self.upBlock.downPath)) {
				self.lightContainer.addChild(new Glow({
					y: -BLOCK_SIZE / 2 - BLOCK_MARGIN / 4,
					width: LIGHT_SPILL_SIZE,
					height: LIGHT_SPILL_SIZE,
					anchorX: 0.5,
					anchorY: 0.5,
					rangeX: 20,
					layers: 4,
					solid: true,
					tint: 0xFFFFFF
				}));
			}
			if (self.rightPath && (!self.rightBlock || !self.rightBlock.lit || !self.rightBlock.leftPath)) {
				self.lightContainer.addChild(new Glow({
					x: BLOCK_SIZE / 2 + BLOCK_MARGIN / 4,
					width: LIGHT_SPILL_SIZE,
					height: LIGHT_SPILL_SIZE,
					anchorX: 0.5,
					anchorY: 0.5,
					rangeY: 20,
					layers: 4,
					solid: true,
					tint: 0xFFFFFF
				}));
			}
			if (self.downPath && (!self.downBlock || !self.downBlock.lit || !self.downBlock.upPath)) {
				self.lightContainer.addChild(new Glow({
					y: BLOCK_SIZE / 2 + BLOCK_MARGIN / 4,
					width: LIGHT_SPILL_SIZE,
					height: LIGHT_SPILL_SIZE,
					anchorX: 0.5,
					anchorY: 0.5,
					rangeX: 20,
					layers: 4,
					solid: true,
					tint: 0xFFFFFF
				}));
			}
			if (self.leftPath && (!self.leftBlock || !self.leftBlock.lit || !self.leftBlock.rightPath)) {
				self.lightContainer.addChild(new Glow({
					x: -BLOCK_SIZE / 2 - BLOCK_MARGIN / 4,
					width: LIGHT_SPILL_SIZE,
					height: LIGHT_SPILL_SIZE,
					anchorX: 0.5,
					anchorY: 0.5,
					rangeY: 20,
					layers: 4,
					solid: true,
					tint: 0xFFFFFF
				}));
			}
			self.onSettle();
		}
	};
	self.onSettle = function () {
		self.updatePaths();
		if (self.lit) {
			if (self.upPath && self.upBlock && self.upBlock.downPath && !self.upBlock.lit) {
				self.upBlock.lightContainer.addChild(new Light({
					y: BLOCK_HALFSIZE,
					rotation: 0,
					callback: self.upBlock.onLit
				}));
			}
			if (self.rightPath && self.rightBlock && self.rightBlock.leftPath && !self.rightBlock.lit) {
				self.rightBlock.lightContainer.addChild(new Light({
					x: -BLOCK_HALFSIZE,
					rotation: Math.PI / 2,
					callback: self.rightBlock.onLit
				}));
			}
			if (self.downPath && self.downBlock && self.downBlock.upPath && !self.downBlock.lit) {
				self.downBlock.lightContainer.addChild(new Light({
					y: -BLOCK_HALFSIZE,
					rotation: Math.PI,
					callback: self.downBlock.onLit
				}));
			}
			if (self.leftPath && self.leftBlock && self.leftBlock.rightPath && !self.leftBlock.lit) {
				self.leftBlock.lightContainer.addChild(new Light({
					x: BLOCK_HALFSIZE,
					rotation: 3 * Math.PI / 2,
					callback: self.leftBlock.onLit
				}));
			}
		} else {
			if (self.upPath && self.upBlock && self.upBlock.downPath && self.upBlock.lit) {
				self.lightContainer.addChild(new Light({
					y: -BLOCK_HALFSIZE,
					rotation: Math.PI,
					callback: self.onLit
				}));
			}
			if (self.rightPath && self.rightBlock && self.rightBlock.leftPath && self.rightBlock.lit) {
				self.lightContainer.addChild(new Light({
					x: BLOCK_HALFSIZE,
					rotation: 3 * Math.PI / 2,
					callback: self.onLit
				}));
			}
			if (self.downPath && self.downBlock && self.downBlock.upPath && self.downBlock.lit) {
				self.lightContainer.addChild(new Light({
					y: BLOCK_HALFSIZE,
					rotation: 0,
					callback: self.onLit
				}));
			}
			if (self.leftPath && self.leftBlock && self.leftBlock.rightPath && self.leftBlock.lit) {
				self.lightContainer.addChild(new Light({
					x: -BLOCK_HALFSIZE,
					rotation: Math.PI / 2,
					callback: self.onLit
				}));
			}
		}
	};
	self.updatePaths = function () {};
	return self;
});
var BlockX = Block.expand(function (config) {
	var self = Block.call(this, config);
	self.upPath = true;
	self.rightPath = true;
	self.downPath = true;
	self.leftPath = true;
	self.blockContainer.attachAsset('blockX1', {
		x: -BLOCK_HALFSIZE,
		y: -BLOCK_HALFSIZE,
		anchorX: 0,
		anchorY: 0
	});
	self.blockContainer.attachAsset('blockX2', {
		x: BLOCK_HALFSIZE,
		y: -BLOCK_HALFSIZE,
		anchorX: 1,
		anchorY: 0
	});
	self.blockContainer.attachAsset('blockX3', {
		x: -BLOCK_HALFSIZE,
		y: BLOCK_HALFSIZE,
		anchorX: 0,
		anchorY: 1
	});
	self.blockContainer.attachAsset('blockX4', {
		x: BLOCK_HALFSIZE,
		y: BLOCK_HALFSIZE,
		anchorX: 1,
		anchorY: 1
	});
	self.down = function () {};
	return self;
});
var BlockT = Block.expand(function (config) {
	var self = Block.call(this, config);
	self.blockContainer.attachAsset('blockT1', {
		x: -BLOCK_HALFSIZE,
		y: -BLOCK_HALFSIZE,
		anchorX: 0,
		anchorY: 0
	});
	self.blockContainer.attachAsset('blockT2', {
		x: BLOCK_HALFSIZE,
		y: -BLOCK_HALFSIZE,
		anchorX: 1,
		anchorY: 0
	});
	self.blockContainer.attachAsset('blockT3', {
		y: BLOCK_HALFSIZE,
		anchorX: 0.5,
		anchorY: 1
	});
	self.updatePaths = function () {
		self.downPath = self.orientation !== 0;
		self.leftPath = self.orientation !== 1;
		self.upPath = self.orientation !== 2;
		self.rightPath = self.orientation !== 3;
	};
	self.updatePaths();
	return self;
});
var BlockLine = Block.expand(function (config) {
	var self = Block.call(this, config);
	self.blockContainer.attachAsset('blockLine1', {
		x: -BLOCK_HALFSIZE,
		anchorX: 0,
		anchorY: 0.5,
		height: BLOCK_SIZE
	});
	self.blockContainer.attachAsset('blockLine2', {
		x: BLOCK_HALFSIZE,
		anchorX: 1,
		anchorY: 0.5,
		height: BLOCK_SIZE
	});
	self.updatePaths = function () {
		var vertical = !(self.orientation % 2);
		self.upPath = vertical;
		self.downPath = vertical;
		self.leftPath = !vertical;
		self.rightPath = !vertical;
	};
	self.updatePaths();
	return self;
});
var BlockL = Block.expand(function (config) {
	var self = Block.call(this, config);
	self.blockContainer.attachAsset('blockL1', {
		anchorX: 0.5,
		anchorY: 0.5,
		height: BLOCK_SIZE
	});
	self.blockContainer.attachAsset('blockL2', {
		x: -BLOCK_HALFSIZE,
		y: BLOCK_HALFSIZE,
		anchorX: 0,
		anchorY: 1
	});
	self.updatePaths = function () {
		self.leftPath = self.orientation === 0 || self.orientation === 1;
		self.upPath = self.orientation === 1 || self.orientation === 2;
		self.rightPath = self.orientation === 2 || self.orientation === 3;
		self.downPath = self.orientation === 3 || self.orientation === 0;
	};
	self.updatePaths();
	return self;
});
var BlockBlank = Block.expand(function (config) {
	var self = Block.call(this, config);
	var blockBlankAssets = ['blockBlank1', 'blockBlank2', 'blockBlank3'];
	var randomAsset = blockBlankAssets[Math.floor(Math.random() * blockBlankAssets.length)];
	self.blockContainer.attachAsset(randomAsset, {
		anchorX: 0.5,
		anchorY: 0.5,
		width: BLOCK_SIZE,
		height: BLOCK_SIZE
	});
	self.down = function () {};
	return self;
});

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

/**** 
* Game Code
****/ 
var LAVA_LINE = game.height - 200;
var LAVA_SLICE_COUNT = 18;
var LAVA_SLICE_WIDTH = 128;
var LAVA_BOB_HEIGHT = 10;
var LAVA_BOB_OFFSET = Math.PI / 5;
var LAVA_BOB_PERIOD = Math.PI / 60;
var BLOCK_SCALE = 2.5;
var BLOCK_SIZE = 100;
var BLOCK_MARGIN = 20;
var BLOCK_HALFSIZE = BLOCK_SIZE * 0.5;
var BLOCK_ROTATE_SPEED = 100;
var LIGHT_GROW_SPEED = 5000;
var LIGHT_SPILL_SIZE = 35;
var LIGHT_OFFSET = 5;
var ROW_SPAN = 7;
var ROW_COUNT = 11;
var lightManager = game.addChild(new Container());
var blockManager = game.addChild(new BlockManager());
var lava = game.addChild(new Lava({
	x: game.width / 2,
	y: LAVA_LINE
}));
function shuffle(array) {
	var currentIndex = array.length;
	while (currentIndex != 0) {
		var randomIndex = Math.floor(Math.random() * currentIndex);
		currentIndex--;
		var ref = [array[randomIndex], array[currentIndex]];
		array[currentIndex] = ref[0];
		array[randomIndex] = ref[1];
	}
	return array;
}
function generateBlockClasses(index) {
	var settings = {
		index: index
	};
	switch (index) {
		case 0:
			return [BlockBlank, BlockBlank, BlockBlank, BlockX, BlockBlank, BlockBlank, BlockBlank];
		case 1:
			settings.blanks = ROW_SPAN; // Prevent additional blanks
			return [BlockBlank, BlockBlank, randomizeBlockClass(settings), BlockX, randomizeBlockClass(settings), BlockBlank, BlockBlank];
		case 2:
			return [BlockBlank, randomizeBlockClass(settings), randomizeBlockClass(settings), BlockX, randomizeBlockClass(settings), randomizeBlockClass(settings), BlockBlank];
		default:
			var blockClasses = [];
			for (var i = 0; i < ROW_SPAN; i++) {
				blockClasses[i] = randomizeBlockClass(settings);
			}
			return shuffle(blockClasses);
	}
}
function randomizeBlockClass(settings) {
	var classes = [BlockBlank, BlockT, BlockX, BlockLine, BlockL];
	return classes[Math.floor(Math.random() * classes.length)];
}

===================================================================
--- original.js
+++ change.js
@@ -113,9 +113,8 @@
 		width: 3 * LAVA_SLICE_WIDTH,
 		alpha: 0.35,
 		tint: 0xFF4D00
 	}));
-	self.lightContainer = self.addChild(new ConfigContainer({}));
 	self.update = function () {
 		self.y = Math.sin(LK.ticks * LAVA_BOB_PERIOD + config.index * LAVA_BOB_OFFSET) * LAVA_BOB_HEIGHT;
 	};
 	return self;
@@ -205,12 +204,9 @@
 		anchorX: 0.5,
 		anchorY: 0.5,
 		alpha: 0
 	});
-	self.lightContainer = lightManager.addChild(new ConfigContainer({
-		x: self.x + (self.parent ? self.parent.x : 0),
-		y: self.y + (self.parent ? self.parent.y : 0)
-	}));
+	self.lightContainer = lightManager.addChild(new Container());
 	self.blockContainer = self.addChild(new ConfigContainer({
 		rotation: self.orientation * Math.PI / 2
 	}));
 	self.rotate = function () {
@@ -228,8 +224,12 @@
 				}
 			});
 		}
 	};
+	self.update = function () {
+		self.lightContainer.x = self.x + parent.x;
+		self.lightContainer.y = self.y + parent.y;
+	};
 	self.down = function () {
 		self.rotate();
 	};
 	self.onLit = function () {