Java实现2048小游戏(直接拿走运行)

运行效果:
在这里插入图片描述
1.项目结构
在这里插入图片描述
2.代码
BaseData接口

package com.hsy.game;

import java.awt.*;

public interface BaseData {
    Font topicFont = new Font("微软雅黑", Font.BOLD, 50);
    Font scoreFont = new Font("微软雅黑", Font.BOLD, 28);
    Font normalFont = new Font("宋体", Font.PLAIN, 20);
    Font font1 = new Font("宋体", Font.BOLD, 46);
    Font font2 = new Font("宋体", Font.BOLD, 40);
    Font font3 = new Font("宋体", Font.BOLD, 34);
    Font font4 = new Font("宋体", Font.BOLD, 28);
    Font font5 = new Font("宋体", Font.BOLD, 22);
    int normalFontData = 20;
    int topicFontData = 30;

    void init();
    void showView();
}

GameView类

package com.hsy.game;

import java.awt.Color;
import java.awt.FlowLayout;
import java.awt.FontMetrics;
import java.awt.Graphics;
import java.awt.Graphics2D;
import java.awt.RenderingHints;
import java.awt.event.KeyEvent;
import java.awt.event.KeyListener;
import java.util.ArrayList;
import java.util.List;
import java.util.Random;

import javax.swing.JFrame;
import javax.swing.JLabel;
import javax.swing.JPanel;


public class GameView implements BaseData{
    private static final int jFrameWidth = 400;
    private static final int jFrameHeight = 530;
    private static int score = 0;

    private JFrame jFrameMain;
    private JLabel jLblTitle;
    private JLabel jLblScoreName;
    private JLabel jLblScore;
    private GameBoard gameBoard;


    private JLabel jlblTip;

    public GameView() {
        init();
    }

    @Override
    public void init() {
        jFrameMain = new JFrame("2048小游戏");
        jFrameMain.setSize(jFrameWidth, jFrameHeight);
        jFrameMain.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        jFrameMain.setLocationRelativeTo(null);
        jFrameMain.setResizable(false);
        jFrameMain.setLayout(null);

        jLblTitle = new JLabel("2048", JLabel.CENTER);
        jLblTitle.setFont(topicFont);
        jLblTitle.setForeground(Color.BLACK);
        jLblTitle.setBounds(50, 0, 150, 60);
        jFrameMain.add(jLblTitle);


        // 分数区
        jLblScoreName = new JLabel("得 分", JLabel.CENTER);
        jLblScoreName.setFont(scoreFont);
        jLblScoreName.setForeground(Color.WHITE);
        jLblScoreName.setOpaque(true);
        jLblScoreName.setBackground(Color.GRAY);
        jLblScoreName.setBounds(250, 0, 120, 30);
        jFrameMain.add(jLblScoreName);

        jLblScore = new JLabel("0", JLabel.CENTER);
        jLblScore.setFont(scoreFont);
        jLblScore.setForeground(Color.WHITE);
        jLblScore.setOpaque(true);
        jLblScore.setBackground(Color.GRAY);
        jLblScore.setBounds(250, 30, 120, 30);
        jFrameMain.add(jLblScore);

        // 说明:
        jlblTip = new JLabel("操作: ↑ ↓ ← →, 按esc键重新开始  ",
                JLabel.CENTER);
        jlblTip.setFont(normalFont);
        jlblTip.setForeground(Color.DARK_GRAY);
        jlblTip.setBounds(0, 60, 400, 40);
        jFrameMain.add(jlblTip);

        gameBoard = new GameBoard();
        gameBoard.setBounds(0, 100, 400, 400);
        gameBoard.setBackground(Color.GRAY);
        gameBoard.setFocusable(true);
        gameBoard.setLayout(new FlowLayout());
        jFrameMain.add(gameBoard);
    }

    // 游戏面板需要对键值实现侦听,
    // 这里采用内部类来继承 JPanel 类,
    // 并实现接口 KeyListener 中的 keyPressed 方法,
    // 方格是通过
    @SuppressWarnings("serial")
    class GameBoard extends JPanel implements KeyListener {
        private static final int CHECK_GAP = 10;
        private static final int CHECK_ARC = 20;
        private static final int CHECK_SIZE = 86;

