game.js

class Game2048 {
    constructor() {
        this.size = 4;
        this.grid = [];
        this.score = 0;
        this.gameOver = false;
    }

    init() {
        // Создаем пустую сетку 4x4
        this.grid = [
            [0, 0, 0, 0],
            [0, 0, 0, 0],
            [0, 0, 0, 0],
            [0, 0, 0, 0]
        ];
        this.score = 0;
        this.gameOver = false;
        
        // Добавляем две начальные плитки
        this.addNewTile();
        this.addNewTile();
        
        // Обновляем отображение
        this.updateBoard();
        this.updateScore();
    }

    addNewTile() {
        // Находим все пустые клетки
        const emptyCells = [];
        for (let row = 0; row < this.size; row++) {
            for (let col = 0; col < this.size; col++) {
                if (this.grid[row][col] === 0) {
                    emptyCells.push({ row, col });
                }
            }
        }
        
        // Если есть пустые клетки, добавляем новую плитку
        if (emptyCells.length > 0) {
            const randomCell = emptyCells[Math.floor(Math.random() * emptyCells.length)];
            // 90% вероятность получить 2, 10% - 4
            this.grid[randomCell.row][randomCell.col] = Math.random() < 0.9 ? 2 : 4;
        }
    }

    // Движение влево
    moveLeft() {
        let moved = false;
        
        for (let row = 0; row < this.size; row++) {
            // Получаем все непустые значения в строке
            let values = this.grid[row].filter(val => val !== 0);
            
            // Объединяем соседние одинаковые значения
            for (let i = 0; i < values.length - 1; i++) {
                if (values[i] === values[i + 1]) {
                    values[i] *= 2;
                    this.score += values[i];
                    values.splice(i + 1, 1);
                    moved = true;
                }
            }
            
            // Заполняем оставшиеся места нулями справа
            while (values.length < this.size) {
                values.push(0);
            }
            
            // Проверяем, изменилась ли строка
            for (let col = 0; col < this.size; col++) {
                if (this.grid[row][col] !== values[col]) {
                    moved = true;
                }
                this.grid[row][col] = values[col];
            }
        }
        
        return moved;
    }

    // Движение вправо
    moveRight() {
        let moved = false;
        
        for (let row = 0; row < this.size; row++) {
            // Получаем все непустые значения в строке (в обратном порядке)
            let values = this.grid[row].filter(val => val !== 0).reverse();
            
            // Объединяем соседние одинаковые значения
            for (let i = 0; i < values.length - 1; i++) {
                if (values[i] === values[i + 1]) {
                    values[i] *= 2;
                    this.score += values[i];
                    values.splice(i + 1, 1);
                    moved = true;
                }
            }
            
            // Заполняем оставшиеся места нулями слева и возвращаем порядок
            while (values.length < this.size) {
                values.push(0);
            }
            values = values.reverse();
            
            // Проверяем, изменилась ли строка
            for (let col = 0; col < this.size; col++) {
                if (this.grid[row][col] !== values[col]) {
                    moved = true;
                }
                this.grid[row][col] = values[col];
            }
        }
        
        return moved;
    }

    // Движение вверх
    moveUp() {
        let moved = false;
        
        for (let col = 0; col < this.size; col++) {
            // Получаем все непустые значения в колонке
            let values = [];
            for (let row = 0; row < this.size; row++) {
                if (this.grid[row][col] !== 0) {
                    values.push(this.grid[row][col]);
                }
            }
            
            // Объединяем соседние одинаковые значения
            for (let i = 0; i < values.length - 1; i++) {
                if (values[i] === values[i + 1]) {
                    values[i] *= 2;
                    this.score += values[i];
                    values.splice(i + 1, 1);
                    moved = true;
                }
            }
            
            // Заполняем оставшиеся места нулями снизу
            while (values.length < this.size) {
                values.push(0);
            }
            
            // Записываем значения обратно в колонку
            for (let row = 0; row < this.size; row++) {
                if (this.grid[row][col] !== values[row]) {
                    moved = true;
                }
                this.grid[row][col] = values[row];
            }
        }
        
        return moved;
    }

    // Движение вниз
    moveDown() {
        let moved = false;
        
        for (let col = 0; col < this.size; col++) {
            // Получаем все непустые значения в колонке (снизу вверх)
            let values = [];
            for (let row = this.size - 1; row >= 0; row--) {
                if (this.grid[row][col] !== 0) {
                    values.push(this.grid[row][col]);
                }
            }
            
            // Объединяем соседние одинаковые значения
            for (let i = 0; i < values.length - 1; i++) {
                if (values[i] === values[i + 1]) {
                    values[i] *= 2;
                    this.score += values[i];
                    values.splice(i + 1, 1);
                    moved = true;
                }
            }
            
            // Заполняем оставшиеся места нулями сверху
            while (values.length < this.size) {
                values.push(0);
            }
            
            // Записываем значения обратно в колонку (снизу вверх)
            for (let row = this.size - 1; row >= 0; row--) {
                const valueIndex = this.size - 1 - row;
                if (this.grid[row][col] !== values[valueIndex]) {
                    moved = true;
                }
                this.grid[row][col] = values[valueIndex];
            }
        }
        
        return moved;
    }

    // Основной метод движения
    move(direction) {
        if (this.gameOver) return false;

        let moved = false;
        
        // Выбираем направление движения
        switch(direction) {
            case 'left':
                moved = this.moveLeft();
                break;
            case 'right':
                moved = this.moveRight();
                break;
            case 'up':
                moved = this.moveUp();
                break;
            case 'down':
                moved = this.moveDown();
                break;
        }

        // Если было движение, добавляем новую плитку и проверяем состояние
        if (moved) {
            this.addNewTile();
            this.updateBoard();
            this.updateScore();
            this.checkGameOver();
        }

        return moved;
    }

    // Проверка на окончание игры
    checkGameOver() {
        // Проверяем пустые клетки
        for (let row = 0; row < this.size; row++) {
            for (let col = 0; col < this.size; col++) {
                if (this.grid[row][col] === 0) {
                    return false; // Есть пустые клетки - игра продолжается
                }
            }
        }
        
        // Проверяем возможность объединения по горизонтали
        for (let row = 0; row < this.size; row++) {
            for (let col = 0; col < this.size - 1; col++) {
                if (this.grid[row][col] === this.grid[row][col + 1]) {
                    return false; // Можно объединить по горизонтали
                }
            }
        }
        
        // Проверяем возможность объединения по вертикали
        for (let row = 0; row < this.size - 1; row++) {
            for (let col = 0; col < this.size; col++) {
                if (this.grid[row][col] === this.grid[row + 1][col]) {
                    return false; // Можно объединить по вертикали
                }
            }
        }
        
        // Если дошли сюда - игра окончена
        this.gameOver = true;
        this.showGameOver();
        return true;
    }

    showGameOver() {
        setTimeout(() => {
            alert('Игра окончена! Ваш счёт: ' + this.score);
        }, 100);
    }

    updateBoard() {
        const board = document.getElementById('game-board');
        if (!board) return;
        
        board.innerHTML = '';
        
        for (let row = 0; row < this.size; row++) {
            for (let col = 0; col < this.size; col++) {
                const cell = document.createElement('div');
                cell.className = 'grid-cell';
                const value = this.grid[row][col];
                
                if (value !== 0) {
                    cell.textContent = value;
                    cell.classList.add(`cell-${value}`);
                }
                
                board.appendChild(cell);
            }
        }
    }

    updateScore() {
        const scoreElement = document.getElementById('score');
        if (scoreElement) {
            scoreElement.textContent = this.score;
        }
    }
}