2048小游戏 java版（代码+注释）

已于 2022-09-09 22:04:08 修改
阅读量8.5k 收藏 197
点赞数 32
文章标签： java
于 2022-08-28 14:39:40 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_54262820/article/details/126531655
版权

        一个纯纯小白，想写点什么，也想学习一下怎么在这里写东西，就简单的写个2048小游戏。写的不好，大佬就不用看了，希望和大家交流学习，有写的不好或有更好的建议也欢迎提出来。（需要用的可直接粘贴复制）（轻喷）

目录

游戏展示

讲解 

代码

游戏展示

        基本上做到了和手机上一样。 我会按照我的思路为大家讲解一下，有需要的可以看看，想直接看效果或者需要用的，可以直接滑倒最后粘贴复制。

讲解 

目录结构如下

 按照我自己的思路讲一下，可能有点乱。

        1.首先初始化一下画板，将不会改变的部分先完成。

private void initPaint(Graphics g) {
        //TODO 画方块所造区域
        g.setColor(new Color(192, 175, 159));
        g.fillRect(10, 120, 360 + 8, 360 + 8);

        //TODO 画得分区域以及说明区域
        g.setColor(new Color(209, 132, 102));
        g.fillRect(200, 15, 80, 50);
        g.fillRect(290, 15, 80, 50);

        g.setColor(Color.black);
        g.setFont(new Font("宋体", Font.BOLD, 20));
        g.drawString("得分", 220, 35);
        g.drawString("最高分", 300, 35);
        g.setFont(new Font("宋体", Font.BOLD, 35));
        g.drawString("游戏说明：", 15, 55);
        g.setFont(new Font("宋体", Font.BOLD, 20));
        g.drawString("按上下左右键控制;按空格键重新游戏", 15, 100);
        
        //画空白方块
        for (int i = 0; i < 4; i++) {
            for (int j = 0; j < 4; j++) {
                paintBlock(g, new Block(table[i][j]), j, i);
            }
        }
    }

         2.创建带有数字的方块，这里创建了一个block类，主要存储了，每种方块所显示的数字，数字颜色，背景颜色等属性。并且有一个setAllFont方法，来设置这些属性。

package game_2048;

import java.awt.*;

public class Block {

    int kind;
    Font wFont;
    Color wColor;
    Color bColor;
    String s;

    public Block(int kind) {
        this.kind = kind;
    }

    private final Font font1 = new Font("宋体", Font.BOLD, 46);
    private final Font font2 = new Font("宋体", Font.BOLD, 40);
    private final Font font3 = new Font("宋体", Font.BOLD, 34);
    private final Font font4 = new Font("宋体", Font.BOLD, 28);

    private final Color color1 = new Color(119,108,99);
    private final Color color2 = new Color(254,254,254);

    public void setAllFont() {
        switch (kind) {
            case 0 -> bColor = new Color(206, 194, 180);
            case 1 -> {
                wFont = font1;
                wColor = color1;
                bColor = new Color(237, 229, 218);
                s = 2 + "";
            }
            case 2 -> {
                wFont = font1;
                wColor = color1;
                bColor = new Color(237, 220, 190);
                s = 4 + "";
            }
            case 3 -> {
                wFont = font1;
                wColor = color1;
                bColor = new Color(242, 177, 123);
                s = 8 + "";
            }
            case 4 -> {
                wFont = font2;
                wColor = color2;
                bColor = new Color(246, 147, 92);
                s = 16 + "";
            }
            case 5 -> {
                wFont = font2;
                wColor = color2;
                bColor = new Color(245, 118, 86);
                s = 32 + "";
            }
            case 6 -> {
                wFont = font2;
                wColor = color2;
                bColor = new Color(245, 83, 45);
                s = 64 + "";
            }
            case 7 -> {
                wFont = font3;
                wColor = color2;
                bColor = new Color(237, 206, 115);
                s = 128 + "";
            }
            case 8 -> {
                wFont = font3;
                wColor = color2;
                bColor = new Color(230,209,81);
                s = 256 + "";
            }
            case 9 -> {
                wFont = font3;
                wColor = color2;
                bColor = new Color(207,163,12);
                s = 512 + "";
            }
            case 10 -> {
                wFont = font4;
                wColor = color2;
                bColor = new Color(229,180,6);
                s = 1024 + "";
            }
            case 11 -> {
                wFont = font4;
                wColor = color2;
                bColor = new Color(161,131,115);
                s = 2048 + "";
            }
            default -> {
            }
        }
    }

}

        3.绘制每个方块（这里在1里面已经用过了，当时是画空白的）

