2048游戏——Java

最新推荐文章于 2023-02-14 22:35:38 发布
最新推荐文章于 2023-02-14 22:35:38 发布
阅读量405 收藏 2
点赞数 2
分类专栏： 小程序
原文链接：https://blog.csdn.net/weixin_40577349/article/details/84649511
版权

整理一下以前学习时找到的程序。

一、框架

在这里插入图片描述
就以个 2 维数组，4 个方向进行加法 在空白位置出现随机的 2 就行了

二、代码（链接在最后）

1、ConstantValue.java(封装常量)

import java.awt.Color;

/*
 * 封装常量
 * WID：边长
 * SP：间隔
 * lable：各种数字
 * clo：对应数字颜色
 * */

public class ConstantValue {
    private static final int WID = 150;
    private static final int SP = 10;
    private static final int[] label = { 2, 4, 8, 16, 32, 64, 128, 256, 512, 1024, 2048};
    private static final Color[] clo = {
            new Color(200, 200, 200), 
            new Color(228, 228, 160),
            new Color(214, 163, 92), 
            new Color(234, 124, 72),
            new Color(240, 84, 77), 
            new Color(255, 68, 53),
            new Color(200, 200, 64),
            new Color(0, 0, 255),
            new Color(0, 255, 0),
            new Color(255, 0, 0),
            new Color(100, 100, 100),
        };
    
	public static int getWid() {
		return WID;
	}
	public static int getSp() {
		return SP;
	}
	public static int[] getLabel() {
		return label;
	}
	public static Color[] getClo() {
		return clo;
	}
}

2、Game2048.java

import java.awt.*;
import java.awt.event.*;

import java.io.*;

import java.util.*;

import javax.swing.*;


public class Game2048 extends JApplet {
	
	private int scores = 0;
    private int best = 0;
    private boolean change;
    private boolean CheckMode = false;
    private boolean gameOverFlag = false;
    private boolean successFlag = false;
    private static JLabel scoreLabel;
    private static My2048Panel myp;
    private static JButton goBackButton;
    
    public static RectObject[][] rset = new RectObject[4][4];
    private Map<Integer, Color> cmap = new HashMap<Integer, Color>();
    public RectObject[][] list = new RectObject[4][4];
    private LinkedList<ArrayList<Integer>> saveList = new LinkedList<ArrayList<Integer>>();
    
    KeyListener kl = new KeyListener() {
            public void keyPressed(KeyEvent e) {
                saveTheStep();
                goBackButton.setVisible(true);

                if (gameOverFlag == true) {
                    return;
                }

                if (!aDirAble()) {
                    gameOver();
                }

                int key = e.getKeyCode();

                switch (key) {
                case KeyEvent.VK_UP:
                    change = false;
                    moveUp(true);

                    if (change == true) {
                        getARandomRect();
                        //saveTheStep();
                    }
                    break;

                case KeyEvent.VK_DOWN:
                    change = false;
                    moveDown(true);

                    if (change == true) {
                        getARandomRect();
                        //saveTheStep();
                    }
                    break;

                case KeyEvent.VK_LEFT:
                    change = false;
                    moveLeft(true);

                    if (change == true) {
                        getARandomRect();
                        //saveTheStep();
                    }
                    break;

                case KeyEvent.VK_RIGHT:
                    change = false;
                    moveRight(true);

                    if (change == true) {
                        getARandomRect();
                        //saveTheStep();
                    }
                    break;
                }
                //saveTheStep();
            }

            public void keyTyped(KeyEvent e) {
            }

            public void keyReleased(KeyEvent e) {
            }
        };

    public Game2048() {
        //saveTheStep();
        for (int i = 0; i < 11; i++) {
            cmap.put(ConstantValue.getLabel()[i], ConstantValue.getClo()[i]);
        }
    }

