写一个简单的程序

hummhumm

已于 2024-05-13 15:01:03 修改

阅读量6.4k

点赞数 36

文章标签： python 算法开发语言 java json javascript maven

于 2024-04-30 11:55:37 首次发布

本文链接：https://blog.csdn.net/hummhumm/article/details/138340808

版权

思路分析：

1. 导入必要的库

首先，确保你的项目中包含了AWT或Swing库，因为我们将使用它们来创建图形界面。

import javax.swing.*;
import java.awt.*;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.util.Random;

2. 定义方块形状

俄罗斯方块由几种基本形状（称为tetrominoes）组成，每种形状有4个单元格。

enum Tetromino {
    I(new int[][]{{1, 1, 1, 1}}),
    O(new int[][]{{1, 1}, {1, 1}}),
    T(new int[][]{{0, 1, 0}, {1, 1, 1}}),
    // ... 其他形状如L, J, S, Z
    ;

    int[][] shape;

    Tetromino(int[][] shape) {
        this.shape = shape;
    }
}

3. 游戏面板类

创建一个GamePanel类，它继承自JPanel，并将处理游戏的主要逻辑。

public class GamePanel extends JPanel implements ActionListener {

    private static final int BOARD_WIDTH = 10;
    private static final int BOARD_HEIGHT = 20;
    private int[][] board = new int[BOARD_HEIGHT][BOARD_WIDTH];
    private Tetromino currentTetromino;
    private int currentX, currentY;
    private Timer timer;
    private Random random = new Random();

    public GamePanel() {
        initBoard();
        currentTetromino = getRandomTetromino();
        currentX = BOARD_WIDTH / 2 - currentTetromino.shape[0].length / 2;
        currentY = 0;

        timer = new Timer(500, this);
        timer.start();
    }

    private void initBoard() {
        // 初始化游戏面板，通常全部设为0表示空白
        for (int[] row : board) {
            Arrays.fill(row, 0);
        }
    }

    private Tetromino getRandomTetromino() {
        return Tetromino.values()[random.nextInt(Tetromino.values().length)];
    }

    @Override
    protected void paintComponent(Graphics g) {
        super.paintComponent(g);
        drawBoard(g);
        drawTetromino(g);
    }

    private void drawBoard(Graphics g) {
        // 绘制游戏面板
        for (int i = 0; i < BOARD_HEIGHT; ++i) {
            for (int j = 0; j < BOARD_WIDTH; ++j) {
                if (board[i][j] != 0) {
                    g.setColor(Color.BLUE);
                    g.fillRect(j * 20, i * 20, 20, 20);
                }
            }
        }
    }

    private void drawTetromino(Graphics g) {
        // 绘制当前方块
        Color color = Color.RED; // 为了简化，所有方块都用红色
        for (int i = 0; i < currentTetromino.shape.length; ++i) {
            for (int j = 0; j < currentTetromino.shape[i].length; ++j) {
                if (currentTetromino.shape[i][j] != 0) {
                    g.setColor(color);
                    g.fillRect((currentX + j) * 20, (currentY + i) * 20, 20, 20);
                }
            }
        }
    }

    @Override
    public void actionPerformed(ActionEvent e) {
        moveDown();
        repaint();
    }

    private void moveDown() {
        if (!isCollision(0, 1)) {
            currentY++;
        } else {
            // 碰撞处理，将当前方块固定到板上并生成新的方块
            fixTetromino();
            currentTetromino = getRandomTetromino();
            currentX = BOARD_WIDTH / 2 - currentTetromino.shape[0].length / 2;
            currentY = 0;

            if (isCollision(0, 0)) {
                // 如果新方块直接碰撞，游戏结束
                timer.stop();
            }
        }
    }

    // 碰撞检测函数，判断下一个位置是否可移动
    private boolean isCollision(int offsetX, int offsetY) {
        // 实现碰撞检测逻辑...
    }

