java编写2048游戏

好的，我可以为您提供一个简单的 Java 实现版本，以下是代码：

import java.util.Random;
import java.util.Scanner;

public class Game2048 {

    private final int SIZE = 4;
    private int[][] board;
    private int score;
    private Random random;

    public Game2048() {
        board = new int[SIZE][SIZE];
        random = new Random();
        addRandom();
        addRandom();
    }

    public void play() {
        while (true) {
            printBoard();
            if (checkGameOver()) {
                System.out.println("Game over! Your score is " + score);
                break;
            }
            System.out.print("Enter direction (W/A/S/D): ");
            Scanner scanner = new Scanner(System.in);
            String input = scanner.nextLine().toUpperCase();
            boolean moved = false;
            switch (input) {
                case "W":
                    moved = moveUp();
                    break;
                case "A":
                    moved = moveLeft();
                    break;
                case "S":
                    moved = moveDown();
                    break;
                case "D":
                    moved = moveRight();
                    break;
            }
            if (moved) {
                addRandom();
            } else {
                System.out.println("Invalid move! Try again.");
            }
        }
    }

    private boolean moveUp() {
        boolean moved = false;
        for (int j = 0; j < SIZE; j++) {
            for (int i = 1; i < SIZE; i++) {
                if (board[i][j] != 0) {
                    int k = i;
                    while (k > 0 && board[k - 1][j] == 0) {
                        k--;
                    }
                    if (k != i) {
                        board[k][j] = board[i][j];
                        board[i][j] = 0;
                        moved = true;
                    }
                    if (k > 0 && board[k - 1][j] == board[k][j]) {
                        board[k - 1][j] *= 2;
                        score += board[k - 1][j];
                        board[k][j] = 0;
                        moved = true;
                    }
                }
            }
        }
        return moved;
    }

    private boolean moveLeft() {
        boolean moved = false;
        for (int i = 0; i < SIZE; i++) {
            for (int j = 1; j < SIZE; j++) {
                if (board[i][j] != 0) {
                    int k = j;
                    while (k > 0 && board[i][k - 1] == 0) {
                        k--;
                    }
                    if (k != j) {
                        board[i][k] = board[i][j];
                        board[i][j] = 0;
                        moved = true;
                    }
                    if (k > 0 && board[i][k - 1] == board[i][k]) {
                        board[i][k - 1] *= 2;
                        score += board[i][k - 1];
                        board[i][k] = 0;
                        moved = true;
                    }
                }
            }
        }
        return moved;
    }

    private boolean moveDown() {
        boolean moved = false;
        for (int j = 0; j < SIZE; j++) {
            for (int i = SIZE - 2; i >= 0; i--) {
                if (board[i][j] != 0) {
                    int k = i;
                    while (k < SIZE - 1 && board[k + 1][j] == 0) {
                        k++;
                    }
                    if (k != i) {
                        board[k][j] = board[i][j];
                        board[i][j] = 0;
                        moved = true;
                    }
                    if (k < SIZE - 1 && board[k + 1][j] == board[k][j]) {
                        board[k + 1][j] *= 2;
                        score += board[k + 1][j];
                        board[k][j] = 0;
                        moved = true;
                    }
                }
            }
        }
        return moved;
    }

    private boolean moveRight() {
        boolean moved = false;
        for (int i = 0; i < SIZE; i++) {
            for (int j = SIZE - 2; j >= 0; j--) {
                if (board[i][j] != 0) {
                    int k = j;
                    while (k < SIZE - 1 && board[i][k + 1] == 0) {
                        k++;
                    }
                    if (k != j) {
                        board[i][k] = board[i][j];
                        board[i][j] = 0;
                        moved = true;
                    }
                    if (k < SIZE - 1 && board[i][k + 1] == board[i][k]) {
                        board[i][k + 1] *= 2;
                        score += board[i][k + 1];
                        board[i][k] = 0;
                        moved = true;
                    }
                }
            }
        }
        return moved;
    }

    private void addRandom() {
        int x = random.nextInt(SIZE);
        int y = random.nextInt(SIZE);
        while (board[x][y] != 0) {
            x = random.nextInt(SIZE);
            y = random.nextInt(SIZE);
        }
        board[x][y] = random.nextInt(2) == 0 ? 2 : 4;
    }

    private boolean checkGameOver() {
        for (int i = 0; i < SIZE; i++) {
            for (int j = 0; j < SIZE; j++) {
                if (board[i][j] == 0) {
                    return false;
                }
                if (i > 0 && board[i][j] == board[i - 1][j]) {
                    return false;
                }
                if (j > 0 && board[i][j] == board[i][j - 1]) {
                    return false;
                }
            }
        }
        return true;
    }

    private void printBoard() {
        System.out.println("Score: " + score);
        for (int i = 0; i < SIZE; i++) {
            for (int j = 0; j < SIZE; j++) {
                System.out.print(board[i][j] + "\t");
            }
            System.out.println();
        }
    }

    public static void main(String[] args) {
        Game2048 game = new Game2048();
        game.play();
    }
}

这个实现使用了一个 4x4 的二维数组来表示游戏棋盘，然后通过键盘输入来控制方向，使用了随机数生成器来添加新的方块，还有一个计分器来计算玩家的得分。在玩家输入方向后，会调用相应的移动方法，如果移动成功，则会添加新的方块。如果无法移动，则会提示玩家尝试其他方向。游戏会在无法移动或者达到 2048 分时结束。