//画方块
    private void paintBlock(Graphics g, Block block, int x, int y) {
        block.setAllFont();
        g.setColor(block.bColor);
        g.fillRect(10 + x * 90 + 7, 120 + y * 90 + 7, 83, 83);
        if (block.kind > 0) {
            g.setColor(block.wColor);
            g.setFont(block.wFont);
            FontMetrics fm = getFontMetrics(block.wFont);
            String value = block.s;
            g.drawString(value,
                    10 + x * 90 + 7 + (83 - fm.stringWidth(value)) / 2,
                    120 + y * 90 + 7 + (83 - fm.getAscent() - fm.getDescent()) / 2 + fm.getAscent());
        }
    }

         4.初始化界面，包括分数，和最开始显示的方块。

        用random类来随机刷新方块存在的位置。

        这里的getS()和后面的setS()分别是读、取文件，为了显示最高分用。（这两个方法写了不是很好，就不讲了）

private void init() {
        isOver = false;

        source = 0;
        try {
            best = getS();
        } catch (IOException e) {
            throw new RuntimeException(e);
        }
        for (int i = 0; i < 4; i++) {
            for (int j = 0; j < 4; j++) {
                table[i][j] = 0;
            }
        }
        bX = rand1.nextInt(4);
        bY = rand2.nextInt(4);
        table[bX][bY] = 1;
    }

        5. 控制所有方块的移动。

        通过一系列控制语句，来决定是否能移动或者合并。我这里是为了做滑动的效果，可能写的有点啰嗦，反正能用就行吧。

private void bDown() {
        for (int j = 0; j <= 3; j++) {
            //第一个if是为了一种稍微特殊的地方
            //后面的每个方向都一样
            if (table[0][j] == table[1][j] && table[2][j] == table[3][j]
                    && table[0][j] != 0 && table[2][j] != 0) {
                table[1][j]++;
                table[0][j] = 0;
            }

            for (int i = 2; i >= 0; i--) {
                if (table[i + 1][j] == 0) {
                    table[i + 1][j] = table[i][j];
                    table[i][j] = 0;
                }
                if (table[i][j] != 0 && table[i][j] == table[i + 1][j]) {
                    if (c[j]) {
                        table[i + 1][j]++;
                        table[i][j] = 0;
                        c[j] = false;
                        source += (int) Math.pow(2, table[i + 1][j]);
                    }
                }
            }
        }
    }

        6.我这里是用线程的方法，来实现滑动的效果。

        每次按按键后，将改变fx的值，然后启动线程，每次会执行三次方块的移动，每次延迟40ms，依次来达到滑动的效果。

    @Override
    public void run() {
        for (int i = 0; i < 4; i++) {
            c[i] = true;
        }

        int[][] tt = new int[4][4];
        for (int i = 0; i < 4; i++) {
            for (int j = 0; j < 4; j++) {
                tt[i][j] = table[i][j];
            }
        }

        for (int k = 0; k < 3; k++) {
            switch (fx) {
                case 0 -> bUp();
                case 1 -> bRight();
                case 2 -> bDown();
                case 3 -> bLeft();
                default -> {
                }
            }
            try {
                Thread.sleep(40);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }

            if (best < source) {
                best = source;
                try {
                    setS(source);
                } catch (IOException ioException) {
                    ioException.printStackTrace();
                }

            }

            repaint();
        }

        isMove = false;
        loop:
        for (int i = 0; i < 4; i++) {
            for (int j = 0; j < 4; j++) {
                if (tt[i][j] != table[i][j]) {
                    isMove = true;
                    break loop;
                }
            }
        }
        randomBlock();
    }

        8.随机生成新的方块。 每次移动之后，就会随机产生新的方块，并且也在这里设置了结束的条件。