    // 将当前方块固定到游戏面板上
    private void fixTetromino() {
        // 实现方块固定的逻辑...
    }

    // 添加键盘控制逻辑以移动和旋转方块...
}

// 主类用于启动游戏
public class TetrisGame {

    public static void main(String[] args) {
        JFrame frame = new JFrame("Java Tetris");
        frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        GamePanel gamePanel = new GamePanel();
        frame.add(gamePanel);
        frame.pack();
        frame.setVisible(true);
    }
}

方块旋转

为方块添加旋转逻辑，这需要一个方法来旋转当前方块，并检查旋转后是否与已固定的方块或边界发生碰撞。

private void rotateTetromino() {
    int[][] rotatedShape = new int[currentTetromino.shape[0].length][currentTetromino.shape.length];
    for (int i = 0; i < currentTetromino.shape.length; i++) {
        for (int j = 0; j < currentTetromino.shape[i].length; j++) {
            rotatedShape[j][currentTetromino.shape.length - i - 1] = currentTetromino.shape[i][j];
        }
    }
    
    if (!isCollision(0, 0, rotatedShape)) {
        currentTetromino.shape = rotatedShape;
    }
}

注意，isCollision方法需要更新以接受旋转后的形状作为参数进行碰撞检测。

精确的碰撞检测

在isCollision方法中，你需要遍历方块的所有单元格，检查每个单元格下移或旋转后的位置是否超出边界或与已固定的方块重叠。

private boolean isCollision(int offsetX, int offsetY, int[][] shape) {
    for (int i = 0; i < shape.length; i++) {
        for (int j = 0; j < shape[i].length; j++) {
            if (shape[i][j] != 0) {
                int newX = currentX + j + offsetX;
                int newY = currentY + i + offsetY;
                
                // 检查是否超出边界
                if (newY >= BOARD_HEIGHT || newX < 0 || newX >= BOARD_WIDTH) {
                    return true;
                }
                
                // 检查是否与已固定的方块重叠
                if (newY < BOARD_HEIGHT && board[newY][newX] != 0) {
                    return true;
                }
            }
        }
    }
    return false;
}

得分系统

当一行或多行被填满时，应清除这些行并给玩家加分。实现这一逻辑通常涉及检查每一行，如果某行全为非零值，则视为完成行，并从面板中移除，同时让上方的行下落。

用户输入处理

为了响应用户的键盘操作（例如左右移动、旋转、加速下落），你需要覆盖keyPressed事件。这里以Swing为例，你可能需要将GamePanel也实现KeyListener接口，并重写相关方法。

public class GamePanel extends JPanel implements ActionListener, KeyListener {
    // ...
    
    public GamePanel() {
        // ...
        addKeyListener(this);
        setFocusable(true);
    }

    @Override
    public void keyPressed(KeyEvent e) {
        switch (e.getKeyCode()) {
            case KeyEvent.VK_LEFT:
                moveLeft();
                break;
            case KeyEvent.VK_RIGHT:
                moveRight();
                break;
            case KeyEvent.VK_DOWN:
                moveDownFast(); // 快速下落
                break;
            case KeyEvent.VK_UP:
                rotateTetromino();
                break;
            // 添加其他按键处理...
        }
    }

    // 实现moveLeft, moveRight, moveDownFast等方法
    // ...
}

移动方块：向左和向右

private void moveLeft() {
    if (!isCollision(-1, 0)) {
        currentX--;
    }
}

private void moveRight() {
    if (!isCollision(1, 0)) {
        currentX++;
    }
}

快速下落

为了允许玩家通过按住向下键使方块快速下落，我们可以添加一个moveDownFast方法，该方法直接将方块移到下一个可能的位置，而不是等待计时器触发的自然下落。

private void moveDownFast() {
    while (!isCollision(0, 1)) {
        currentY++;
    }
    // 确保方块不会穿过已经固定的方块
    currentY--;
}

行消除与得分

实现一个方法来检查并消除满行，然后更新分数。每当一行或多行被消除时，上面的行应下移。