        private Check[][] checks = new Check[4][4];
        private boolean isAdd = true;

        public GameBoard() {
            initGame();
            addKeyListener(this);
        }

        @Override
        public void keyPressed(KeyEvent e) {
            switch (e.getKeyCode()) {
                case KeyEvent.VK_ESCAPE:
                    initGame();
                    break;
                case KeyEvent.VK_LEFT:
                    moveLeft();
                    createCheck();
                    judgeGameOver();
                    break;
                case KeyEvent.VK_RIGHT:
                    moveRight();
                    createCheck();
                    judgeGameOver();
                    break;
                case KeyEvent.VK_UP:
                    moveUp();
                    createCheck();
                    judgeGameOver();
                    break;
                case KeyEvent.VK_DOWN:
                    moveDown();
                    createCheck();
                    judgeGameOver();
                    break;
                default:
                    break;
            }
            repaint();
        }

        private void initGame() {
            score = 0;
            for (int indexRow = 0; indexRow < 4; indexRow++) {
                for (int indexCol = 0; indexCol < 4; indexCol++) {
                    checks[indexRow][indexCol] = new Check();
                }
            }
            // 生成两个数
            isAdd = true;
            createCheck();
            isAdd = true;
            createCheck();
        }

        private void createCheck() {
            List<Check> list = getEmptyChecks();

            if (!list.isEmpty() && isAdd) {
                Random random = new Random();
                int index = random.nextInt(list.size());
                Check check = list.get(index);
                // 2, 4出现概率3:1
                check.value = (random.nextInt(4) % 3 == 0) ? 2 : 4;
                isAdd = false;
            }
        }

        // 获取空白方格
        private List<Check> getEmptyChecks() {
            List<Check> checkList = new ArrayList<>();
            for (int i = 0; i < 4; i++) {
                for (int j = 0; j < 4; j++) {
                    if (checks[i][j].value == 0) {
                        checkList.add(checks[i][j]);
                    }
                }
            }

            return checkList;
        }

        private boolean judgeGameOver() {
            jLblScore.setText(score + "");

            if (!getEmptyChecks().isEmpty()) {
                return false;
            }

            for (int i = 0; i < 3; i++) {
                for (int j = 0; j < 3; j++) {
                    //判断是否存在可合并的方格
                    if (checks[i][j].value == checks[i][j + 1].value
                            || checks[i][j].value == checks[i + 1][j].value) {
                        return false;
                    }
                }
            }

            return true;
        }

        private boolean moveLeft() {
            for (int i = 0; i < 4; i++) {
                for (int j = 1, index = 0; j < 4; j++) {
                    if (checks[i][j].value > 0) {
                        if (checks[i][j].value == checks[i][index].value) {
                            score += checks[i][index++].value <<= 1;
                            checks[i][j].value = 0;
                            isAdd = true;
                        } else if (checks[i][index].value == 0) {
                            checks[i][index].value = checks[i][j].value;
                            checks[i][j].value = 0;
                            isAdd = true;
                        } else if (checks[i][++index].value == 0) {
                            checks[i][index].value = checks[i][j].value;
                            checks[i][j].value = 0;
                            isAdd = true;
                        }
                    }
                }
            }
            return isAdd;
        }

        private boolean moveRight() {
            for (int i = 0; i < 4; i++) {
                for (int j = 2, index = 3; j >= 0; j--) {
                    if (checks[i][j].value > 0) {
                        if (checks[i][j].value == checks[i][index].value) {
                            score += checks[i][index--].value <<= 1;
                            checks[i][j].value = 0;
                            isAdd = true;
                        } else if (checks[i][index].value == 0) {
                            checks[i][index].value = checks[i][j].value;
                            checks[i][j].value = 0;
                            isAdd = true;
                        } else if (checks[i][--index].value == 0) {
                            checks[i][index].value = checks[i][j].value;
                            checks[i][j].value = 0;
                            isAdd = true;
                        }
                    }
                }
            }

            return isAdd;
        }

