您现在的位置：程式碼之家 >> 編程語言 > >> Java 程式設計 >> Java 程式設計入門

貪吃蛇遊戲 MIDP 核心算法實現詳解

編輯：Java 程式設計入門

專案背景與核心思路

諾基亞經典貪吃蛇遊戲承載了無數人的手機遊戲啟蒙記憶。遊戲規則簡單：玩家控制蛇在迷宮中移動，吃到食物身體變長，撞牆或撞到自身即遊戲結束。要在 J2ME (MIDP) 平台實現此遊戲，關鍵在於設計高效的蛇身數據結構與移動算法。本文提供一個可擴展的核心實現參考，包含三個核心類別：SnakeMIDlet、SnakeCanvas、Snake。

核心類別設計

1. SnakeMIDlet：MIDlet 入口類別

負責初始化顯示並啟動遊戲畫布：

public class SnakeMIDlet extends MIDlet {
    protected void startApp() throws MIDletStateChangeException {
        Display.getDisplay(this).setCurrent(new SnakeCanvas());
    }
    protected void pauseApp() {}
    protected void destroyApp(boolean unconditional) throws MIDletStateChangeException {}
}

2. SnakeCanvas：遊戲畫布與主迴圈

繼承 Canvas 並實現 Runnable，包含繪製、遊戲迴圈與按鍵處理：

public class SnakeCanvas extends Canvas implements Runnable {
    Snake snake = new Snake();

    public SnakeCanvas() {
        snake.init();
        new Thread(this).start();
    }

    protected void paint(Graphics g) {
        g.setColor(0);
        g.fillRect(0, 0, getWidth(), getHeight()); // 清屏
        snake.paint(g);
    }

    public void run() {
        while (true) {
            snake.move();
            repaint();
            try { Thread.sleep(50); } catch (InterruptedException e) { e.printStackTrace(); }
        }
    }

    protected void keyPressed(int keyCode) {
        int action = getGameAction(keyCode);
        switch (action) {
            case Canvas.UP:    snake.breakInto(1); break;
            case Canvas.DOWN:  snake.breakInto(3); break;
            case Canvas.LEFT:  snake.breakInto(4); break;
            case Canvas.RIGHT: snake.breakInto(2); break;
        }
    }
}

3. Snake：蛇身核心邏輯

使用 Vector 存儲蛇身各段，每段以 int[4] 表示：[x, y, direction, length]。方向編碼：1=上、2=右、3=下、4=左。

初始化

public void init() {
    int[] head = {10, 10, 2, 50}; // 起始位置 (10,10)，向右，長度 50
    sections.addElement(head);
}

繪製邏輯

public synchronized void paint(Graphics g) {
    if (sections.isEmpty()) return;
    g.setColor(0, 255, 0); // 綠色蛇身
    for (int i = 0; i < sections.size(); i++) {
        int[] sec = (int[]) sections.elementAt(i);
        switch (sec[2]) {
            case 1: g.drawLine(sec[0], sec[1], sec[0], sec[1] - sec[3]); break; // 上
            case 2: g.drawLine(sec[0], sec[1], sec[0] + sec[3], sec[1]); break; // 右
            case 3: g.drawLine(sec[0], sec[1], sec[0], sec[1] + sec[3]); break; // 下
            case 4: g.drawLine(sec[0], sec[1], sec[0] - sec[3], sec[1]); break; // 左
        }
    }
}

移動算法核心：蛇頭增長、蛇尾縮短

public synchronized void move() {
    if (sections.isEmpty()) return;
    int[] tail = (int[]) sections.elementAt(sections.size() - 1);
    int[] head = (int[]) sections.elementAt(0);

    // 移動蛇尾起點
    switch (tail[2]) {
        case 1: tail[1]--; break;
        case 2: tail[0]++; break;
        case 3: tail[1]++; break;
        case 4: tail[0]--; break;
    }
    tail[3]--; // 蛇尾長度 -1
    head[3]++; // 蛇頭長度 +1

    // 蛇尾長度歸零則移除該段
    if (tail[3] <= 0) sections.removeElement(tail);
}

轉向邏輯：在蛇頭插入新段

public synchronized void breakInto(int dir) {
    if (sections.isEmpty()) return;
    int[] head = (int[]) sections.elementAt(0);
    if (dir == head[2]) return; // 同方向無操作

    int[] newHead = new int[4];
    newHead[2] = dir;
    newHead[3] = 0; // 新段初始長度為 0

    // 根據舊蛇頭方向計算新蛇頭起始座標
    switch (head[2]) {
        case 1: newHead[0] = head[0]; newHead[1] = head[1] - head[3]; break;
        case 2: newHead[0] = head[0] + head[3]; newHead[1] = head[1]; break;
        case 3: newHead[0] = head[0]; newHead[1] = head[1] + head[3]; break;
        case 4: newHead[0] = head[0] - head[3]; newHead[1] = head[1]; break;
    }
    sections.insertElementAt(newHead, 0); // 插入為新蛇頭
}