private void randomBlock() {
        v.clear();
        for (int i = 0; i < 4; i++) {
            for (int j = 0; j < 4; j++) {
                if (table[i][j] == 0) {
                    v.add(i);
                    v.add(j);
                }
            }
        }
        if (v.size() > 0 && isMove) {
            int kk = rand.nextInt(v.size() / 2);
            table[v.get(kk * 2)][v.get(kk * 2 + 1)] = (rand.nextInt(7) % 6 == 0) ? 2 : 1;
        }

        if (v.size() == 0) {
            boolean isSame = false;
            loop1:
            for (int i = 0; i < 3; i++) {
                for (int j = 0; j < 4; j++) {
                    if ((table[i][j] == table[i + 1][j]) || (table[j][i] == table[j][i + 1])) {
                        isSame = true;
                        break loop1;
                    }
                }
            }
            if (!isSame) {
                isOver = true;
                repaint();
            }
        }
    }

就这样吧，，，有啥问题也可以问，我也会回答。。。。。。

代码

best.txt

        best.txt主要用来记录最高得分，创建时候需要在里面存储个0，不然读取的时候会报错。

MPanel

        Panel类，主要的代码都在这个类里。 

package game_2048;

import javax.swing.*;
import java.awt.*;
import java.awt.event.*;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.util.Random;
import java.util.Vector;

public class MPanel extends JPanel implements KeyListener, Runnable {

    int[][] table = new int[4][4];

    int fx; //上下左右0123

    Random rand1 = new Random();
    Random rand2 = new Random();
    Random rand = new Random();

    int bX;
    int bY;

    Vector<Integer> v = new Vector<>();

    boolean isMove;

    boolean[] c = new boolean[4];

    int source = 0;
    int best;

    boolean isOver;

    public MPanel() {
        setFocusable(true);
        setBackground(new Color(241, 228, 219));
        this.addKeyListener(this);
        init();
    }

    private void init() {
        isOver = false;

        source = 0;
        try {
            best = getS();
        } catch (IOException e) {
            throw new RuntimeException(e);
        }
        for (int i = 0; i < 4; i++) {
            for (int j = 0; j < 4; j++) {
                table[i][j] = 0;
            }
        }
        bX = rand1.nextInt(4);
        bY = rand2.nextInt(4);
        table[bX][bY] = 1;
    }

    @Override
    public void paint(Graphics g) {
        super.paint(g);
        initPaint(g);


        g.setColor(Color.white);
        g.setFont(new Font("宋体", Font.BOLD, 25));
        FontMetrics fm = getFontMetrics(new Font("宋体", Font.BOLD, 20));
        String value1 = source + "";
        g.drawString(value1,
                195 + (80 - fm.stringWidth(value1)) / 2,
                30 + (50 - fm.getAscent() - fm.getDescent()) / 2 + fm.getAscent());
        String value2 = best + "";
        g.drawString(value2,
                285 + (80 - fm.stringWidth(value2)) / 2,
                30 + (50 - fm.getAscent() - fm.getDescent()) / 2 + fm.getAscent());

        if (isOver) {
            g.setColor(new Color(0, 0, 0, 0.5f));
            g.fillRect(0, 0, getWidth(), getHeight());
            g.setFont(new Font("宋体", Font.BOLD, 60));
            fm = getFontMetrics(new Font("宋体", Font.BOLD, 60));
            String value = "游戏结束";
            g.drawString(value,
                    (getWidth() - fm.stringWidth(value)) / 2,
                    (getHeight() - fm.getAscent() - fm.getDescent()) / 2 + fm.getAscent());
        }
    }

