/**** 
* Classes
****/
var TetrominoBlock = Container.expand(function (type, i, j) {
var self = Container.call(this);
var blockGraphic = self.createAsset('tetromino_' + type + '_' + i + '_' + j, type + ' Tetromino block at (' + i + ', ' + j + ')', 0.5, 0.5);
self.x = j * blockSize;
self.y = i * blockSize;
});
// Define Tetromino class
var Tetromino = Container.expand(function () {
var self = Container.call(this);
Tetromino.prototype.checkCollision = function (dx, dy, board) {
for (var i = 0; i < this.blocks.length; i++) {
var block = this.blocks[i];
var newX = this.x + block.x + dx;
var newY = this.y + block.y + dy;
var gridX = Math.floor(newX / blockSize);
var gridY = Math.floor(newY / blockSize);
if (gridX < 0 || gridX >= boardWidth || gridY >= boardHeight) {
return true; // Collision with board boundaries
}
if (gridY >= 0 && board.grid[gridY] && board.grid[gridY][gridX]) {
return true; // Collision with another block
}
}
return false;
};
this.blocks = [];
this.type = '';
this.rotationIndex = 0;
this.initializeBlocks = function (layout) {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]) {
var block = new TetrominoBlock(this.type, i, j);
this.blocks.push(this.addChild(block));
}
}
}
};
};
this.create = function (type) {
this.type = type;
this.rotationIndex = 0;
var layout = tetrominoLayouts[type][this.rotationIndex];
this.initializeBlocks(layout);
};
this.rotate = function () {
var oldRotationIndex = this.rotationIndex;
var newRotationIndex = (this.rotationIndex + 1) % tetrominoLayouts[this.type].length;
this.rotationIndex = newRotationIndex;
this.updateBlockPositions();
if (this.checkCollision(0, 0, board)) {
this.rotationIndex = oldRotationIndex;
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) {
if (!this.checkCollision(dx, dy, board)) {
this.x += dx;
this.y += dy;
} else if (dy > 0) {
board.fixTetromino(this);
spawnTetromino();
}
};
});

// Define GameBoard class
var GameBoard = Container.expand(function () {
var self = Container.call(this);
this.grid = gameBoardGrid; // Reference the initialized game board grid
this.checkLines = function () {
var linesCleared = 0;
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) {
linesCleared++;
for (var row = y; row > 0; row--) {
for (var x = 0; x < boardWidth; x++) {
this.grid[row][x] = this.grid[row - 1][x];
if (this.grid[row][x]) {
this.grid[row][x].y += blockSize;
}
}
}
for (var x = 0; x < boardWidth; x++) {
this.grid[0][x] = null;
}
}
}
if (linesCleared > 0) {
var scoreToAdd = linesCleared * linesCleared * 100;
LK.setScore(LK.getScore() + scoreToAdd);
scoreDisplay.updateScore(LK.getScore());
GameState.level = Math.floor(LK.getScore() / 1000) + 1;
fallRate = Math.max(1000 - (GameState.level - 1) * 100, 200);
scoreDisplay.updateLevel(GameState.level);
scoreDisplay.updateLinesCleared(GameState.linesCleared);
}
}
this.fixTetromino = function (tetromino) {
// Fix Tetromino to the board
// ... (Fixing code here)
};
});
// Define GameBoard class
var GameBoard = Container.expand(function () {
var self = Container.call(this);
this.grid = [];
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.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);
if (y < boardHeight && x < boardWidth) {
this.grid[y][x] = block;
block.x = x * blockSize;
block.y = y * blockSize;
this.addChild(block);
} else if (y < 0) {
LK.showGameOver();
return false;
}
}
this.checkLines();
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 row = y; row > 0; row--) {
for (var x = 0; x < boardWidth; x++) {
this.grid[row][x] = this.grid[row - 1][x];
if (this.grid[row][x]) {
this.grid[row][x].y += blockSize;
}
}
}
for (var x = 0; x < boardWidth; x++) {
this.grid[0][x] = null;
}
for (var x = 0; x < boardWidth; x++) {
if (this.grid[y][x]) {
this.grid[y][x].destroy();
this.grid[y][x] = null;
}
}
var linesCleared = 0;
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) {
linesCleared++;
for (var row = y; row > 0; row--) {
for (var x = 0; x < boardWidth; x++) {
this.grid[row][x] = this.grid[row - 1][x];
if (this.grid[row][x]) {
this.grid[row][x].y += blockSize;
}
}
}
for (var x = 0; x < boardWidth; x++) {
this.grid[0][x] = null;
}
for (var x = 0; x < boardWidth; x++) {
if (this.grid[y][x]) {
this.grid[y][x].destroy();
this.grid[y][x] = null;
}
}
}
}
if (linesCleared > 0) {
var scoreToAdd = (linesCleared === 1) ? 100 : (linesCleared === 2) ? 300 : (linesCleared === 3) ? 500 : 800;
LK.setScore(LK.getScore() + scoreToAdd);
scoreTxt.setText(LK.getScore());
}
}
}
};
this.init();
});
// 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 for better contrast
});

