Java小游戏-俄罗斯方块

最新推荐文章于 2024-03-25 23:46:22 发布

X-MTing

最新推荐文章于 2024-03-25 23:46:22 发布

阅读量2.9k

点赞数 7

文章标签： java 开发语言游戏

本文链接：https://blog.csdn.net/m0_54570435/article/details/130327491

版权

摘要

随着时代的不断发展，个人电脑也在不断普及，一些有趣的桌面游戏已经成为人们在使用计算机进行工作或工作之余休闲娱乐的首选，从最开始的Windows系统自带的黑白棋、纸牌、扫雷等游戏开始，到现在目不暇接的各种游戏，游戏已经成为人们在使用计算机进行工作或学习之余休闲娱乐的首选，而俄罗斯方块游戏是人们最熟悉的小游戏之一，它以其趣味性强，易上手等诸多特点得到了大众的认可，也是不少人小时候不可或缺的娱乐项目，因此开发此游戏软件可满足人们的一些娱乐的需求。

此俄罗斯方块游戏可以为用户提供一个可在普通个人电脑上运行的，界面美观的，易于控制的俄罗斯方块。

本文采用SpringMVC技术完成了一个简便、易于操作的俄罗斯方块小游戏。本系统主要实现了随机生成方块、方块的下落、方块的清除、键盘控制方块的旋转、键盘控制方块的移动、计分等功能。使用JAVA语言，应用MVC的设计模式来设计系统，使系统结构清晰，运行速度快、稳定和安全，并且易于开发和维护。开发工具采用Eclipse，简单方便，一定程度上提高了俄罗斯方块小游戏的可玩性和方便性。

关键词： JAVA MVC设计模式 俄罗斯方块 Eclipse

第一章概述

引言

俄罗斯方块游戏是一款经典的小游戏，由于它简单有趣，因而得到了广泛的流行，男女老少都十分适合。俄罗斯方块主要是以随机方块的生成，方块的旋转，方块的移动，方块的消除以及游戏区域的不断刷新为一体，涵盖了俄罗斯方块游戏的整个运行流程。现在越来越多的游戏涌入我们的视野，丰富和影响着我们的生活。选择和做为题目的主要原因是做游戏这个流程业务比较符合我以后的学习编程的工作发展方向。从技术上来讲，俄罗斯方块的设计工作复杂且富有挑战性，它包含的内容多，设计的知识广泛，与图形界面的联系大，包括界面的显示和不断刷新等，在设计的时候，要运用到各方面的知识，这对于我的编程逻辑以及专业认知是有很大帮助的。

通过该游戏，游玩者可以体验到简易又易于上手的游戏机制，同时不断加速的方块下落也在考验着游玩者的脑力，为游玩者提供娱乐的同时，可一定程度地锻炼自己的反应，是被不少人称为的一款“益智游戏”。

1.2 系统目标

本次设计的俄罗斯方块功能齐全，包括方块的随机生成功能，方块的下落功能，方块的旋转功能，方块的移动功能，方块的消除功能，方块消除后游戏区域的刷新功能，游戏的暂停功能，游戏的计分功能，本游戏实现了简便、可玩性高的同时，也带给很多人一份童年的回忆。

第二章俄罗斯方块需求分析

2.1 游戏功能需求

2.1.1 俄罗斯方块游戏窗口区域的实现

2.1.2 方块的随机生成和下落

2.1.3 方块的清除

2.1.4 方块清除后的游戏区域刷新

2.1.5 方块清除后计数

2.1.6 方块的旋转

2.1.7 游戏的暂停

2.3游戏配置

2.3.1软件配置

服务器端：安装Java虚拟机，Web服务器软件Resin,

客户端：安装Java虚拟机，Chrome浏览器

开发环境：INTelliJ IDEA

开发语言：Java

Web服务平台：resin-4.0.36

数据库： Mysql5.0

2.3.2硬件配置

服务器端：Centos6.5，有网络接口卡（NIC），内存应在4GB以上，硬盘在160GB以上。

电脑配置：CPU: Core i5 2.30GHz 内存：DDR3 8GB 硬盘：500GB

操作系统：Microsoft Windows10专业版

客户端：Core i5以上配置的PC机，有网络接口卡（NIC），内存应在4GB以上，硬盘在500GB以上。　

