/**** 
* Classes
****/
var TetrominoBlock = Container.expand(function (type, gridX, gridY) {
	var self = Container.call(this);
	var block = self.createAsset('block_' + type, 'Tetromino block', 0.5, 0.5);
	block.x = gridX * block.width;
	block.y = gridY * block.height;
	this.addChild(block);
});
// Define Tetromino class
var Tetromino = Container.expand(function () {
	var self = Container.call(this);
	this.blocks = [];
	this.type = '';
	this.rotationIndex = 0;
	this.initializeBlocks = function (layout) {
		for (var i = 0; i < layout.length; i++) {
			for (var j = 0; j < layout[i].length; j++) {
				if (layout[i][j]) {
					this.blocks.push(new TetrominoBlock(this.type, j, i));
				}
			}
		}
	};
	this.create = function (type) {
		this.type = type;
		this.rotationIndex = 0;
		var layout = tetrominoLayouts[type][this.rotationIndex];
		this.initializeBlocks(layout);
	};
	this.rotate = function () {
		this.rotationIndex = (this.rotationIndex + 1) % tetrominoLayouts[this.type].length;
		this.updateBlockPositions();
	};
	this.updateBlockPositions = function () {
		var layout = tetrominoLayouts[this.type][this.rotationIndex];
		var k = 0;
		for (var i = 0; i < layout.length; i++) {
			for (var j = 0; j < layout[i].length; j++) {
				if (layout[i][j]) {
					this.blocks[k].x = j * this.blocks[k].width;
					this.blocks[k].y = i * this.blocks[k].height;
					k++;
				}
			}
		}
	};
	this.move = function (dx, dy) {
		var movement = TetrominoMovement.calculateMove(this, dx, dy, board);
		if (movement.canMove) {
			this.x = movement.newX;
			this.y = movement.newY;
		}
	};
});
// Define GameBoard class
var GameBoard = Container.expand(function () {
	var self = Container.call(this);
	GameBoard.prototype.fixTetromino = function (tetromino) {
		var blocks = tetromino.blocks;
		for (var i = 0; i < blocks.length; i++) {
			var block = blocks[i];
			var x = Math.round((block.x + tetromino.x - this.x) / blockSize);
			var y = Math.round((block.y + tetromino.y - this.y) / blockSize);
			this.lowerField.addBlock(block, x, y);
		}
	};
	this.grid = [];
	this.lowerField = new LowerField();
	this.init = function () {
		for (var i = 0; i < boardHeight; i++) {
			this.grid[i] = [];
			for (var j = 0; j < boardWidth; j++) {
				this.grid[i][j] = null;
			}
		}
		this.lowerField.init();
	};
	this.addTetromino = function (tetromino) {
		var blocks = tetromino.blocks;
		for (var i = 0; i < blocks.length; i++) {
			var block = blocks[i];
			var x = Math.round((block.x + tetromino.x - this.x) / blockSize);
			var y = Math.round((block.y + tetromino.y - this.y) / blockSize);
			// Check if the block is within the board and not already occupied
			if (y < boardHeight && !this.grid[y][x]) {
				this.grid[y][x] = block;
			} else {
				// If the block cannot be placed, fix the Tetromino in its last valid position
				tetromino.y -= blockSize;
				this.fixTetromino(tetromino);
				return false;
			}
		}
		return true;
	};
	this.isGameOver = function () {
		for (var x = 0; x < boardWidth; x++) {
			if (this.grid[0][x] !== null) {
				return true;
			}
		}
		return false;
	};
	this.checkLines = function () {
		for (var y = 0; y < boardHeight; y++) {
			var lineComplete = true;
			for (var x = 0; x < boardWidth; x++) {
				if (this.grid[y][x] === null) {
					lineComplete = false;
					break;
				}
			}
			if (lineComplete) {
				for (var x = 0; x < boardWidth; x++) {
					var block = this.grid[y][x];
					block.destroy();
					this.grid[y][x] = null;
				}
				for (var row = y; row > 0; row--) {
					for (var x = 0; x < boardWidth; x++) {
						if (this.grid[row - 1][x] !== null) {
							this.grid[row][x] = this.grid[row - 1][x];
							this.grid[row - 1][x] = null;
							this.grid[row][x].y += blockSize;
						}
					}
				}
				LK.setScore(LK.getScore() + 100);
				scoreTxt.setText(LK.getScore());
			}
		}
	};
});
// Define LowerField class for collecting Tetrominoes
var LowerField = Container.expand(function () {
	var self = Container.call(this);
	this.init = function () {
		this.grid = [];
		for (var i = 0; i < boardHeight; i++) {
			this.grid[i] = [];
			for (var j = 0; j < boardWidth; j++) {
				this.grid[i][j] = null;
			}
		}
	};
	this.init();
	this.addBlock = function (block, x, y) {
		if (y < boardHeight && x < boardWidth) {
			this.grid[y][x] = block;
			block.x = x * blockSize;
			block.y = y * blockSize;
			this.addChild(block);
		}
	};
});

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