private void checkAndClearLines() {
    int linesCleared = 0;
    for (int i = BOARD_HEIGHT - 1; i >= 0; i--) {
        boolean isFullLine = true;
        for (int j = 0; j < BOARD_WIDTH; j++) {
            if (board[i][j] == 0) {
                isFullLine = false;
                break;
            }
        }
        if (isFullLine) {
            // 清除这一行
            for (int k = i; k > 0; k--) {
                System.arraycopy(board[k-1], 0, board[k], 0, BOARD_WIDTH);
            }
            Arrays.fill(board[0], 0); // 顶部行清空
            linesCleared++;
        }
    }
    // 根据消除的行数更新分数
    score += calculateScore(linesCleared);
}

private int calculateScore(int lines) {
    // 示例分数计算逻辑，可根据实际情况调整
    switch (lines) {
        case 1: return 100;
        case 2: return 300;
        case 3: return 700;
        case 4: return 1500;
        default: return 0;
    }
}

显示分数

在paintComponent方法中添加显示分数的逻辑。

@Override
protected void paintComponent(Graphics g) {
    super.paintComponent(g);
    drawBoard(g);
    drawTetromino(g);
    
    // 显示分数
    Font font = new Font("Arial", Font.BOLD, 16);
    g.setFont(font);
    g.setColor(Color.WHITE);
    g.drawString("Score: " + score, 10, 20);
}

完整性检查

确保在initBoard、rotateTetromino、fixTetromino等关键点更新或使用score变量时，score已被正确定义为类成员变量。

至此，我们已经概述了实现一个基本但完全可玩的俄罗斯方块游戏的关键步骤。当然，还有许多可以优化和扩展的地方，比如增强用户界面、增加音效、实现更复杂的游戏模式等。希望这个指南能为你开发自己的俄罗斯方块游戏提供一个良好的起点。不断实验和学习，享受编程的乐趣！

动画和流畅度优化

为了使游戏看起来更加流畅，可以引入游戏循环的概念，用一个定时器控制游戏的帧率，而不是仅仅依赖于方块下落的计时器。这使得即使方块静止时，游戏画面也能保持动态更新，如背景动画或预览下一个方块。

// 在构造函数中添加一个游戏循环的Timer
gameLoopTimer = new Timer(1000 / DESIRED_FRAMES_PER_SECOND, this);
gameLoopTimer.start();

记得要实现ActionListener接口，并在其中处理游戏循环的逻辑，比如重绘屏幕、检测用户输入等。

预览下一个方块

玩家通常希望看到下一个即将出现的方块。可以在游戏界面的一角添加一个预览区域。

private void drawNextTetromino(Graphics g) {
    // 计算预览区域的位置
    int previewX = BOARD_WIDTH * BLOCK_SIZE + 20;
    int previewY = 20;

    g.setColor(Color.LIGHT_GRAY);
    g.fillRect(previewX, previewY, NEXT_PREVIEW_COLS * BLOCK_SIZE, NEXT_PREVIEW_ROWS * BLOCK_SIZE);

    // 绘制下一个形状
    Tetromino nextTetromino = tetrominoQueue.peek();
    if (nextTetromino != null) {
        for (int i = 0; i < Tetromino.SHAPES[nextTetromino.getType()].length; i++) {
            for (int j = 0; j < Tetromino.SHAPES[nextTetromino.getType()][i].length; j++) {
                if (Tetromino.SHAPES[nextTetromino.getType()][i][j] != 0) {
                    g.setColor(nextTetromino.getColor());
                    g.fillRect((previewX + j * BLOCK_SIZE), (previewY + i * BLOCK_SIZE), BLOCK_SIZE, BLOCK_SIZE);
                }
            }
        }
    }
}

别忘了在paintComponent方法中调用drawNextTetromino(g)。

音效和音乐

音效可以极大地增强游戏体验。你可以添加简单的音频文件播放功能，当方块放置、消除行或游戏结束时播放相应的音效。