/**** 
* Game Code
****/
// Define game constants and variables
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 score = 0; // Initialize current score
var level = 1; // Initialize game level
var gameState = 'active'; // Game state can be 'paused', 'active', or 'gameOver'
this.grid = [];
for (var i = 0; i < boardHeight; i++) {
this.grid[i] = [];
for (var j = 0; j < boardWidth; j++) {
this.grid[i][j] = null; // Each cell starts as null (empty)
}
}

// GameBoard class is now encapsulated and instantiated separately
var board = new GameBoard();
board.init();

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

// Add the board to the game
game.addChild(board);

// Create score display
var ScoreDisplay = Container.expand(function () {
var self = Container.call(this);
this.scoreText = new Text2('Score: 0', {
size: 100,
fill: "#ffffff",
anchor: { x: 0.5, y: 0 }
});
this.levelText = new Text2('Level: 1', {
size: 100,
fill: "#ffffff",
anchor: { x: 0.5, y: 0 }
});
this.linesText = new Text2('Lines: 0', {
size: 100,
fill: "#ffffff",
anchor: { x: 0.5, y: 0 }
});
LK.gui.top.addChild(this.scoreText);
LK.gui.top.addChild(this.levelText);
LK.gui.top.addChild(this.linesText);
this.levelText.y = this.scoreText.height;
this.linesText.y = this.scoreText.height * 2;
this.updateScore = function (score) {
this.scoreText.setText('Score: ' + score.toString());
};
this.updateLevel = function (level) {
this.levelText.setText('Level: ' + level.toString());
};
this.updateLinesCleared = function (lines) {
this.linesText.setText('Lines: ' + lines.toString());
};
});

// Create a new ScoreDisplay instance
var scoreDisplay = new ScoreDisplay();

// Initialize the first Tetromino
spawnTetromino();

// 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) {
canMove = false;
break;
} else if (gridY >= 0 && 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
// GameBoard class is now encapsulated and instantiated separately
var board = new GameBoard();
game.addChild(board);
var GameState = {
currentTetromino: null,
nextTetrominoType: null,
tetrominoTypes: ['I', 'J', 'L', 'O', 'S', 'T', 'Z'],
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]]]
},
scoreTxt: null,
isGameOver: false,
initialize: function() {
GameState.nextTetrominoType = this.tetrominoTypes[Math.floor(Math.random() * this.tetrominoTypes.length)];
GameState.linesCleared = 0;
GameState.spawnTetromino();
scoreDisplay = new ScoreDisplay();
},
spawnTetromino: function() {
GameState.linesCleared = 0;
scoreDisplay.updateLinesCleared(GameState.linesCleared);
var type = this.nextTetrominoType != null ? this.nextTetrominoType : this.tetrominoTypes[Math.floor(Math.random() * this.tetrominoTypes.length)];
this.nextTetrominoType = this.tetrominoTypes[Math.floor(Math.random() * this.tetrominoTypes.length)];
this.currentTetromino = new Tetromino();
this.currentTetromino.create(type);
this.currentTetromino.x = board.x + (boardWidth * blockSize - this.currentTetromino.width) / 2;
this.currentTetromino.y = board.y - this.currentTetromino.height;
game.addChild(this.currentTetromino);
},
gameOver: function() {
this.isGameOver = true;
LK.showGameOver();
}
};
GameState.initialize();

// 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 = GameState.nextTetrominoType != null ? GameState.nextTetrominoType : GameState.tetrominoTypes[Math.floor(Math.random() * GameState.tetrominoTypes.length)];
GameState.nextTetrominoType = GameState.tetrominoTypes[Math.floor(Math.random() * GameState.tetrominoTypes.length)];
GameState.currentTetromino = new Tetromino();
GameState.currentTetromino.create(type);
GameState.currentTetromino.x = board.x + boardWidth / 2 * blockSize - GameState.currentTetromino.width / 2;
GameState.currentTetromino.y = board.y;
game.addChild(GameState.currentTetromino);
}

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

// Implement automatic Tetromino descent
var fallInterval = LK.setInterval(function() {
if (GameState.currentTetromino) {
GameState.currentTetromino.move(0, blockSize);
}
}, fallRate);

// Game tick event
LK.on('tick', function () {
// Implement fall rate timer
if (LK.ticks % (fallRate / (1000 / 60)) === 0) {
// Attempt to move current tetromino down and check for collision
currentTetromino.move(0, blockSize);
if (currentTetromino.isFixed) {
// Collision occurred and Tetromino is fixed, spawn a new Tetromino
spawnTetromino();
}
}

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

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

// Handle user input for moving and rotating the tetromino
handleUserInput();
});