/**** 
* Game Code
****/
// Define game constants and variables
var TetrominoMovement = {
	calculateMove: function calculateMove(tetromino, dx, dy, board) {
		var newX = tetromino.x + dx;
		var newY = tetromino.y + dy;
		var canMove = true;
		for (var i = 0; i < tetromino.blocks.length; i++) {
			var block = tetromino.blocks[i];
			var gridX = Math.round((block.x + newX - board.x) / blockSize);
			var gridY = Math.round((block.y + newY - board.y) / blockSize);
			if (gridX < 0 || gridX >= boardWidth || gridY < 0 || gridY >= boardHeight || board.grid[gridY] && board.grid[gridY][gridX]) {
				canMove = false;
				break;
			}
		}
		return {
			canMove: canMove,
			newX: newX,
			newY: newY
		};
	}
};
var boardWidth = 10;
var boardHeight = 20;
var blockSize = 2048 / boardWidth; // Calculate block size based on viewable area width
var fallRate = 1000; // Time in milliseconds between each Tetromino fall step
var board = game.addChild(new GameBoard());
var currentTetromino;
var nextTetrominoType;
var tetrominoTypes = ['I', 'J', 'L', 'O', 'S', 'T', 'Z'];
var tetrominoLayouts = {
	'I': [[[1, 1, 1, 1]]],
	'J': [[[1, 0, 0], [1, 1, 1]]],
	'L': [[[0, 0, 1], [1, 1, 1]]],
	'O': [[[1, 1], [1, 1]]],
	'S': [[[0, 1, 1], [1, 1, 0]]],
	'T': [[[0, 1, 0], [1, 1, 1]]],
	'Z': [[[1, 1, 0], [0, 1, 1]]]
};
var scoreTxt;
var isGameOver = false;

// Initialize board
board.init();

// Center the board on the screen
board.x = (2048 - boardWidth * blockSize) / 2;
board.y = (2732 - boardHeight * blockSize) / 2;

// Create score display
scoreTxt = new Text2('0', {
	size: 150,
	fill: "#ffffff"
});
scoreTxt.anchor.set(.5, 0);
LK.gui.top.addChild(scoreTxt);

// Function to spawn a new tetromino
function spawnTetromino() {
	var type = nextTetrominoType || tetrominoTypes[Math.floor(Math.random() * tetrominoTypes.length)];
	nextTetrominoType = tetrominoTypes[Math.floor(Math.random() * tetrominoTypes.length)];
	currentTetromino = new Tetromino();
	currentTetromino.create(type);
	currentTetromino.x = board.x + boardWidth / 2 * blockSize - currentTetromino.width / 2;
	currentTetromino.y = board.y;
	game.addChild(currentTetromino);
}

// Start the game with a new tetromino
spawnTetromino();

// Game tick event
LK.on('tick', function () {
	if (isGameOver) {
		LK.effects.flashScreen(0xff0000, 1000);
		LK.showGameOver();
		return;
	}

	// Implement fall rate timer
	if (LK.ticks % (fallRate / (1000 / 60)) === 0) {
		// Attempt to move current tetromino down and check for collision
		var originalY = currentTetromino.y;
		currentTetromino.move(0, blockSize);
		board.addTetromino(currentTetromino);
		if (currentTetromino.y === originalY) {
			// Collision occurred, spawn a new Tetromino
			spawnTetromino();
		}
	}

	// Check for completed lines
	board.checkLines();

	// Check for game over
	if (board.isGameOver()) {
		isGameOver = true;
	}
});

// Touch event listeners for rotating and moving tetromino
game.on('down', function (obj) {
	var touchPos = obj.event.getLocalPosition(game);
	if (touchPos.x < board.x) {
		// Move tetromino left
		currentTetromino.move(-blockSize, 0);
	} else if (touchPos.x > board.x + boardWidth * blockSize) {
		// Move tetromino right
		currentTetromino.move(blockSize, 0);
	}
});
game.on('up', function (obj) {
	// Rotate tetromino
	currentTetromino.rotate();
});

===================================================================
--- original.js
+++ change.js
@@ -46,27 +46,13 @@
 			}
 		}
 	};
 	this.move = function (dx, dy) {
-		var newX = this.x + dx;
-		var newY = this.y + dy;
-		var canMove = true;
-		// Check each block for potential collisions
-		for (var i = 0; i < this.blocks.length; i++) {
-			var block = this.blocks[i];
-			var gridX = Math.round((block.x + newX - board.x) / blockSize);
-			var gridY = Math.round((block.y + newY - board.y) / blockSize);
-			// Check boundaries and occupied spaces
-			if (gridX < 0 || gridX >= boardWidth || gridY < 0 || gridY >= boardHeight || board.grid[gridY] && board.grid[gridY][gridX]) {
-				canMove = false;
-				break;
-			}
+		var movement = TetrominoMovement.calculateMove(this, dx, dy, board);
+		if (movement.canMove) {
+			this.x = movement.newX;
+			this.y = movement.newY;
 		}
-		// Move Tetromino if no collisions are detected
-		if (canMove) {
-			this.x = newX;
-			this.y = newY;
-		}
 	};
 });
 // Define GameBoard class
 var GameBoard = Container.expand(function () {
@@ -180,8 +166,29 @@
 /**** 
 * Game Code
 ****/
 // Define game constants and variables
+var TetrominoMovement = {
+	calculateMove: function calculateMove(tetromino, dx, dy, board) {
+		var newX = tetromino.x + dx;
+		var newY = tetromino.y + dy;
+		var canMove = true;
+		for (var i = 0; i < tetromino.blocks.length; i++) {
+			var block = tetromino.blocks[i];
+			var gridX = Math.round((block.x + newX - board.x) / blockSize);
+			var gridY = Math.round((block.y + newY - board.y) / blockSize);
+			if (gridX < 0 || gridX >= boardWidth || gridY < 0 || gridY >= boardHeight || board.grid[gridY] && board.grid[gridY][gridX]) {
+				canMove = false;
+				break;
+			}
+		}
+		return {
+			canMove: canMove,
+			newX: newX,
+			newY: newY
+		};
+	}
+};
 var boardWidth = 10;
 var boardHeight = 20;
 var blockSize = 2048 / boardWidth; // Calculate block size based on viewable area width
 var fallRate = 1000; // Time in milliseconds between each Tetromino fall step