    //初始化画板
    private void initPaint(Graphics g) {
        //TODO 画方块所造区域
        g.setColor(new Color(192, 175, 159));
        g.fillRect(10, 120, 360 + 8, 360 + 8);

        //TODO 画得分区域以及说明区域
        g.setColor(new Color(209, 132, 102));
        g.fillRect(200, 15, 80, 50);
        g.fillRect(290, 15, 80, 50);

        g.setColor(Color.black);
        g.setFont(new Font("宋体", Font.BOLD, 20));
        g.drawString("得分", 220, 35);
        g.drawString("最高分", 300, 35);
        g.setFont(new Font("宋体", Font.BOLD, 35));
        g.drawString("游戏说明：", 15, 55);
        g.setFont(new Font("宋体", Font.BOLD, 20));
        g.drawString("按上下左右键控制;按空格键重新游戏", 15, 100);

        for (int i = 0; i < 4; i++) {
            for (int j = 0; j < 4; j++) {
                paintBlock(g, new Block(table[i][j]), j, i);
            }
        }
    }

    //画方块
    private void paintBlock(Graphics g, Block block, int x, int y) {
        block.setAllFont();
        g.setColor(block.bColor);
        g.fillRect(10 + x * 90 + 7, 120 + y * 90 + 7, 83, 83);
        if (block.kind > 0) {
            g.setColor(block.wColor);
            g.setFont(block.wFont);
            FontMetrics fm = getFontMetrics(block.wFont);
            String value = block.s;
            g.drawString(value,
                    10 + x * 90 + 7 + (83 - fm.stringWidth(value)) / 2,
                    120 + y * 90 + 7 + (83 - fm.getAscent() - fm.getDescent()) / 2 + fm.getAscent());
        }
    }

    @Override
    public void keyTyped(KeyEvent e) {

    }

    @Override
    public void keyPressed(KeyEvent e) {
        int keyCode = e.getKeyCode();
        if (!isOver) {
            Thread thread = new Thread(this);
            if (keyCode == KeyEvent.VK_DOWN) {
                fx = 2;
                thread.start();
            } else if (keyCode == KeyEvent.VK_UP) {
                fx = 0;
                thread.start();
            } else if (keyCode == KeyEvent.VK_RIGHT) {
                fx = 1;
                thread.start();
            } else if (keyCode == KeyEvent.VK_LEFT) {
                fx = 3;
                thread.start();
            }
        }
        if (keyCode == KeyEvent.VK_SPACE) {
            init();
        }
        repaint();
    }


    @Override
    public void keyReleased(KeyEvent e) {

    }

    @Override
    public void run() {
        for (int i = 0; i < 4; i++) {
            c[i] = true;
        }

        int[][] tt = new int[4][4];
        for (int i = 0; i < 4; i++) {
            for (int j = 0; j < 4; j++) {
                tt[i][j] = table[i][j];
            }
        }

        for (int k = 0; k < 3; k++) {
            switch (fx) {
                case 0 -> bUp();
                case 1 -> bRight();
                case 2 -> bDown();
                case 3 -> bLeft();
                default -> {
                }
            }
            try {
                Thread.sleep(40);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }

            if (best < source) {
                best = source;
                try {
                    setS(source);
                } catch (IOException ioException) {
                    ioException.printStackTrace();
                }

            }

            repaint();
        }

        isMove = false;
        loop:
        for (int i = 0; i < 4; i++) {
            for (int j = 0; j < 4; j++) {
                if (tt[i][j] != table[i][j]) {
                    isMove = true;
                    break loop;
                }
            }
        }
        randomBlock();
    }