游戏结束逻辑

实现游戏结束的条件检查，并提供重新开始游戏的选项。

private boolean isGameOver() {
    // 检查新方块是否在初始位置就碰撞
    Tetromino nextTetromino = tetrominoQueue.poll();
    nextTetromino.setX(currentX);
    nextTetromino.setY(currentY);
    if (isCollision(0, 0, nextTetromino)) {
        tetrominoQueue.offer(nextTetromino); // 将方块放回队列，以便重新开始游戏时使用
        return true;
    } else {
        tetrominoQueue.offer(nextTetromino); // 若没有碰撞，将方块重新放回队列顶端
    }
    return false;
}

用户界面改进

暂停功能：实现一个暂停按钮或快捷键，暂停和恢复游戏计时器。
速度递增：随着玩家消除的行数增加，逐渐加快方块下落的速度，提高挑战性。
高分记录：保存并显示高分，激励玩家不断尝试打破记录。

性能和代码结构优化

代码重构：确保代码模块化，易于阅读和维护。例如，可以将绘制逻辑、碰撞检测等分离到不同的方法中。
优化图形处理：考虑使用双缓冲技术减少闪烁，尤其是在进行大量图形更新时。

这些额外的功能和优化不仅能使游戏更加完整，还能显著提升玩家的游戏体验。希望这些建议能够激发你对项目进一步探索的兴趣！

动画和流畅度优化具体实现

首先，你需要确保游戏有一个稳定且流畅的游戏循环。这不仅仅关乎方块的下落，还包括整个游戏界面的实时更新，比如响应用户输入、更新分数显示等。

步骤:

定义常量：确定你想要的每秒帧数（FPS）。例如，设 DESIRED_FRAMES_PER_SECOND 为60。

初始化游戏循环计时器：在你的游戏类的构造函数中，创建一个新的 javax.swing.Timer 对象来驱动游戏循环。

import javax.swing.Timer;

private final int DESIRED_FRAMES_PER_SECOND = 60;
private Timer gameLoopTimer;

public GamePanel() {
    // 初始化代码...
    
    // 添加游戏循环的定时器
    gameLoopTimer = new Timer(1000 / DESIRED_FRAMES_PER_SECOND, e -> {
        // 游戏循环逻辑
        repaint(); // 重绘面板以触发绘图更新
        checkForInput(); // 检查用户输入
        updateGameLogic(); // 更新游戏状态
    });
    gameLoopTimer.start(); // 启动计时器
}

实现游戏逻辑更新方法：在 updateGameLogic() 方法中，处理方块的自动下落、得分计算等游戏核心逻辑。
重绘面板：确保你的 paintComponent(Graphics g) 方法已经正确实现，用于绘制游戏状态。通过在游戏循环中调用 repaint() 来触发重绘。
预览下一个方块

绘制预览区域

在游戏面板上开辟一块区域用于展示下一个即将下落的方块，增加游戏的策略性。

实现方法:
定义预览区域坐标：在 paintComponent(Graphics g) 方法内，定义预览区域的左上角坐标。

绘制预览方块：调用一个新的方法 drawNextTetromino(Graphics g) 来绘制下一个方块。

private void drawNextTetromino(Graphics g) {
    int previewX = BOARD_WIDTH * BLOCK_SIZE + 20; // 假定BOARD_WIDTH是游戏板宽度
    int previewY = 20; // 预览区域的起始Y坐标
    
    // 绘制预览区背景
    g.setColor(Color.LIGHT_GRAY);
    g.fillRect(previewX, previewY, NEXT_PREVIEW_COLS * BLOCK_SIZE, NEXT_PREVIEW_ROWS * BLOCK_SIZE);
    
    // 获取并绘制下一个方块
    Tetromino nextTetromino = tetrominoQueue.peek();
    if (nextTetromino != null) {
        // 省略绘制逻辑，与之前示例类似，但要注意调整位置使其适合预览区域
    }
}