/**** 
* Classes
****/ 
// Assets will be automatically generated based on usage in the code.
// Domino class
var Domino = Container.expand(function () {
	var self = Container.call(this);
	// Assuming directionsList is a shuffled array of directions ['U', 'L', 'R', 'D'] repeated to match the number of dominos
	self.direction = directionsList.shift();
	// Updated asset attachment logic based on direction
	switch (self.direction) {
		case 'U':
			dominoGraphics = self.attachAsset('D_Up', {
				anchorX: 0.5,
				anchorY: 0.5
			});
			break;
		case 'D':
			dominoGraphics = self.attachAsset('D_Down', {
				anchorX: 0.5,
				anchorY: 0.5
			});
			break;
		case 'L':
			dominoGraphics = self.attachAsset('D_Left', {
				anchorX: 0.5,
				anchorY: 0.5
			});
			break;
		case 'R':
			dominoGraphics = self.attachAsset('D_Right', {
				anchorX: 0.5,
				anchorY: 0.5
			});
			break;
	}
	self.isTipped = false;
	self.hiddenCoin = false; // Indicates whether a coin is hidden underneath
	// Direction is already set at the beginning of the constructor.
	// Direction label code removed as it's no longer necessary with direction-specific assets
	self.tip = function (projectile) {
		if (projectile) {
			projectilePool.put(projectile); // Recycle the projectile immediately
			var index = projectiles.indexOf(projectile);
			if (index !== -1) {
				projectiles.splice(index, 1); // Remove from tracking array
			}
		}
		if (!self.isTipped) {
			self.isTipped = true;
			if (self.hiddenCoin) {
				// Change appearance to a coin and increase score by 10 points
				self.destroy();
				var coin = new Container();
				coin.attachAsset('coin', {
					anchorX: 0.5,
					anchorY: 0.5
				});
				game.addChild(coin);
				coin.x = self.x;
				coin.y = self.y;
				score += 10; // Increase score by 10 points for revealing a coin
			} else {
				// Destroy original domino before changing to domino_flipped
				self.destroy();
				var flippedDomino = new Domino();
				flippedDomino.attachAsset('domino_flipped', {
					anchorX: 0.5,
					anchorY: 0.5
				});
				game.addChild(flippedDomino);
				flippedDomino.x = self.x;
				flippedDomino.y = self.y;
			}
			// directionLabel removal code has been deprecated
			// Tip animation logic here
			LK.effects.flashObject(self, 0xffa500, 500);
			// Increment score by 1 for regular domino flips
			score += 1;
			// Update score display
			scoreTxt.setText(score.toString());
			// Shoot a projectile in the direction specified by the domino's symbol
			var projectile = projectilePool.get();
			projectile.direction = self.direction;
			projectile.x = self.x;
			projectile.y = self.y;
			// Update the projectile's grid position
			projectile.gridX = Math.floor(projectile.x / 100);
			projectile.gridY = Math.floor(projectile.y / 100);
			game.addChild(projectile);
			projectiles.push(projectile);
		}
		// Update the domino's grid position
		self.gridX = Math.floor(self.x / 100);
		self.gridY = Math.floor(self.y / 100);
	};
});
// Factory class
var Factory = Container.expand(function () {
	var self = Container.call(this);
	self.dominos = [];
	self.addDomino = function (x, y, hasHiddenCoin) {
		var domino = new Domino();
		domino.x = x;
		domino.y = y;
		domino.hiddenCoin = hasHiddenCoin || false;
		self.addChild(domino);
		self.dominos.push(domino);
	};
	self.reset = function () {
		self.dominos.forEach(function (domino) {
			domino.destroy(); // Destroy domino instance
			// Remove any event listeners attached to domino here if any
		});
		self.dominos.length = 0; // Clear the array without creating a new one
	};
});
// Projectile class
var Projectile = Container.expand(function () {
	var self = Container.call(this);
	var projectileGraphics = self.attachAsset('projectile', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	self.direction = '';
	self.speed = 10;
	self.move = function () {
		// Decrease acceleration factor
		var acceleration = 0.5;
		// Update speed with decreased acceleration
		self.speed += acceleration;
		switch (self.direction) {
			case 'U':
				self.y -= self.speed;
				break;
			case 'L':
				self.x -= self.speed;
				break;
			case 'R':
				self.x += self.speed;
				break;
			case 'D':
				self.y += self.speed;
				break;
		}
		// Update the projectile's grid position and check for collisions with dominos
		self.gridX = Math.floor(self.x / 100);
		self.gridY = Math.floor(self.y / 100);
		// Check for domino collisions after moving
		factory.dominos.forEach(function (domino) {
			if (!domino.isTipped && self.raycast(domino)) {
				domino.tip(self); // Pass this projectile to the domino's tip method
				// Reset projectile's speed to its original value after tipping a domino
				self.speed = 10;
			}
		});
	};
	self.raycast = function (domino) {
		// Calculate the distance between the projectile and the domino
		var dx = domino.x - self.x;
		var dy = domino.y - self.y;
		var distance = Math.sqrt(dx * dx + dy * dy);
		// If the distance is less than the sum of their radii, there is an intersection
		return distance < self.width / 2 + domino.width / 2;
	};
});

/**** 
* Initialize Game
****/ 
// Initialize a new projectile pool
var game = new LK.Game({
	backgroundColor: 0xd3d3d3 // Set game background to light grey
});

/**** 
* Game Code
****/ 
var backgroundAsset = LK.getAsset('background', {
	anchorX: 0.0,
	anchorY: 0.0
});
var background = game.addChild(LK.getAsset('background', {
	x: 0,
	y: 0,
	width: game.width,
	height: game.height
}));
// Function to shuffle an array
function shuffleArray(array) {
	for (var i = array.length - 1; i > 0; i--) {
		var j = Math.floor(Math.random() * (i + 1));
		var _ref = [array[j], array[i]];
		array[i] = _ref[0];
		array[j] = _ref[1];
	}
}
// Calculate total number of dominos based on grid size (16 columns * 20 rows)
var totalDominos = 16 * 20;
// Divide total by 4 to get number of dominos for each direction
var dominosPerDirection = totalDominos / 4;
// Create a list of directions with an equal number of 'U', 'L', 'R', 'D'
var directionsList = [];
['U', 'L', 'R', 'D'].forEach(function (direction) {
	for (var i = 0; i < dominosPerDirection; i++) {
		directionsList.push(direction);
	}
});
// Shuffle the directions list
shuffleArray(directionsList);
// Initialize score variable
var score = 0;
// Display score
var scoreTxt = new Text2(score.toString(), {
	size: 150,
	fill: "#ffffff",
	stroke: "#000000",
	// Black outline
	strokeThickness: 8 // Thickness of the outline
});
scoreTxt.anchor.set(0.5, 0); // Center the score text horizontally
LK.gui.top.addChild(scoreTxt); // Add the score text to the GUI overlay at the top-center of the screen
// Custom intersects function for accurate collision detection
function intersects(projectile, domino) {
	var projectileBounds = {
		left: projectile.x - projectile.width / 2,
		right: projectile.x + projectile.width / 2,
		top: projectile.y - projectile.height / 2,
		bottom: projectile.y + projectile.height / 2
	};
	var dominoBounds = {
		left: domino.x - domino.width / 2,
		right: domino.x + domino.width / 2,
		top: domino.y - domino.height / 2,
		bottom: domino.y + domino.height / 2
	};
	return !(projectileBounds.right < dominoBounds.left || projectileBounds.left > dominoBounds.right || projectileBounds.bottom < dominoBounds.top || projectileBounds.top > dominoBounds.bottom);
}
// Array to store all projectiles
// ProjectilePool class
var ProjectilePool = function ProjectilePool() {
	this.pool = [];
	this.get = function () {
		if (this.pool.length > 0) {
			return this.pool.pop();
		} else {
			return new Projectile();
		}
	};
	this.put = function (projectile) {
		// Assuming projectiles might have event listeners attached
		// Remove event listeners from projectile here if any
		this.pool.push(projectile);
	};
};
// Initialize a new projectile pool
var projectilePool = new ProjectilePool();
var projectiles = [];
// Game tick function to move all projectiles and check for domino tipping
LK.on('tick', function () {
	projectiles.forEach(function (projectile, i) {
		// Move the projectile based on its direction
		projectile.move();
		// Check for domino tipping within the same grid cell
		var tippedDomino = factory.dominos.find(function (domino) {
			return !domino.isTipped && domino.gridX === projectile.gridX && domino.gridY === projectile.gridY && projectile.intersects(domino);
		});
		if (tippedDomino) {
			// Recycle the current projectile
			projectilePool.put(projectile);
			projectiles.splice(i, 1);
			// Trigger the projectile of the domino it just hit
			tippedDomino.tip();
		}
		// Remove projectiles that have moved off screen
		if (projectile.x < 0 || projectile.x > 2048 || projectile.y < 0 || projectile.y > 2732) {
			projectile.destroy(); // Destroy the projectile when it hits the edge of the screen
			projectiles.splice(i, 1); // Remove from tracking array
		}
	});
});
var factory = game.addChild(new Factory());
// Function to check and trigger domino tipping
function checkAndTipDominos(x, y) {
	factory.dominos.forEach(function (domino) {
		if (Math.abs(domino.x - x) < 100 && Math.abs(domino.y - y) < 100) {
			domino.tip();
		}
	});
}
// Populate the factory with dominos and randomly select 10 to have hidden coins
var dominoIndexesWithCoins = [];
while (dominoIndexesWithCoins.length < 10) {
	var randomIndex = Math.floor(Math.random() * 320); // 320 is the total number of dominos (16*20)
	if (dominoIndexesWithCoins.indexOf(randomIndex) === -1) {
		dominoIndexesWithCoins.push(randomIndex);
	}
}
var dominoCounter = 0;
for (var i = 0; i < 16; i++) {
	for (var j = 0; j < 20; j++) {
		factory.addDomino(2048 / 2 - 16 * 100 / 2 + i * 100, 2732 / 2 - 20 * 100 / 2 + j * 100, dominoIndexesWithCoins.includes(dominoCounter));
		dominoCounter++;
	}
}
// Handle touch events to tip dominos
game.on('down', function (obj) {
	var pos = obj.event.getLocalPosition(game);
	// Find the closest domino to the tap position
	var closestDomino = factory.dominos.reduce(function (closest, domino) {
		var distance = Math.sqrt(Math.pow(domino.x - pos.x, 2) + Math.pow(domino.y - pos.y, 2));
		if (distance < closest.distance) {
			return {
				domino: domino,
				distance: distance
			};
		} else {
			return closest;
		}
	}, {
		domino: null,
		distance: Infinity
	});
	// Tip the closest domino if it is within 100 units of the tap position
	if (closestDomino.distance < 100) {
		closestDomino.domino.tip();
	}
});

===================================================================
--- original.js
+++ change.js
@@ -298,9 +298,9 @@
 }
 var dominoCounter = 0;
 for (var i = 0; i < 16; i++) {
 	for (var j = 0; j < 20; j++) {
-		factory.addDomino(120 + i * 50, 350 + j * 50, dominoIndexesWithCoins.includes(dominoCounter));
+		factory.addDomino(2048 / 2 - 16 * 100 / 2 + i * 100, 2732 / 2 - 20 * 100 / 2 + j * 100, dominoIndexesWithCoins.includes(dominoCounter));
 		dominoCounter++;
 	}
 }
 // Handle touch events to tip dominos