    private void randomBlock() {
        v.clear();
        for (int i = 0; i < 4; i++) {
            for (int j = 0; j < 4; j++) {
                if (table[i][j] == 0) {
                    v.add(i);
                    v.add(j);
                }
            }
        }
        if (v.size() > 0 && isMove) {
            int kk = rand.nextInt(v.size() / 2);
            table[v.get(kk * 2)][v.get(kk * 2 + 1)] = (rand.nextInt(7) % 6 == 0) ? 2 : 1;
        }

        if (v.size() == 0) {
            boolean isSame = false;
            loop1:
            for (int i = 0; i < 3; i++) {
                for (int j = 0; j < 4; j++) {
                    if ((table[i][j] == table[i + 1][j]) || (table[j][i] == table[j][i + 1])) {
                        isSame = true;
                        break loop1;
                    }
                }
            }
            if (!isSame) {
                isOver = true;
                repaint();
            }
        }
    }

    private void bDown() {
        for (int j = 0; j <= 3; j++) {
            //第一个if是为了一种稍微特殊的地方
            //后面的每个方向都一样
            if (table[0][j] == table[1][j] && table[2][j] == table[3][j]
                    && table[0][j] != 0 && table[2][j] != 0) {
                table[1][j]++;
                table[0][j] = 0;
            }

            for (int i = 2; i >= 0; i--) {
                if (table[i + 1][j] == 0) {
                    table[i + 1][j] = table[i][j];
                    table[i][j] = 0;
                }
                if (table[i][j] != 0 && table[i][j] == table[i + 1][j]) {
                    if (c[j]) {
                        table[i + 1][j]++;
                        table[i][j] = 0;
                        c[j] = false;
                        source += (int) Math.pow(2, table[i + 1][j]);
                    }
                }
            }
        }
    }

    private void bLeft() {
        for (int i = 0; i <= 3; i++) {

            if (table[i][0] == table[i][1] && table[i][2] == table[i][3]
                    && table[i][0] != 0 && table[i][2] != 0) {
                table[i][2]++;
                table[i][3] = 0;
            }

            for (int j = 1; j <= 3; j++) {
                if (table[i][j - 1] == 0) {
                    table[i][j - 1] = table[i][j];
                    table[i][j] = 0;
                }
                if (table[i][j] != 0 && table[i][j] == table[i][j - 1]) {
                    if (c[i]) {
                        table[i][j - 1]++;
                        table[i][j] = 0;
                        c[i] = false;
                        source += (int) Math.pow(2, table[i][j - 1]);
                    }
                }
            }
        }
    }

    private void bRight() {
        for (int i = 0; i <= 3; i++) {

            if (table[i][0] == table[i][1] && table[i][2] == table[i][3]
                    && table[i][0] != 0 && table[i][2] != 0) {
                table[i][1]++;
                table[i][0] = 0;
            }

            for (int j = 2; j >= 0; j--) {
                if (table[i][j + 1] == 0) {
                    table[i][j + 1] = table[i][j];
                    table[i][j] = 0;
                }
                if (table[i][j] != 0 && table[i][j] == table[i][j + 1]) {
                    if (c[i]) {
                        table[i][j + 1]++;
                        table[i][j] = 0;
                        c[i] = false;
                        source += (int) Math.pow(2, table[i][j + 1]);
                    }
                }
            }
        }
    }

    private void bUp() {
        for (int j = 0; j <= 3; j++) {

            if (table[0][j] == table[1][j] && table[2][j] == table[3][j]
                    && table[0][j] != 0 && table[2][j] != 0) {
                table[2][j]++;
                table[3][j] = 0;
            }

            for (int i = 1; i <= 3; i++) {
                if (table[i - 1][j] == 0) {
                    table[i - 1][j] = table[i][j];
                    table[i][j] = 0;
                }
                if (table[i][j] != 0 && table[i][j] == table[i - 1][j]) {
                    if (c[j]) {
                        table[i - 1][j]++;
                        table[i][j] = 0;
                        c[j] = false;
                        source += (int) Math.pow(2, table[i - 1][j]);
                    }
                }
            }
        }
    }