    //the applet init
    public void init() {
        Container cp = getContentPane();
        cp.setLayout(null);
        cp.setFocusable(true);
        cp.addKeyListener(kl);

        Font font = new Font("TimesNewman", Font.BOLD, 30);
        JLabel sl = new JLabel();
        sl.setLayout(new GridLayout(2, 1));

        JLabel sllb = new JLabel("Scores");
        sllb.setFont(font);
        scoreLabel = new JLabel("0");
        scoreLabel.setFont(font);
        sl.add(sllb);
        sl.add(scoreLabel);

        try {
            File file = new File("BestRecord");

            if (file.exists()) {
                RandomAccessFile f = new RandomAccessFile(file, "rw");
                f.seek(0);
                best = f.readInt();
                f.close();
            }
        } catch (FileNotFoundException e) {
            best = 0;
            e.printStackTrace();
        } catch (IOException e) {
            best = 0;
            e.printStackTrace();
        }

        JLabel bsl = new JLabel();
        bsl.setLayout(new GridLayout(2, 1));

        JLabel jl = new JLabel("Best");
        jl.setFont(font);

        JLabel jl1 = new JLabel("" + best);
        jl1.setFont(font);
        bsl.add(jl);
        bsl.add(jl1);

        myp = new My2048Panel();

        LOGO logo = new LOGO(0, 0);

        goBackButton = new JButton("UNDO");
        goBackButton.setFont(font);
        goBackButton.addActionListener(new goBackListener());
        goBackButton.addKeyListener(kl);

        JButton jb = new JButton("RESET");
        jb.setFont(font);
        jb.addActionListener(new resetListener());
        jb.addKeyListener(kl);

        sl.setBounds(500, 20, 200, 80);
        bsl.setBounds(300, 20, 200, 80);
        logo.setBounds(0, 0, 600, 100);
        myp.setBounds(0, 90, 700, 700);
        goBackButton.setBounds(700, 250, 150, 60);
        jb.setBounds(700, 450, 150, 60);

        cp.add(sl);
        cp.add(bsl);
        cp.add(logo);
        cp.add(myp);
        cp.add(goBackButton);
        cp.add(jb);

        File f = new File("LastRecord");

        if (f.exists()) {
            try {
                RandomAccessFile file = new RandomAccessFile(f, "rw");
                int num = file.readInt();
                scoreLabel.setText("" + num);

                for (int i = 0; i < 4; i++) {
                    for (int j = 0; j < 4; j++) {
                        num = file.readInt();

                        if (num != 0) {
                            rset[i][j] = new RectObject();
                            rset[i][j].value = num;
                        }
                    }
                }

                file.close();
            } catch (FileNotFoundException e) {
                e.printStackTrace();
            } catch (IOException e) {
                e.printStackTrace();
            }
        } else {
            getARandomRect();
            getARandomRect();
        }
    }

    //moveLeft
    public void moveLeft(boolean flag) {
        clearList(list);

        for (int i = 0; i < 4; i++) {
            int k = 0;

            for (int j = 0; j < 4; j++) {
                if (rset[i][j] != null) {
                    list[i][k++] = new RectObject(rset[i][j]);
                }
            }
        }

        for (int i = 0; (i < 4) && flag; i++) {
            for (int j = 0; j < 3; j++) {
                if ((list[i][j] != null) && (list[i][j + 1] != null) &&
                        (list[i][j].value == list[i][j + 1].value)) {
                    list[i][j].value *= 2;

                    if (CheckMode == false) {
                        int sum = Integer.parseInt(scoreLabel.getText());
                        sum += list[i][j].value;
                        scoreLabel.setText("" + sum);
                    }

                    list[i][j + 1] = null;
                    j++;
                }
            }
        }

        if (isChange()) {
            if (CheckMode == false) {
                copySet(rset, list);
                repaint();
                moveLeft(false);
            }

            change = true;
        } else {
            repaint();
        }
    }