        private boolean moveUp() {
            for (int i = 0; i < 4; i++) {
                for (int j = 1, index = 0; j < 4; j++) {
                    if (checks[j][i].value > 0) {
                        if (checks[j][i].value == checks[index][i].value) {
                            score += checks[index++][i].value <<= 1;
                            checks[j][i].value = 0;
                            isAdd = true;
                        } else if (checks[index][i].value == 0) {
                            checks[index][i].value = checks[j][i].value;
                            checks[j][i].value = 0;
                            isAdd = true;
                        } else if (checks[++index][i].value == 0){
                            checks[index][i].value = checks[j][i].value;
                            checks[j][i].value = 0;
                            isAdd = true;
                        }
                    }
                }
            }

            return isAdd;
        }

        private boolean moveDown() {
            for (int i = 0; i < 4; i++) {
                for (int j = 2, index = 3; j >= 0; j--) {
                    if (checks[j][i].value > 0) {
                        if (checks[j][i].value == checks[index][i].value) {
                            score += checks[index--][i].value <<= 1;
                            checks[j][i].value = 0;
                            isAdd = true;
                        } else if (checks[index][i].value == 0) {
                            checks[index][i].value = checks[j][i].value;
                            checks[j][i].value = 0;
                            isAdd = true;
                        } else if (checks[--index][i].value == 0) {
                            checks[index][i].value = checks[j][i].value;
                            checks[j][i].value = 0;
                            isAdd = true;
                        }
                    }
                }
            }

            return isAdd;
        }

        @Override
        public void paint(Graphics g) {
            super.paint(g);
            for (int i = 0; i < 4; i++) {
                for (int j = 0; j < 4; j++) {
                    drawCheck(g, i, j);
                }
            }

            // GameOver
            if (judgeGameOver()) {
                g.setColor(new Color(64, 64, 64, 150));
                g.fillRect(0, 0, getWidth(), getHeight());
                g.setColor(Color.WHITE);
                g.setFont(topicFont);
                FontMetrics fms = getFontMetrics(topicFont);
                String value = "Game Over!";
                g.drawString(value,
                        (getWidth()-fms.stringWidth(value)) / 2,
                        getHeight() / 2);
            }
        }

        // 绘制方格
        // Graphics2D 类扩展了 Graphics 类,
        // 提供了对几何形状、坐标转换、颜色管理和文本布局更为复杂的控制
        private void drawCheck(Graphics g, int i, int j) {
            Graphics2D gg = (Graphics2D) g;
            gg.setRenderingHint(RenderingHints.KEY_ANTIALIASING,
                    RenderingHints.VALUE_ANTIALIAS_ON);
            gg.setRenderingHint(RenderingHints.KEY_STROKE_CONTROL,
                    RenderingHints.VALUE_STROKE_NORMALIZE);
            Check check = checks[i][j];
            gg.setColor(check.getBackground());
            // 绘制圆角
            // x - 要填充矩形的 x 坐标。
            // y - 要填充矩形的 y 坐标。
            // width - 要填充矩形的宽度。
            // height - 要填充矩形的高度。
            // arcwidth - 4 个角弧度的水平直径。
            // archeight - 4 个角弧度的垂直直径。
            gg.fillRoundRect(CHECK_GAP + (CHECK_GAP + CHECK_SIZE) * j,
                    CHECK_GAP + (CHECK_GAP + CHECK_SIZE) * i,
                    CHECK_SIZE, CHECK_SIZE, CHECK_ARC, CHECK_ARC);
            gg.setColor(check.getForeground());
            gg.setFont(check.getCheckFont());

            // 对文字的长宽高测量。
            FontMetrics fms = getFontMetrics(check.getCheckFont());
            String value = String.valueOf(check.value);
            //使用此图形上下文的当前颜色绘制由指定迭代器给定的文本。
            //getAscent()是FontMetrics中的一个方法,
            //它返回某字体的基线(baseline)到该字体中大多数字符的升部(ascender)之间的距离
            //getDescent 为降部
            gg.drawString(value,
                    CHECK_GAP + (CHECK_GAP + CHECK_SIZE) * j +
                            (CHECK_SIZE - fms.stringWidth(value)) / 2,
                    CHECK_GAP + (CHECK_GAP + CHECK_SIZE) * i +
                            (CHECK_SIZE - fms.getAscent() - fms.getDescent()) / 2
                            + fms.getAscent());
        }