    public int getS() throws IOException {
        String filePath = "src\\game_2048\\best.txt";
        FileReader fileReader = new FileReader(filePath);
        int data = 0;
        String s = "";
        while ((data = fileReader.read()) != -1) {
            s += (char) data;
        }
        int y = Integer.parseInt(s);
        fileReader.close();
        return y;
    }

    private void setS(int y) throws IOException {
        String filePath = "src\\game_2048\\best.txt";
        FileWriter fileWriter = new FileWriter(filePath);
        String yy = y + "";
        fileWriter.write(yy);
        fileWriter.close();
    }

}

Block 

        每个方块创建的类。 

package game_2048;

import java.awt.*;

public class Block {

    int kind;
    Font wFont;
    Color wColor;
    Color bColor;
    String s;

    public Block(int kind) {
        this.kind = kind;
    }

    private final Font font1 = new Font("宋体", Font.BOLD, 46);
    private final Font font2 = new Font("宋体", Font.BOLD, 40);
    private final Font font3 = new Font("宋体", Font.BOLD, 34);
    private final Font font4 = new Font("宋体", Font.BOLD, 28);

    private final Color color1 = new Color(119,108,99);
    private final Color color2 = new Color(254,254,254);

    public void setAllFont() {
        switch (kind) {
            case 0 -> bColor = new Color(206, 194, 180);
            case 1 -> {
                wFont = font1;
                wColor = color1;
                bColor = new Color(237, 229, 218);
                s = 2 + "";
            }
            case 2 -> {
                wFont = font1;
                wColor = color1;
                bColor = new Color(237, 220, 190);
                s = 4 + "";
            }
            case 3 -> {
                wFont = font1;
                wColor = color1;
                bColor = new Color(242, 177, 123);
                s = 8 + "";
            }
            case 4 -> {
                wFont = font2;
                wColor = color2;
                bColor = new Color(246, 147, 92);
                s = 16 + "";
            }
            case 5 -> {
                wFont = font2;
                wColor = color2;
                bColor = new Color(245, 118, 86);
                s = 32 + "";
            }
            case 6 -> {
                wFont = font2;
                wColor = color2;
                bColor = new Color(245, 83, 45);
                s = 64 + "";
            }
            case 7 -> {
                wFont = font3;
                wColor = color2;
                bColor = new Color(237, 206, 115);
                s = 128 + "";
            }
            case 8 -> {
                wFont = font3;
                wColor = color2;
                bColor = new Color(230,209,81);
                s = 256 + "";
            }
            case 9 -> {
                wFont = font3;
                wColor = color2;
                bColor = new Color(207,163,12);
                s = 512 + "";
            }
            case 10 -> {
                wFont = font4;
                wColor = color2;
                bColor = new Color(229,180,6);
                s = 1024 + "";
            }
            case 11 -> {
                wFont = font4;
                wColor = color2;
                bColor = new Color(161,131,115);
                s = 2048 + "";
            }
            default -> {
            }
        }
    }

}

MFrame

package game_2048;

/*
 *@author douhehe
 */

import javax.swing.*;

public class MFrame {
    public static void main(String[] args) {
        JFrame jf = new JFrame("2048小游戏");

        jf.add(new MPanel());

        jf.setSize(401,552);
        jf.setLocationRelativeTo(null);     //居中
        jf.setResizable(false);
        jf.setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE);
        jf.setVisible(true);
    }
}

逗呵呵
关注
  • 32
    点赞
  • 踩
  • 197
    收藏
    觉得还不错? 一键收藏
  • 9
    评论