电脑配置：CPU: Core i5 2.30GHz 内存：DDR3 8GB 硬盘：500GB

操作系统：Microsoft Windows 7 专业版

2.3.3网络配置

网络：服务器和客户端应有网络连通。配置TCP/IP协议。

2.4游戏的未来可能提出的要求

将每位玩家的分数进行统计并进行排名

2.5可行性分析

2.5.1经济可行性

本游戏系统主要是用于大学生Java课程设计，不需要考虑其所能产生的经济效益和游戏日后的发展状态。所以经济问题可不用考虑。

2.5.2技术可行性

本系统主要利用的是Java中的Swing组件进行开发，技术方面要求并非特别困难，技术可行。

2.5.2 社会可行性

本游戏系统的开发主要适用于课程设计与论文，用以巩固java的学习，主要以个人和学校为单位，仅供个人娱乐和学校的课程设计与论文检查入档案。

第三章俄罗斯方块总体设计

3.1 功能设计

系统所实现的功能强弱是衡量一个软件好坏的最直接也是最根本的标准。经过对游戏的可行性分析、需求分析、数据分析以及数据库设计后，结合调研的情况，本游戏分为游戏面板的设计与实现，游戏操作方法和游戏状态的说明与实现，方块的旋转、下落、消除以及消除后的游戏区域重新刷新、游戏的暂停，确定了游戏的功能模块

3.2 游戏功能设计

3.2.1 游戏区域的显示

游戏面板主要包括方块在游戏区域的显示以及操作方块之后的游戏区域变化的不断刷新。主要使用JtextArea的setBackground方法将文本区域网格分布设底色为白色。

3.2.2 游戏说明面板

游戏说明面板主要包括游戏操作方法的说明、游戏状态的说明。主要使用Jlabel标签将各种游戏说明添加到游戏界面中。

3.2.3 游戏分数记录面板

游戏分数记录面板主要包括游戏得分的记录。主要通过定义变量temp=100，由已定义休眠时间为time=1000，当消除一行后，time-=temp令socre=temp，则在游戏难度增大（方块下落速度加快）的同时游戏分数改变。

3.3 方块的形成和旋转

方块的形成主要包括随机形成方块并使之下落，方块的旋转主要指针对不同的方块有不同的旋转结果。

方块的随机形成由调用random方法实现，将所有方块放在一个数组之中，随后调用random方法则将生成一个随机方块。

方块的旋转由if语句实现，先用if语句判断当前方块的索引，再根据索引给出不同的旋转方式。

3.4 游戏的暂停

游戏的暂停主要包括对游戏进程进行暂停操作。

游戏的暂停主要是由键盘监视器getKeyChar实现，当键盘输入p时，定义的boolean变量game_pause变为ture，其返回game_run方法使游戏暂停，同时游戏说明面板改变游戏状态。

第四章　详细设计

4.1 开发工具的选用及其介绍

4.1.1 Eclipse

Eclipse 是一个开放源代码的、基于Java的可扩展开发平台。就其本身而言，它只是一个框架和一组服务，用于通过插件组件构的开发环境。幸运的是，Eclipse 附带了一个标准的插件集，包括Java开发工具（Java Development Kit，JDK）。

Eclipse是著名的跨平台的自由集成开发环境（IDE）。最初主要Java语言开发，通过安装不同的插件Eclipse可以支持不同的计算机语言，比如C++和Python等开发工具。Eclipse的本身只是一个框架平台，但是众多插件的支持使得Eclipse拥有其他功能相对固定的IDE软件很难具有的灵活性。许多软件开发商以Eclipse为框架开发自己的IDE。 [4]

Eclipse 最初由OTI和IBM两家公司的IDE产品开发组创建，起始于1999年4月。IBM提供了最初的Eclipse代码基础，包括Platform、JDT 和PDE。Eclipse项目IBM发起，围绕着Eclipse项目已经发展成为了一个庞大的Eclipse联盟，有150多家软件公司参与到Eclipse项目中，其中包括Borland、Rational Software、Red Hat及Sybase等。Eclipse是一个开放源码项目，它其实是Visual Age for Java的替代品，其界面跟先前的Visual Age for Java差不多，但由于其开放源码，任何人都可以免费得到，并可以在此基础上开发各自的插件，因此越来越受人们关注。随后还有包括Oracle在内的许多大公司也纷纷加入了该项目，Eclipse的目标是成为可进行任何语言开发的IDE集成者，使用者只需下载各种语言的插件即可。