// Function to handle user input for moving and rotating the tetromino
function handleUserInput() {
game.on('down', function (obj) {
var touchPos = obj.event.getLocalPosition(game);
// Define touch areas for control
var leftArea = { x: board.x, width: boardWidth * blockSize / 3 };
var rightArea = { x: board.x + boardWidth * blockSize * 2 / 3, width: boardWidth * blockSize / 3 };
var rotateArea = { x: board.x + boardWidth * blockSize / 3, width: boardWidth * blockSize / 3 };

// Move tetromino left
if (touchPos.x >= leftArea.x && touchPos.x < leftArea.x + leftArea.width) {
currentTetromino.move(-blockSize, 0);
}
// Move tetromino right
else if (touchPos.x >= rightArea.x && touchPos.x < rightArea.x + rightArea.width) {
currentTetromino.move(blockSize, 0);
}
// Rotate tetromino
else if (touchPos.x >= rotateArea.x && touchPos.x < rotateArea.x + rotateArea.width) {
currentTetromino.rotate();
}
});
}

// Touch event listeners for rotating and moving tetromino

===================================================================
--- original.js
+++ change.js
@@ -109,11 +109,15 @@
 }
 }
 }
 if (linesCleared > 0) {
-var scoreToAdd = (linesCleared === 1) ? 100 : (linesCleared === 2) ? 300 : (linesCleared === 3) ? 500 : 800;
+var scoreToAdd = linesCleared * linesCleared * 100;
 LK.setScore(LK.getScore() + scoreToAdd);
-scoreTxt.setText(LK.getScore());
+scoreDisplay.updateScore(LK.getScore());
+GameState.level = Math.floor(LK.getScore() / 1000) + 1;
+fallRate = Math.max(1000 - (GameState.level - 1) * 100, 200);
+scoreDisplay.updateLevel(GameState.level);
+scoreDisplay.updateLinesCleared(GameState.linesCleared);
 }
 }
 this.fixTetromino = function (tetromino) {
 // Fix Tetromino to the board
@@ -288,17 +292,37 @@
 
 // Create score display
 var ScoreDisplay = Container.expand(function () {
 var self = Container.call(this);
-this.scoreText = new Text2('0', {
-size: 150,
+this.scoreText = new Text2('Score: 0', {
+size: 100,
 fill: "#ffffff",
 anchor: { x: 0.5, y: 0 }
 });
+this.levelText = new Text2('Level: 1', {
+size: 100,
+fill: "#ffffff",
+anchor: { x: 0.5, y: 0 }
+});
+this.linesText = new Text2('Lines: 0', {
+size: 100,
+fill: "#ffffff",
+anchor: { x: 0.5, y: 0 }
+});
 LK.gui.top.addChild(this.scoreText);
+LK.gui.top.addChild(this.levelText);
+LK.gui.top.addChild(this.linesText);
+this.levelText.y = this.scoreText.height;
+this.linesText.y = this.scoreText.height * 2;
 this.updateScore = function (score) {
-this.scoreText.setText(score.toString());
+this.scoreText.setText('Score: ' + score.toString());
 };
+this.updateLevel = function (level) {
+this.levelText.setText('Level: ' + level.toString());
+};
+this.updateLinesCleared = function (lines) {
+this.linesText.setText('Lines: ' + lines.toString());
+};
 });
 
 // Create a new ScoreDisplay instance
 var scoreDisplay = new ScoreDisplay();
@@ -354,17 +378,15 @@
 scoreTxt: null,
 isGameOver: false,
 initialize: function() {
 GameState.nextTetrominoType = this.tetrominoTypes[Math.floor(Math.random() * this.tetrominoTypes.length)];
+GameState.linesCleared = 0;
 GameState.spawnTetromino();
-this.scoreTxt = new Text2('0', {
-size: 150,
-fill: "#ffffff"
-});
-this.scoreTxt.anchor.set(.5, 0);
-LK.gui.top.addChild(this.scoreTxt);
+scoreDisplay = new ScoreDisplay();
 },
 spawnTetromino: function() {
+GameState.linesCleared = 0;
+scoreDisplay.updateLinesCleared(GameState.linesCleared);
 var type = this.nextTetrominoType != null ? this.nextTetrominoType : this.tetrominoTypes[Math.floor(Math.random() * this.tetrominoTypes.length)];
 this.nextTetrominoType = this.tetrominoTypes[Math.floor(Math.random() * this.tetrominoTypes.length)];
 this.currentTetromino = new Tetromino();
 this.currentTetromino.create(type);