Java实现2048小游戏，我竟然一盘都没赢，你们说我到底行不行？
编程界明世隐的博客
09-07 6581
作者简介 作者名：编程界明世隐 简介：CSDN博客专家，从事软件开发多年，精通Java、JavaScript，博主也是从零开始一步步把学习成长、深知学习和积累的重要性，喜欢跟广大ADC一起打野升级，欢迎您关注，期待与您一起学习、成长、起飞！ 系列目录 1. Java俄罗斯方块 2. Java五子棋小游戏 3. 老Java程序员花一天时间写了个飞机大战 4. Java植物大战僵尸 5. 老Java程序员花2天写了个连连看 6. Java消消乐（天天爱消除） 7. Java贪吃蛇小游戏 8. Java扫雷小
【经典例子】Java实现2048小游戏（附带源码）
m0_46013789的博客
02-05 1705
2048游戏是一款数字益智游戏，目标是通过合并相同数字的方块来达到2048这个目标。游戏在一个4x4的方格上进行，每个方格上都有一个数字（初始时为2或4）。玩家可以通过滑动方向键（上、下、左、右）来移动所有的方块，当两个相同数字的方块在移动过程中碰到一起时，它们会合并成一个数字的方块，数字为它们的和。每次滑动后，系统会在空白的方格上随机生成一个新的数字方块。游戏的目标是通过不断合并方块，最终得到一个数字为2048的方块。
《逃离塔科夫》：游戏突然走红的背后靠运气还是实力？
iqifenxia的博客
09-14 513
https://www.fgba.net/sitemap.xml
java课程设计大作业 2048小游戏（设计实现文档+源代码）
最新发布
m0_73546099的博客
06-10 480
在完成一次靠左移动后，接下来的双重循环使用来合并小方格中数字相同的元素的，把他们相加并放到靠左的方格中，同样外循环是用来控制行数，内循环控制列数，在内循环中加了一个判断条件，当列数加1小于4时（因为只需循环到第三列即可完成该操作），同时该列与该列+1的那一列的元素值相等且它们都不等于0时，即可进行合并操作，合并后，把该列的值置为两元素相加的结果，并把该列+1列置为0，然后把统计是否移动了的计数器进行一个自增操作。
JAVA大作业-实现2048小游戏
qq_1528515287的博客
06-20 2699
2048游戏是一款比较流行的数字游戏，每次可以选择上下左右滑动，每滑动一次，所有的数字方块都会往滑动的方向靠拢，系统也会在空白的地方乱数出现一个数字方块，相同数字的方块在靠拢、相撞时会相加。后续修改了积分bug和失败后新游戏bug，增加了排行榜,增加了登录页面，添加了背景和logo。2) 正确完成任务要求1、2，算法优化、报告规范，评定为“良好”或“优秀”；2) 利用图形化插件实现界面，至少包括游戏介绍、游戏开始、游戏结束三部分。3) 正确完成任务要求1、2、3，评定为“优秀”。
html 2048小游戏【源码详解（一）】
qq_44640575的博客
04-07 1469
这里先讲一下2048小游戏的界面设计，包含，主要是用拆分的思想进行。完整代码可以先看主页的上一篇。篇幅3500字。
Linux下用C++实现2048小游戏详解
Change_Improve的博客
11-18 2429
目录 项目分析 库函数的基本运用 游戏界面盘子的绘制 绘制游戏界面盘子 操作界面进一步的完善 游戏的实现 数字在盘子中的位置 重新初始化游戏 实现向左移动合并数字 实现向其它方向的移动并合并数字 项目完整代码 对于2048这个小游戏大家应该都玩过，没玩过的话，可以点击下方的链接进去玩一下。 2048游戏网页链接 2048是一个风靡全球的益智类小游戏，通过上下左右控制来合...
2048小游戏，Java+css+html
03-18
2048小游戏是基于网站开发的，电脑玩家可以通过上下左右控制方向，手机玩家可以通过滑动屏幕进行操作。系统使用js进行前端交互，css设置界面样式，操作简单，代码有详细注释，适合小白学习。 tips：将代码放下载到...
2048小游戏源码（java）
05-18
【标题】"2048小游戏源码（java）"所涵盖的知识点主要集中在Java编程语言和游戏开发领域。2048是一款基于数字合并的益智游戏，玩家需要通过上下左右滑动屏幕来合并数字，目标是达到2048这个数字。以下是关于这个项目...
Java小白写的飞机大战+注释
08-19
【标签】"Java小游戏"意味着这是一款利用Java语言开发的小型游戏，这类游戏通常包含基础的游戏机制，如玩家控制、碰撞检测、得分系统等，适合用于教学和实践编程技能。 【压缩包子文件的文件名称列表】"飞机大战....
最新Java 基本算法代码示例+注释
05-24
"最新Java基本算法代码示例+注释"的资源正是为帮助开发者理解和实践这些算法而设计的。 该压缩包中的"suanfa"可能包含一系列的Java源代码文件，每个文件都对应一个或多个基础算法的实现，并且配有详尽的注释，以...
java实现2048游戏源代码
08-18
主要为大家详细介绍了java实现2048游戏源代码，文中示例代码介绍的非常详细，具有一定的参考价值，感兴趣的小伙伴们可以参考一下
JAVA2048小游戏源码.zip
12-11
一、源码介绍 JAVA2048小游戏,运行java -jar命令启动jar包。 二、主要功能 鼠标点击数字+上下左右箭头移动。 三、注意事项 开发环境为eclipse，数据库为无
2048网页版小游戏代码
01-05
2048小游戏
Java版2048小游戏.zip
12-16
Java版2048小游戏是一款基于Java编程语言开发的轻量级数字拼图游戏，源自于2014年Gabriele Cirulli创建的原版2048。这个游戏的目标是通过滑动屏幕上的数字方块，使得相同数字的方块合并，最终达到2048这个数字。它在...
java基于Swing的贪吃蛇游戏源代码＋报告
02-10
注释详细，3000字报告，报告图文并茂，java课设使用。 鼠标控制、可更改难度、含历史最高成绩记录、可暂停与继续、可增加难度。 利用Swing类库，结合java语法及课程学习中出现的案例，逐步实现游戏界面显示，游戏的...
教你使用Java开发一款简单的扫雷小游戏 附实例代码
克隆窝
01-02 2743
相信很多小伙伴都知道也玩过扫雷游戏，本篇文章将和大家分享一篇关于如何使用Java来实现一款简单的扫雷小游戏，这有助于大家对于Java相关知识的学习有一定的参考价值，下面是详情内容。学了几周的Java，闲来无事，写个乞丐版的扫雷，加强一下Java基础知识。编写这个游戏，一共经历了三个阶段,编写了三个版本的游戏代码。第一版：完成了扫雷游戏的基本雏形，实现了游戏的基本功能,游戏运行在cmd黑窗口中，以字符绘制游戏界面,无图形化窗口，通过控制台输入字符完成游戏控制。代码放置在一个java文件中，代码的可读性以及可扩
基于Java的2048小游戏的设计与实现，附源码+文档，适合课程设计，包远程安装调试运行
m0_66818464的博客
10-26 2220
游戏的后台通过监听键盘方向键来移动数字方块，运用随机数的思想随机产生一个2或4的随机数，显示在随机方块中，运用二维数组存储、遍历查找等思想，在每次移动前循环查找二维数组相邻的移动方向的行或列可以合并与否，如果没有可以合并的数字方块同时又没有空余的空间产生新的数字则游戏宣告结束，同时，当检测到合并的结果中出现2048，也宣告游戏结束。为了增加游戏的用户体验，后期加入了操作音效（音效文件提取自百度移动应用商店——2048），在移动和合并方块时播放不同声音。系统框架：Swing+AWT。系统架构：gui界面。
python实现2048小游戏
weixin_64370013的博客
06-22 988
【代码】python实现2048小游戏。
2048小游戏java源代码（通过GUI界面）带注释
05-30
以下是一个简单的2048小游戏Java源代码，带有注释，通过GUI界面实现： ``` import java.awt.GridLayout; import java.awt.event.ActionEvent; import java.awt.event.ActionListener; import java.util.Random; ...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 9
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值