4.2.1方块的随机生成

可以将蓝色方块视为放在一个4x4的大方格中，则可将方块转化为16进制数并将其存储在allrect数组中，并调用random方法随机抽取数组，即可生成一个随机的方块。

4.2.2 方块的下降和清除功能

设temp=0x8000；设置一个双重for循环，利用>>1不断右移一位并与rect（即生成方块进行比较）若两者都为1；则调用文本区域的setBackground方法使其变白（或使其变蓝）。

4.2.3 方块的旋转

将方块放入数组中，每个方块的索引的不同，定义变量old，利用for循环判断方块的索引所对应数组中每个方块的索引，对不同的索引进行不同的旋转变形。

4.2.4 方块的移除和刷新区域

定义temp=0x8000；设置一个双循环，利用>>1不断右移一位并与rect（即生成方块进行比较）若两者都为1；则使其变白。

4.2.5 计分

定义一个变量temp，当reomvrow每消除一行方块时，将socre的值，并将之添加至右说明板。

4.2.6 游戏的暂停

加入键盘监视器getKeychar，当按下p时，pause_times赋值为1，game_pause为false，游戏暂停；再按下p时pause_times赋值为2，游戏继续。

4.2 详细模块设计

4.2.1 游戏面板的设计

（1）游戏面板的设计主要包括游戏区域的设计和游戏说明的面板的设计。

其中游戏区域的设计主要使用了JtextArea和JtextArea的setBackground方法以及还有网格布局（GirdLayout）和边框布局（BorderLayout），游戏说明的面板主要使用了Jlabel方法将不同的标签插入到窗口之中。

程序源码