    //moveRight
    public void moveRight(boolean flag) {
        clearList(list);

        for (int i = 0; i < 4; i++) {
            int k = 3;

            for (int j = 3; j > -1; j--) {
                if (rset[i][j] != null) {
                    list[i][k--] = new RectObject(rset[i][j]);
                }
            }
        }

        for (int i = 0; (i < 4) && flag; i++) {
            for (int j = 3; j > 0; j--) {
                if ((list[i][j] != null) && (list[i][j - 1] != null) &&
                        (list[i][j].value == list[i][j - 1].value)) {
                    list[i][j].value *= 2;

                    if (CheckMode == false) {
                        int sum = Integer.parseInt(scoreLabel.getText());
                        sum += list[i][j].value;
                        scoreLabel.setText("" + sum);
                    }

                    list[i][j - 1] = null;
                    j--;
                }
            }
        }

        if (isChange()) {
            if (CheckMode == false) {
                copySet(rset, list);
                repaint();
                moveRight(false);
            }

            change = true;
        } else {
            repaint();
        }
    }

    //moveup
    public void moveUp(boolean flag) {
        clearList(list);

        for (int j = 0; j < 4; j++) {
            int k = 0;

            for (int i = 0; i < 4; i++) {
                if (rset[i][j] != null) {
                    list[k++][j] = new RectObject(rset[i][j]);
                }
            }
        }

        for (int j = 0; (j < 4) && flag; j++) {
            for (int i = 0; i < 3; i++) {
                if ((list[i][j] != null) && (list[i + 1][j] != null) &&
                        (list[i][j].value == list[i + 1][j].value)) {
                    list[i][j].value *= 2;

                    if (CheckMode == false) {
                        int sum = Integer.parseInt(scoreLabel.getText());
                        sum += list[i][j].value;
                        scoreLabel.setText("" + sum);
                    }

                    list[i + 1][j] = null;
                    i++;
                }
            }
        }

        if (isChange()) {
            if (CheckMode == false) {
                copySet(rset, list);
                repaint();
                moveUp(false);
            }

            change = true;
        } else {
            repaint();
        }
    }

    //movedown
    public void moveDown(boolean flag) {
        clearList(list);

        for (int j = 0; j < 4; j++) {
            int k = 3;

            for (int i = 3; i > -1; i--) {
                if (rset[i][j] != null) {
                    list[k--][j] = new RectObject(rset[i][j]);
                }
            }
        }

        for (int j = 0; (j < 4) && flag; j++) {
            for (int i = 3; i > 0; i--) {
                if ((list[i][j] != null) && (list[i - 1][j] != null) &&
                        (list[i][j].value == list[i - 1][j].value)) {
                    list[i][j].value *= 2;

                    if (CheckMode == false) {
                        int sum = Integer.parseInt(scoreLabel.getText());
                        sum += list[i][j].value;
                        scoreLabel.setText("" + sum);
                    }

                    list[i - 1][j] = null;
                    i--;
                }
            }
        }

        if (isChange()) {
            if (CheckMode == false) {
                copySet(rset, list);
                repaint();
                moveDown(false);
            }

            change = true;
        } else {
            repaint();
        }
    }

    //other functions
    private void copySet(RectObject[][] dst, RectObject[][] src) {
        for (int i = 0; i < 4; i++) {
            for (int j = 0; j < 4; j++) {
                dst[i][j] = src[i][j];
            }
        }
    }

    //detect whether rset is different from list or not 
    private boolean isChange() {
        for (int i = 0; i < 4; i++) {
            for (int j = 0; j < 4; j++) {
                if ((rset[i][j] != null) && (list[i][j] != null) && !rset[i][j].equals(list[i][j])) {
                    return true;
                }

                if ((rset[i][j] != null) && (list[i][j] == null)) {
                    return true;
                }

                if ((rset[i][j] == null) && (list[i][j] != null)) {
                    return true;
                }
            }
        }
        return false;
    }

    private void clearList(RectObject[][] s) {
        for (int i = 0; i < s.length; i++) {
            for (int j = 0; j < s[i].length; j++) {
                s[i][j] = null;
            }
        }
    }

    //get a random rectangle
    public void getARandomRect() {
        ArrayList<Point> list = new ArrayList<Point>();

        for (int i = 0; i < 4; i++) {
            for (int j = 0; j < 4; j++) {
                if (rset[i][j] == null) {
                    list.add(new Point(i, j));
                }
            }
        }

        if ((list.size() == 0) && !aDirAble()) {
            gameOver();

            return;
        }

        Random rand = new Random();
        int index = rand.nextInt(list.size());
        Point loc = (Point) list.get(index);
        index = rand.nextInt(2);
        rset[loc.x][loc.y] = new RectObject();

        if (index == 1) {
            rset[loc.x][loc.y].value = 4;
        } else {
            rset[loc.x][loc.y].value = 2;
        }
    }