        @Override
        public void keyReleased(KeyEvent e) {
        }

        @Override
        public void keyTyped(KeyEvent e) {
        }

    }

    @Override
    public void showView() {
        jFrameMain.setVisible(true);
    }

}

Check类

package com.hsy.game;

import java.awt.Color;
import java.awt.Font;


public class Check {
    public int value;

    public Check() {
        clear();
    }

    public void clear() {
        value = 0;
    }

    public Color getForeground() {
        switch (value) {
            case 0:
                return new Color(0xcdc1b4);
            case 2:
            case 4:
                return Color.BLACK;
            default:
                return Color.WHITE;
        }
    }

    public Color getBackground() {
        switch (value) {
            case 0:
                return new Color(0xcdc1b4);
            case 2:
                return new Color(0xeee4da);
            case 4:
                return new Color(0xede0c8);
            case 8:
                return new Color(0xf2b179);
            case 16:
                return new Color(0xf59563);
            case 32:
                return new Color(0xf67c5f);
            case 64:
                return new Color(0xf65e3b);
            case 128:
                return new Color(0xedcf72);
            case 256:
                return new Color(0xedcc61);
            case 512:
                return new Color(0xedc850);
            case 1024:
                return new Color(0xedc53f);
            case 2048:
                return new Color(0xedc22e);
            case 4096:
                return new Color(0x65da92);
            case 8192:
                return new Color(0x5abc65);
            case 16384:
                return new Color(0x248c51);
            default:
                return new Color(0x248c51);
        }
    }

    public Font getCheckFont() {
        if (value < 10) {
            return BaseData.font1;
        }
        if (value < 100) {
            return BaseData.font2;
        }
        if (value < 1000) {
            return BaseData.font3;
        }
        if (value < 10000) {
            return BaseData.font4;
        }

        return BaseData.font5;
    }

}

Test类

package com.hsy.game;

public class Test {
    public static void main(String[] args) {
        new GameView().showView();
    }
}

运行Test即可


文章标签:

原文连接:https://blog.csdn.net/qq_47436772/article/details/114123633

相关推荐

[教你做小游戏] 只用几行原生JS,写一个函数,播放音效、播放BGM、切换BGM

我们用48h,合作创造了一款Web游戏:Dice Crush,参加国际赛事

【小程序】快来开发你的第一个微信小游戏(详细流程)

还记得当年的超级玛丽么?来吧,动手设计一款小霸王游戏机

Unity中文版?脚本也用中文?用中文写了个剧情小游戏,真好玩~

网易游戏 Flink SQL 平台化实践

初学JS—JavaScript实现像素鸟小游戏

从零开始完整开发基于websocket的在线对弈游戏【五子棋】,只用几十行代码完成全部逻辑。

关于我仿做了个steam很火的《Helltaker》游戏

Unity制作 小球吃金币 游戏

NC20566 [SCOI2010]游戏

生命游戏(信息学堂2022)

[教你做小游戏] 展示斗地主扑克牌,支持按出牌规则排序!支持按大小排序!

【基于Flutter&Flame 的飞机大战开发笔记】展示面板及重新开始菜单

【基于Flutter&Flame 的飞机大战开发笔记】利用bloc管理游戏状态

软件设计实战:基于Java的俄罗斯方块游戏【完整版】

【基于Flutter&Flame 的飞机大战开发笔记】子弹升级和补给

【基于Flutter&Flame 的飞机大战开发笔记】重构敌机

Python做游戏很难吗—来看看我做的多有意思~

LeetCode-消除游戏