import javax.swing.*;
import java.awt.*;
import java.awt.event.KeyEvent;
import java.awt.event.KeyListener;
import java.util.Random;
public class A extends JFrame implements KeyListener{
    //游戏的行数26,列数12
    private static final int game_x = 26;
    private static final int game_y = 12;
    //文本域数组
    JTextArea[][] text;
    //二维数组
    int[][] data;
    //显示游戏状态的标签
    JLabel label1;
    //显示游戏分数的标签
    JLabel label;
    //用于判断游戏是否结束
    boolean isrunning;
    //用于存储所有的方块的数组
    int[] allRect;
    //用于存储当前方块的变量
    int rect;
    //线程的休眠时间
    int time = 1000;
    //表示方块坐标
    int x, y;
    //该变量用于计算得分
    int score = 0;
    //定义一个标志变量,用于判断游戏是否暂停
    boolean game_pause = false;
    //定义一个变量用于记录按下暂停键的次数
    int pause_times = 0;
    public void initWindow() {
        //设置窗口大小
        this.setSize(600,850);
        //设置窗口是否可见
        this.setVisible(true);
        //设置窗口居中
        this.setLocationRelativeTo(null);
        //设置释放窗体
        this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        //设置窗口大小不可变
        this.setResizable(false);
        //设置标题
        this.setTitle("俄罗斯方块");
    }
    //初始化游戏界面
    public void initGamePanel() {
        JPanel game_main = new JPanel();
        game_main.setLayout(new GridLayout(game_x,game_y,1,1));
        //初始化面板
        for (int i = 0 ; i < text.length ; i++) {
            for (int j = 0 ; j < text[i].length ;j++) {
                //设置文本域的行列数
                text[i][j] = new JTextArea(game_x,game_y);
                //设置文本域的背景颜色
                text[i][j].setBackground(Color.WHITE);
                //添加键盘监听事件
                text[i][j].addKeyListener(this);
                //初始化游戏边界
                if (j == 0 || j == text[i].length-1 || i == text.length-1) {
                    text[i][j].setBackground(Color.MAGENTA);
                    data[i][j] = 1;
                }
                //设置文本区域不可编辑
                text[i][j].setEditable(false);
                //文本区域添加到主面板上
                game_main.add(text[i][j]);
            }
        }
        //添加到窗口中
        this.setLayout(new BorderLayout());
        this.add(game_main,BorderLayout.CENTER);//（布局到中间区域）东南西北中
    }
    //初始化游戏的说明面板
    public void initExplainPanel() {
        //创建游戏的左说明面板
        JPanel explain_left = new JPanel();
        //创建游戏的右说明面板
        JPanel explain_right = new JPanel();
        explain_left.setLayout(new GridLayout(4,1));
        explain_right.setLayout(new GridLayout(2,1));
        //初始化左说明面板
        //在左说明面板,添加说明文字
        explain_left.add(new JLabel("按空格键,方块变形"));
        explain_left.add(new JLabel("按左箭头,方块左移"));
        explain_left.add(new JLabel("按右箭头,方块右移"));
        explain_left.add(new JLabel("按下箭头,方块下落"));
        //设置标签的内容为红色字体
        label1.setForeground(Color.RED);
        //把游戏状态标签,游戏分数标签,添加到右说明面板
        explain_right.add(label);
        explain_right.add(label1);
        //将左说明面板添加到窗口的左侧
        this.add(explain_left,BorderLayout.WEST);
        //将右说明面板添加到窗口的右侧
        this.add(explain_right,BorderLayout.EAST);
    }
    public A() {
        text = new JTextArea[game_x][game_y];
        data = new int[game_x][game_y];
        //初始化表示游戏状态的标签
        label1 = new JLabel("游戏状态: 正在游戏中!");
        //初始化表示游戏分数的标签
        label = new JLabel("游戏得分为: 0");
        initGamePanel();
        initExplainPanel();
        initWindow();
        //初始化开始游戏的标志
        isrunning = true;
        //初始化存放方块的数组
        allRect = new int[]{0x00cc,0x8888,0x000f,0x888f,0xf888,0xf111,0x111f,0x0eee,0xffff,0x0008,0x0888,0x000e,0x0088,0x000c,0x08c8,0x00e4
	            ,0x04c4,0x004e,0x08c4,0x006c,0x04c8,0x00c6};
    }
    public static void main(String[] args) {
        A a = new A();
        a.game_begin();
    }
    //开始游戏的方法
    public void game_begin() {
        while (true){
            //判断游戏是否结束
            if (!isrunning) {
                break;
            }
    //进行游戏
            game_run();
        }
        //在标签位置显示"游戏结束"
        label1.setText("游戏状态: 游戏结束!");
    }
    //随机生成下落方块形状的方法
    public void ranRect() {
        Random random = new Random();
        rect = allRect[random.nextInt(22)];
    }
    //游戏运行的方法
    public void game_run() {
        ranRect();
        //方块下落位置
        x = 0;
        y = 5;
        for (int i = 0;i < game_x;i++) {
            try {
                Thread.sleep(time);
                if (game_pause) {
                    i--;
                } else {
                    //判断方块是否可以下落
                    if (!canFall(x,y)) {
                        //将data置为1,表示有方块占用
                        changData(x,y);
                        //循环遍历4层,看是否有行可以消除
                        for (int j = x;j < x + 4;j++) {
                            int sum = 0;
                            for (int k = 1;k <= (game_y-2);k++) {
                                if (data[j][k] == 1) {
                                    sum++;
                                }
                            }
                            //判断是否有一行可以被消除
                            if (sum == (game_y-2)) {
                                //消除j这一行
                                removeRow(j);
                            }
                        }
                        //判断游戏是否失败
                        for (int j = 1;j <= (game_y-2);j++) {
                            if (data[3][j] == 1) {
                                isrunning = false;
                                break;
                            }
                        }
                        break;
                    } else {
                        //层数+1
                        x++;
                        //方块下落一行
                        fall(x,y);
                    }
                }
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
    //判断方块是否可以继续下落的方法
    public boolean canFall(int m,int n) {
        //定义一个变量
        int temp = 0x8000;
        //遍历4 * 4方格
        for (int i = 0;i < 4;i++) {
            for (int j = 0;j < 4;j++) {
                if ((temp & rect) != 0) {
                    //判断该位置的下一行是否有方块
                    if (data[m+1][n] == 1) {
                        return false;
                    }
                }
                n++;
                temp >>= 1;
            }
            m++;
            n = n - 4;
        }
        //可以下落
        return true;
    }
    //改变不可下降的方块对应的区域的值的方法
    public void changData(int m,int n) {
        //定义一个变量
        int temp = 0x8000;
        //遍历整个4 * 4的方块
        for (int i = 0;i < 4;i++) {
            for (int j = 0;j < 4;j++) {
                if ((temp & rect) != 0) {
                    data[m][n] = 1;
                }
                n++;
                temp >>= 1;
            }
            m++;
            n = n - 4;
        }
    }
    //移除某一行的所有方块,令以上方块掉落的方法
    public void removeRow(int row) {
        int temp = 100;
        for (int i = row;i >= 1;i--) {
            for (int j = 1;j <= (game_y-2);j++) {
                //进行覆盖
                data[i][j] = data[i-1][j];
            }
        }
        //刷新游戏区域
        reflesh(row);
        //方块加速
        if (time > temp) {
            time -= temp;
        }
        score += temp;
        //显示变化后的分数
        label.setText("游戏得分为: " + score);
    }
    //刷新移除某一行后的游戏界面的方法
    public void reflesh(int row) {
        //遍历row行以上的游戏区域
        for (int i = row;i >= 1;i--) {
            for (int j = 1;j <= (game_y-2);j++) {
                if (data[i][j] == 1) {
                    text[i][j].setBackground(Color.BLUE);
                }else {
                    text[i][j].setBackground(Color.WHITE);
                }
            }
        }
    }
    //方块向下掉落一层的方法
    public void fall(int m,int n) {
        if (m > 0) {
            //清除上一层方块
            clear(m-1,n);
        }
        //重新绘制方块
        draw(m,n);
    }
    //清除方块掉落后,上一层有颜色的地方的方法
    public void clear(int m,int n) {
        //定义变量
        int temp = 0x8000;
        for (int i = 0;i < 4;i++) {
            for (int j = 0;j < 4;j++) {
                if ((temp & rect) != 0) {
                    text[m][n].setBackground(Color.WHITE);
                }
                n++;
                temp >>= 1;
            }
            m++;
            n = n - 4;
        }
    }
    //重新绘制掉落后方块的方法
    public void draw(int m,int n) {
        //定义变量
        int temp = 0x8000;
        for (int i = 0;i < 4;i++) {
            for (int j = 0;j < 4;j++) {
                if ((temp & rect) != 0) {
                    text[m][n].setBackground(Color.BLUE);
                }
                n++;
                temp >>= 1;
            }
            m++;
            n = n - 4;
        }
    }
    public void keyTyped(KeyEvent e) {
        //控制游戏暂停
        if (e.getKeyChar() == 'p') {
            //判断游戏是否结束
            if (!isrunning) {
                return;
            }
            pause_times++;
            //判断按下一次,暂停游戏
            if (pause_times == 1) {
                game_pause = true;
                label1.setText("游戏状态: 暂停中!");
            }
            //判断按下两次,继续游戏
            if (pause_times == 2) {
                game_pause = false;
                pause_times = 0;
                label1.setText("游戏状态: 正在进行中!");
            }
        }
        //控制方块进行变形
        if (e.getKeyChar() == KeyEvent.VK_SPACE) {
            //判断游戏是否结束
            if (!isrunning) {
                return;
            }
            //判断游戏是否暂停
            if (game_pause) {
                return;
            }
            //定义变量,存储目前方块的索引
            int old;
            for (old = 0;old < allRect.length;old++) {
                //判断是否是当前方块
                if (rect == allRect[old]) {
                    break;
                }
            }
            //定义变量,存储变形后方块
            int next;
            //判断是方块
            if (old == 0 || old == 7 || old == 8 || old == 9) {
                return;
            }
            //清除当前方块
            clear(x,y);
            if (old == 1 || old == 2) {
                next = allRect[old == 1 ? 2 : 1];
            if (canTurn(next,x,y)) {
                    rect = next;
                }
            }
            if (old >= 3 && old <= 6) {
                next = allRect[old + 1 > 6 ? 3 : old + 1];
                if (canTurn(next,x,y)) {
                    rect = next;
                }
            }
            if (old == 10 || old == 11) {
                next = allRect[old == 10 ? 11 : 10];
                if (canTurn(next,x,y)) {
                    rect = next;
                }
            }
           if (old == 12 || old == 13) {
               next = allRect[old == 12 ? 13 : 12];
               if (canTurn(next,x,y)) {
                   rect = next;
               }
           }

           if (old >= 14 && old <= 17) {
               next = allRect[old + 1 > 17 ? 14 : old + 1];
               if (canTurn(next,x,y)) {
                   rect = next;
               }
           }
           if (old == 18 || old == 19) {
               next = allRect[old == 18 ? 19 : 18];
               if (canTurn(next,x,y)) {
                   rect = next;
               }
           }
           if (old == 20 || old == 21) {
               next = allRect[old == 20 ? 21 : 20];
               if (canTurn(next,x,y)) {
                   rect = next;
               }
           }
           //重新绘制变形后方块
            draw(x,y);
        }
    }
    //判断方块此时是否可以变形的方法
    public boolean canTurn(int a,int m,int n) {
        //创建变量
        int temp = 0x8000;
        //遍历整个方块
        for (int i = 0;i < 4;i++) {
            for (int j = 0;j < 4;j++) {
                if ((a & temp) != 0) {
                    if (data[m][n] == 1) {
                        return false;
                    }
                }
                n++;
                temp >>= 1;
            }
            m++;
            n = n -4;
        }
        //可以变形
        return true;
    }
    public void keyPressed(KeyEvent e) {
        //方块进行左移
        if (e.getKeyCode() == 37) {
            //判断游戏是否结束
            if (!isrunning) {
                return;
            }
            //判断游戏是否暂停
            if (game_pause) {
                return;
            }
            //方块是否碰到左墙壁
            if (y <= 1) {
                return;
            }
            //定义一个变量
            int temp = 0x8000;
            for (int i = x;i < x + 4;i++) {
                for (int j = y;j < y + 4;j++) {
                    if ((temp & rect) != 0) {
                        if (data[i][j-1] == 1) {
                            return;
                        }
                    }
                    temp >>= 1;
                }
            }
            //首先清除目前方块
            clear(x,y);
            y--;
            draw(x,y);
        }
        //方块进行右移
        if (e.getKeyCode() == 39) {
            //判断游戏是否结束
            if (!isrunning) {
                return;
            }
            //判断游戏是否暂停
            if (game_pause) {
                return;
            }
            //定义变量
            int temp = 0x8000;
            int m = x;
            int n = y;
            //存储最右边的坐标值
            int num = 1;
            for (int i = 0;i < 4;i++) {
                for (int j = 0;j < 4;j++) {
                    if ((temp & rect) != 0) {
                        if (n > num) {
                            num = n;
                        }
                    }
                    n++;
                    temp >>= 1;
                }
                m++;
                n = n - 4;
            }
            //判断是否碰到右墙壁
            if (num >= (game_y-2)) {
                return;
            }
            //方块右移途中是否碰到别的方块
            temp = 0x8000;
            for (int i = x;i < x + 4;i++) {
                for (int j = y;j < y + 4;j++) {
                    if ((temp & rect) != 0) {
                        if (data[i][j+1] == 1) {
                            return;
                        }
                    }
                    temp >>= 1;
                }
            }
            //清除当前方块
            clear(x,y);
            y++;
            draw(x,y);
        }
        //方块进行下落
        if (e.getKeyCode() == 40) {
            //判断游戏是否结束
            if (!isrunning) {
                return;
            }
            //判断游戏是否暂停
            if (game_pause) {
                return;
            }
            //判断方块是否可以下落
            if (!canFall(x,y)) {
                return;
            }
            clear(x,y);
            //改变方块的坐标
            x++;
            draw(x,y);
        }
    }
    public void keyReleased(KeyEvent e) {
    }
}

X-MTing

关注

7
点赞
踩
93

收藏

觉得还不错? 一键收藏
打赏
1
评论
Java小游戏-俄罗斯方块

从技术上来讲，俄罗斯方块的设计工作复杂且富有挑战性，它包含的内容多，设计的知识广泛，与图形界面的联系大，包括界面的显示和不断刷新等，在设计的时候，要运用到各方面的知识，这对于我的编程逻辑以及专业认知是有很大帮助的。本次设计的俄罗斯方块功能齐全，包括方块的随机生成功能，方块的下落功能，方块的旋转功能，方块的移动功能，方块的消除功能，方块消除后游戏区域的刷新功能，游戏的暂停功能，游戏的计分功能，本游戏实现了简便、可玩性高的同时，也带给很多人一份童年的回忆。游戏分数记录面板主要包括游戏得分的记录。
复制链接

扫一扫