    //detect whether there are other steps or not
    public boolean aDirAble() {
        CheckMode = true;
        change = false;
        moveLeft(true);
        moveRight(true);
        moveDown(true);
        moveUp(true);
        CheckMode = false;

        if (change == true) {
            return true;
        } else {
            return false;
        }
    }

    public void gameOver() {
        gameOverFlag = true;

        JPanel jl = new GameOverPane(myp.getWidth(), myp.getHeight());
        jl.setBounds(0, 0, 700, 700);

        JButton jb1 = new JButton("Again");
        Font font = new Font("TimesRoman", Font.BOLD, 30);
        jb1.setOpaque(false);
        jb1.setFont(font);

        JButton jb2 = new JButton("Close");
        jb2.setSize(jb1.getSize());
        jb2.setOpaque(false);
        jb2.setFont(font);
        //保存最高分，分数重置
        jb1.addActionListener(new ActionListener() {
                public void actionPerformed(ActionEvent e) {
                    refreshBest();
                    scoreLabel.setText("0");
                    myp.remove(jl);
                    clearList(rset);
                    myp.validate();
                    getARandomRect();
                    getARandomRect();
                    repaint();
                    gameOverFlag = false;
                }
            });
        //保存最后结果
        jb2.addActionListener(new ActionListener() {
                public void actionPerformed(ActionEvent e) {
                    refreshBest();

                    File f = new File("LastRecord");

                    if (f.exists()) {
                        f.delete();
                    }

                    System.exit(0);
                }
            });
        jl.add(jb1);
        jl.add(jb2);
        myp.add(jl);
        jl.validate();
    }

    public void gameSuccess() {
        JPanel jl = new SuccessPane(myp.getWidth(), myp.getHeight());
        jl.setOpaque(false);
        jl.setBounds(0, 0, 700, 700);

        JButton jb1 = new JButton("Continue");
        Font font = new Font("TimesRoman", Font.BOLD, 30);
        jb1.setOpaque(false);
        jb1.setFont(font);

        JButton jb2 = new JButton("Close");
        jb2.setSize(jb1.getSize());
        jb2.setOpaque(false);
        jb2.setFont(font);
        jb1.addActionListener(new ActionListener() {
                public void actionPerformed(ActionEvent e) {
                    myp.remove(jl);
                    myp.validate();
                    repaint();
                }
            });
        jb2.addActionListener(new ActionListener() {
                public void actionPerformed(ActionEvent e) {
                    refreshBest();
                    System.exit(0);
                }
            });
        jl.add(jb1);
        jl.add(jb2);
        myp.add(jl);
        jl.validate();
    }

    public void saveTheStep() {
        if (saveList.size() < 20) {
            ArrayList<Integer> arr = new ArrayList<Integer>();
            int score = Integer.parseInt(scoreLabel.getText());
            arr.add(score);

            for (int i = 0; i < 4; i++) {
                for (int j = 0; j < 4; j++) {
                    if (rset[i][j] != null) {
                        arr.add(rset[i][j].value);
                    } else {
                        arr.add(0);
                    }
                }
            }

            saveList.addLast(arr);
        } else {
            saveList.removeFirst();
            saveTheStep();
        }
    }

    public static String title(Object o) {
        String t = o.getClass().toString();

        if (t.indexOf("class") != -1) {
            t = t.substring(6);
        }

        return t;
    }

    public static void refreshBest() {
        try {
            int best;
            File f = new File("BestRecord");
            RandomAccessFile file;

            if (f.exists()) {
                file = new RandomAccessFile(f, "rw");
                best = file.readInt();
            } else {
                file = new RandomAccessFile(f, "rw");
                best = 0;
            }

            //			System.out.println("The Best score is "+best);
            int cur = Integer.parseInt(scoreLabel.getText());

            if (cur > best) {
                file.seek(0);
                file.writeInt(cur);
            }

            file.close();
        } catch (FileNotFoundException e1) {
            e1.printStackTrace();
        } catch (IOException e2) {
            e2.printStackTrace();
        }
    }

    public static void saveRecord() {
        try {
            RandomAccessFile file = new RandomAccessFile(new File("LastRecord"),
                    "rw");
            int score = Integer.parseInt(scoreLabel.getText());
            file.writeInt(score);

            for (int i = 0; i < 4; i++) {
                for (int j = 0; j < 4; j++) {
                    if (rset[i][j] != null) {
                        file.writeInt(rset[i][j].value);
                    } else {
                        file.writeInt(0);
                    }
                }
            }
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    public static void run(JApplet applet, int width, int height) {
        JFrame frame = new JFrame(title(applet));
        frame.addWindowListener(new WindowAdapter() {
                public void windowClosing(WindowEvent e) {
                    saveRecord();
                    refreshBest();

                    //System.out.println("The score is "+scoreLabel.getText());
                }
            });
        frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        frame.getContentPane().add(applet);
        frame.setSize(width, height);
        applet.init();
        applet.start();
        frame.setVisible(true);
    }

    public static void main(String[] args) {
        run(new Game2048(), 900, 800);
    }

    class RectObject {
        private int value;

        public RectObject() {
            value = 0;
        }

        public RectObject(RectObject obj) {
            value = obj.value;
        }

        public boolean equals(Object inobj) {
            RectObject obj = (RectObject) inobj;

            if (obj.value == value) {
                return true;
            }

            return false;
        }
    }

    class Point {
        int x;
        int y;

		public Point(int i, int j) {
            x = i;
            y = j;
        }
    }

    class My2048Panel extends JPanel {
        private int[] xindex = {
        		ConstantValue.getSp(), 
        		(2 * ConstantValue.getSp()) + ConstantValue.getWid(), 
        		(3 * ConstantValue.getSp()) + (2 * ConstantValue.getWid()), 
        		(4 * ConstantValue.getSp()) + (3 * ConstantValue.getWid())
            };
        private int[] yindex = {
                ConstantValue.getSp(), 
                (2 * ConstantValue.getSp()) + ConstantValue.getWid(), 
                (3 * ConstantValue.getSp()) + (2 * ConstantValue.getWid()), 
                (4 * ConstantValue.getSp()) + (3 * ConstantValue.getWid())
            };

        public void paintComponent(Graphics g) {
            //background
            super.paintComponent(g);

            for (int i = 0; i < xindex.length; i++) {
                for (int j = 0; j < yindex.length; j++) {
                    g.setColor(Color.WHITE);
                    g.drawRoundRect(
                    		xindex[i], yindex[j], 
                    		ConstantValue.getWid(), ConstantValue.getWid(), 
                    		ConstantValue.getWid() / 5, ConstantValue.getWid() / 5);
                    g.setColor(new Color(197, 183, 129));
                    g.fillRoundRect(
                    		xindex[i], yindex[j], 
                    		ConstantValue.getWid(), ConstantValue.getWid(), 
                    		ConstantValue.getWid() / 5, ConstantValue.getWid() / 5);
                }
            }

            //paint rectangle
            for (int i = 0; i < 4; i++) {
                for (int j = 0; j < 4; j++) {
                    if (rset[i][j] != null) {
                        g.setColor(Color.WHITE);
                        g.drawRoundRect(yindex[j], xindex[i], ConstantValue.getWid(), ConstantValue.getWid(),
                            ConstantValue.getWid() / 5, ConstantValue.getWid() / 5);
                        
                        //各数字颜色
                        g.setColor((Color) cmap.get(rset[i][j].value));

                        g.fillRoundRect(yindex[j], xindex[i], ConstantValue.getWid(), ConstantValue.getWid(),
                            ConstantValue.getWid() / 5, ConstantValue.getWid() / 5);
                        g.setColor(Color.BLACK);

                        Font font = new Font("TimesRoman", Font.BOLD, 50);
                        g.setFont(font);

                        FontMetrics fm = Toolkit.getDefaultToolkit().getFontMetrics(font);
                        int len = fm.stringWidth("" + rset[i][j].value);
                        int hg = fm.getHeight();
                        g.drawString("" + rset[i][j].value,
                            (yindex[j] + (ConstantValue.getWid() / 2)) - (len / 2), xindex[i] + (ConstantValue.getWid() / 2) + (hg / 4));

                        if ((rset[i][j].value == 2048) && (successFlag == false)) {
                            successFlag = true;
                            gameSuccess();
                        }
                    }
                }
            }
        }
    }

    class GameOverPane extends JPanel {
        public GameOverPane(int w, int h) {
            setSize(w, h);
        }

        public void paintComponent(Graphics g) {
            super.paintComponent(g);

            Font font = new Font("TimesRoman", Font.BOLD, 80);
            g.setFont(font);

            FontMetrics fm = Toolkit.getDefaultToolkit().getFontMetrics(font);
            int width = fm.stringWidth("Game Over");
            int height = fm.getHeight();
            g.setColor(new Color(255, 0, 0));
            g.drawString("Game Over!", (getWidth() / 2) - (width / 2),
                (getHeight() / 2) - (height / 2));
        }
    }

    class SuccessPane extends JPanel {
        public SuccessPane(int w, int h) {
            setSize(w, h);
        }

        public void paintComponent(Graphics g) {
            super.paintComponent(g);

            Font font = new Font("TimesRoman", Font.BOLD, 80);
            g.setFont(font);

            FontMetrics fm = Toolkit.getDefaultToolkit().getFontMetrics(font);
            int width = fm.stringWidth("Success!");
            int height = fm.getHeight();
            g.setColor(new Color(255, 0, 0));
            g.drawString("Success!", (getWidth() / 2) - (width / 2),
                (getHeight() / 2) - (height / 2));
        }
    }

    class LOGO extends JPanel {
        public LOGO(int w, int h) {
            setSize(w, h);
        }

        public void paintComponent(Graphics g) {
            super.paintComponent(g);

            Font font = new Font("TimesRoman", Font.BOLD, 60);
            g.setFont(font);

            FontMetrics fm = Toolkit.getDefaultToolkit().getFontMetrics(font);
            int width = fm.stringWidth("2048");
            int height = fm.getHeight();
            g.setColor(new Color(255, 0, 0));
            g.drawString("2048", 20, (getHeight() / 2) + 20);
        }
    }

    public class goBackListener implements ActionListener {
        public void actionPerformed(ActionEvent e) {
            if (saveList.size() == 0) {
                goBackButton.setVisible(false);

                return;
            }

            ArrayList arr = (ArrayList) saveList.getLast();
            scoreLabel.setText("" + arr.get(0));

            for (int i = 0; i < 4; i++) {
                for (int j = 0; j < 4; j++) {
                    int num = (int) arr.get((4 * i) + j + 1);

                    if (num != 0) {
                        rset[i][j] = new RectObject();
                        rset[i][j].value = num;
                    } else {
                        rset[i][j] = null;
                    }
                }
            }

            saveList.removeLast();
            repaint();
        }
    }

    public class resetListener implements ActionListener {
        public void actionPerformed(ActionEvent e) {
            refreshBest();

            for (int i = 0; i < 4; i++) {
                for (int j = 0; j < 4; j++) {
                    rset[i][j] = null;
                }
            }

            scoreLabel.setText("0");
            repaint();
            getARandomRect();
            getARandomRect();
        }
    }
}

三、界面

在这里插入图片描述

四、百度网盘

链接：https://pan.baidu.com/s/1cwQlIzG5otf_yLHGwlr87w
提取码：eb91

有人_295
关注
  • 2
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
【经典例子】Java实现2048小游戏（附带源码）
m0_46013789的博客
02-05 1337
2048游戏是一款数字益智游戏，目标是通过合并相同数字的方块来达到2048这个目标。游戏在一个4x4的方格上进行，每个方格上都有一个数字（初始时为2或4）。玩家可以通过滑动方向键（上、下、左、右）来移动所有的方块，当两个相同数字的方块在移动过程中碰到一起时，它们会合并成一个数字的方块，数字为它们的和。每次滑动后，系统会在空白的方格上随机生成一个新的数字方块。游戏的目标是通过不断合并方块，最终得到一个数字为2048的方块。
java实现2048小游戏
m0_56235386的博客
06-09 2330
2048是一款非常流行的数字益智游戏，玩家需要通过将相同数字的方块合并，最终得到2048这个数字方块。在本篇博客中，我们将会介绍如何使用Java语言编写一个2048小游戏，并提供详细的代码实现。以上就是使用Java语言编写2048小游戏的详细代码实现。在游戏开始之前，我们需要初始化一个4x4的矩阵，并随机生成两个数字方块（2或4）。当所有的格子都被填满，且无法再进行合并时，游戏结束。- 相同数字的方块可以合并成一个更大的数字方块。- 每次移动后需要随机生成一个新的数字方块。- 方块只能向空白的方向移动。
2048小游戏 java版（代码+注释）
逗呵呵的博客
08-28 8369
一个纯纯小白，想写点什么，也想学习一下怎么在这里写东西，就简单的写个2048小游戏。写的不好，大佬就不用看了，希望和大家交流学习，有写的不好或有更好的建议也欢迎提出来。（轻喷）
JAVA大作业-实现2048小游戏
qq_1528515287的博客
06-20 2640
2048游戏是一款比较流行的数字游戏，每次可以选择上下左右滑动，每滑动一次，所有的数字方块都会往滑动的方向靠拢，系统也会在空白的地方乱数出现一个数字方块，相同数字的方块在靠拢、相撞时会相加。后续修改了积分bug和失败后新游戏bug，增加了排行榜,增加了登录页面，添加了背景和logo。2) 正确完成任务要求1、2，算法优化、报告规范，评定为“良好”或“优秀”；2) 利用图形化插件实现界面，至少包括游戏介绍、游戏开始、游戏结束三部分。3) 正确完成任务要求1、2、3，评定为“优秀”。
Java课设 2048小游戏
weixin_46858088的博客
07-30 4858
题目：2048小游戏 1. 引言 《2048》是一款比较流行的数字游戏，最早于2014年3月20日发行。原版2048首先在GitHub上发布，原作者是Gabriele Cirulli，后被移植到各个平台。这款游戏是基于《1024》和《小3传奇》的玩法开发而成的新型数字游戏。 2. 主要模块设计 1)游戏面板 图2.1 显示得分,最高分,当你的分数大于最高分BEST将记录到最高分BEST中 2)移动 图2.2.1......
java小游戏——2048小游戏.zip
12-16
2048是同类游戏中较火的一款游戏。玩法同网页版2048。有移动速度快，计时器等功能。是益智小游戏，游戏的规则十分简单，是时下一款简单易上手的数字小游戏，但又十分虐心。
java实现游戏-2048
07-30
这是一个使用java ( java.awt + java.swing )实现的简单小游戏，2048。 这是对比较流行的数字游戏2048的模仿重现。 游戏技巧： 1.最大数尽可能放在角落。 2.数字按顺序紧邻排列。 3.首先满足最大数和次大数在的那一...
打地鼠游戏——JAVA大作业。.zip
09-10
用java写的项目，项目可以直接运行，请放心下载使用。
奥特曼打怪兽小游戏——Java项目学习.zip
09-10
用java写的项目，项目可以直接运行，请放心下载使用。
用javascript实现简版2048小游戏
bs775926015的博客
04-05 1766
** 1、2048小游戏玩法和规则 ** 2048是一款休闲小游戏。 2048界面有16宫格，可以用键盘方向键选择上下左右四个方向进行操作，如果有相邻的两个数字相同就会合并，相加组成新数字，并且每次移动或合并后界面会自动增加一个数字。 当16宫格中没有空格子，且四个方向都无法操作时，游戏会结束。目的是合并出2048这个数字，获得更高分数。 2、游戏界面截图 3、2048游戏实现原理 1、游戏界面由16宫格组成，可以看成是矩阵的形式。 2、在HTML中给每个格子添加类名以及属性，来记录每个格子的位置。 3、
基于Qt框架 2048游戏
07-21
本人新学Qt参考网上一些连连看和贪吃蛇的代码 写出的2048
2048java游戏
06-07
2048java游戏，和安卓手机的差不多，赶快下载来玩把
2048小游戏源码（Java）.rar
01-02
这是用Java编写的2048小游戏源码，大家可以参考一下，（资源仅为学习参考，不可用于商业目的！版权归原作者所有,请在下载后于24小时内删除）
jsp网页开发2048游戏源码
01-29
本源码采用jsp网页技术来开发2048游戏，源码清晰明了，有详细的注释，欢迎下载。有什么问题希望您的提出。
Java实现的小游戏2048
06-08
使用Java开发的2048,完美运行,同时游戏支持菜单栏,Java课程设计
Java实现2048小游戏，我竟然一盘都没赢，你们说我到底行不行？
编程界明世隐的博客
09-07 6505
作者简介 作者名：编程界明世隐 简介：CSDN博客专家，从事软件开发多年，精通Java、JavaScript，博主也是从零开始一步步把学习成长、深知学习和积累的重要性，喜欢跟广大ADC一起打野升级，欢迎您关注，期待与您一起学习、成长、起飞！ 系列目录 1. Java俄罗斯方块 2. Java五子棋小游戏 3. 老Java程序员花一天时间写了个飞机大战 4. Java植物大战僵尸 5. 老Java程序员花2天写了个连连看 6. Java消消乐（天天爱消除） 7. Java贪吃蛇小游戏 8. Java扫雷小
【游戏框架系列】2048
weixin_40783885的博客
02-14 145
【游戏框架系列】2048
java2048_java之2048
weixin_42361026的博客
02-21 366
今天好热热热热热热热热热 ㄟ(≧◇≦)ㄏ ，所以吃块西瓜就开始玩2048吧~一.先确定这个2048有哪些功能初始出现2个数字和方块移动方块方块中的数字相加仅出现1个相加后的数字和方块记录最大数字随机出现数字和方块游戏结束排行榜重新开始游戏存档二.界面的实现以画图的方式来实现2048游戏主界面。☆窗体实现☆游戏界面实现Graphics的绘图方法☆基本功能实现三.实现2048游戏需要使用那些API类...
用js实现2048小游戏
nnngu
02-12 1757
笔记仓库：https://github.com/nnngu/LearningNotes 1、游戏简介 2048是一款休闲益智类的数字叠加小游戏。（文末给出源代码和演示地址） 2、游戏玩法 在 4*4 的16宫格中，您可以选择上、下、左、右四个方向进行操作，数字会按方向移动，相邻的两个数字相同就会合并，组成更大的数字，每次移动或合并后会自动增加一个数字。 当16宫格中没有空...
java小游戏——贪吃蛇
最新发布
04-15
贪吃蛇是一款经典的小游戏，玩家通过控制一条蛇的移动来吃食物，每吃到一个食物，蛇的长度会增加一节。游戏的目标是尽可能地吃到更多的食物，同时避免蛇头碰到自己的身体或者游戏界面的边界。 在Java中，可以使用图形库（如Swing或JavaFX）来实现贪吃蛇游戏的界面显示和用户交互。以下是一个简单的贪吃蛇游戏的实现思路： 1. 创建一个游戏窗口，设置窗口大小和标题。 2. 创建一个蛇对象，包括蛇头和蛇身，初始位置在游戏界面的中央。 3. 创建一个食物对象，初始位置随机生成在游戏界面上。 4. 监听键盘事件，根据用户的按键操作来改变蛇的移动方向。 5. 在游戏循环中，不断更新蛇的位置和判断是否吃到食物或碰到边界或自身。 6. 如果蛇吃到食物，则增加蛇的长度，并在新的位置生成一个新的食物。 7. 如果蛇碰到边界或自身，则游戏结束。 8. 在游戏界面上绘制蛇和食物的位置。 这只是一个简单的实现思路，你可以根据自己的需求和技术水平进行扩展和优化。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值