扫雷游戏（简易版）

最新推荐文章于 2024-09-23 17:11:27 发布
最新推荐文章于 2024-09-23 17:11:27 发布
阅读量154 收藏
点赞数
文章标签： 游戏 Powered by 金山文档
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2301_76159452/article/details/128747142
版权

想完成一个扫雷游戏,需要思考以下的因素

  • 游戏界面（老生常谈的事了）

  • 扫雷实则有两个“棋盘”，一个是放置雷的，一个是显示给玩家的

  • 怎么布置随机的地雷

  • 若玩家选择的地方是地雷，该如何进行接下来的程序。若不是雷，怎么表示周围雷的个数？

  • 是雷和不是雷，怎么表示？

游戏菜单

首先，一个游戏应该有菜单，就是给玩家选择是否开始游戏，且需要保证在游戏结束后，跳回菜单，让玩家可以一直玩下去，而不用退出游戏后再进入——需要用到循环语句和条件语句

void menu()
{
    printf("******************************\n");
    printf("******    1. play      *******\n");
    printf("******    0. exit      *******\n");
    printf("******************************\n");
}

int main()
{
    int input = 0;
    do
    {
        menu();
        printf("请选择:>");
        scanf("%d", &input);
        switch (input)
        {
        case 1:
            game();//扫雷游戏
            break;
        case 0:
            printf("退出游戏\n");
            break;
        default:
            printf("选择错误，重新选择\n");
            break;
        }
    } while (input);//若输入0的时候就会退出游戏
    return 0;
}

游戏界面

现在就是制作游戏界面，由于扫雷游戏不仅要给玩家展示每一次选择后的结果，而且还需要定下雷

还有界面边界的时候，不需要读取“棋盘”外边的区域，那么怎么解决？

————用两个数组保存，一个数组show保存每次的游戏状态，另一个数组mine保存雷的位置，进行选择时会在mine数组里选择，但反馈的情况会在show里展现给玩家,其次为了解决边界的情况——9*9大的“棋盘”，我们选择用11*11的数组，这样的话边界的区域也能构成一个九宫格进行地雷的排查

初始化数组

void game()
{
    char mine[11][11] = { 0 };//存放布置好的雷的信息
    char show[11][11] = { 0 };//存放排查出的雷的信息
}

初始化棋盘

现在应该将棋盘初始化，我们应该设想，如果是雷，用什么表示，不是雷，又用什么表示？

除此之外，由于排除一块区域后，我们需要显示周围地雷数，所以我们干脆将雷设置为'1'，

不是雷就设置为'0'。且初始化时要对11*11的数组全部设置

InitBoard(mine, 11, 11, '0');//'0'表示不放置雷，初始化时，默认没有雷
InitBoard(show, 11, 11, '*');//'*'表示此处未知
void InitBoard(char board[11][11], int row, int col, char set)//set表示该区域的状态
{
    int i = 0;
    int j = 0;
    for (i = 0; i < row; i++)//控制行数
    {
        for (j = 0; j < col; j++)//控制列数
        {
            board[i][j] = set;//先设置好每个方块的状态—* 
        }
    }
}

且用11*11的数组，可以减少代码量，超出部分默认为0，设置雷的时候就放在9*9里即可

展示棋盘

在游戏开始到结束，每进行一次步骤，都需要显示一次棋盘给玩家，让玩家知道情况，但只显示9*9的棋盘

DisplayBoard(show, 9, 9);

void DisplayBoard(char board[11][11], int row, int col)//对应整个数组11*11
{
    int i = 0;
    int j = 0;
    printf("---------扫雷游戏-----------\n");
    for(int i=0;i<=row;i++)//控制行数
    {
      for(int j=0;j<=col;j++)//控制列情况
      {
        printf("%c ",board[i][j]);
      }
      printf("\n");
    }
    printf("---------扫雷游戏-----------\n");
}

显示出来的就是这种表格，但是，这样会给玩家进行选择的时候，造成一定程度上的干扰2，那我们是否可以增添行列数，来实现游戏的简化?

void DisplayBoard(char board[ROWS][COLS], int row, int col)//对应整个数组11*11
{
    int i = 0;
    int j = 0;
    printf("---------扫雷游戏-----------\n");
    //打印列号
    for (i = 0; i <= col; i++) //第一行就是打印列号
    {
        printf("%d ", i);//打印出的是数字，不是定义成数字
    }
    printf("\n");
    for (i = 1; i <= row; i++)//从第二行开始，就要先打印一个数字，剩下的就打印棋盘状态
    {
        printf("%d ", i);//先打印数字，剩下的打印状态—*
        for (j = 1; j <= col; j++)
        {
            printf("%c ", board[i][j]);//状态*
        }
        printf("\n");//空行
    }
    printf("---------扫雷游戏-----------\n");
}

简化后的，会更加简洁

布置雷

地雷一定是随机的，所以需要随机数的帮忙

随机数怎么布置？——就用rand函数，然后还需要用srand函数来设置时间戳

主函数就变为

int main()
{
    int input = 0;
    srand((unsigned int)time(NULL));//在主函数里使用，这样每次调用的时候随机值就已经定好

    do
    {
        menu();
        printf("请选择:>");
        scanf("%d", &input);
        switch (input)
        {
        case 1:
            game();//扫雷游戏
            break;
        case 0:
            printf("退出游戏\n");
            break;
        default:
            printf("选择错误，重新选择\n");
            break;
        }
    } while (input);

    return 0;
}

将时间戳在主函数里设置，那么每次刚开始运行时，随机数就已经被设置好

接着，我们需要布置雷——怎么布置——在mine数组上实现，且仅作用于9*9的数组

//布置雷
SetMine(mine, 9, 9);

void SetMine(char mine[11][11], int row, int col)
{
    //布置10个雷
    int count = EASY_COUNT;//为什么要设置成EASY_COUNT?——因为宏定义里，EASY_COUNT就是雷的个数—10
    while (count)
    {
        //生成随机的下标,11*11--有效部分就是1-9
        int x = rand()%row+1;//rand%9--0-8  +1 --> 1-9
        int y = rand()%col+1;
        if (mine[x][y] == '0')//如果该地方没有雷，则放置，放置反复放置雷
        {
            mine[x][y] = '1';
            count--;
        }
    }
}

我们这里将雷的个数宏定义成EASY_COUNT，原因在后面讲

因为随机数是0-32767，且膜上9后，结果必定是0-8，加上1后就是1-9

且每次设置前，需要判断该地方是否已经设置过。若设置过，则进行又一轮的循环

排查雷

设置好雷后，我们需要进行排查，选定一个区域

  • 选的区域是雷，则提示游戏失败并且结束游戏

  • 选的区域不是雷，则统计周围雷的个数，并且打印出来

与其同时，输入的是11*11的数组，输出的是9*9的数组

判断时用mine数组判断，反馈情况用show数组表示出来

//排查雷
FindMine(mine, show, 9, 9);

void FindMine(char mine[11][11], char show[11][11], int row, int col)
{
    //1. 输入排查的坐标
    //2. 检查坐标处是不是雷
       // (1) 是雷   - 很遗憾炸死了 - 游戏结束
       // (2) 不是雷  - 统计坐标周围有几个雷 - 存储排查雷的信息到show数组，游戏继续
    int x = 0;
    int y = 0;
    int win = 0;
    while (win<row*col- EASY_COUNT)//最多行走71次，因为有10个雷
    {
        printf("请输入要排查的坐标:>");
        scanf("%d%d", &x, &y);//x--(1,9)  y--(1,9)

        //判断坐标的合法性
        if (x >= 1 && x <= row && y >= 1 && y <= col)
        {
            if (mine[x][y] == '1')//如果该位置是雷
            {
                printf("很遗憾，你被炸死了\n");
                DisplayBoard(mine, row, col);//展示一次游戏
                break;//停止循环跳出
            }
            else//若不是雷
            {
                //不是雷情况下，统计x,y坐标周围有几个雷
                int count = get_mine_count(mine, x, y);
                show[x][y] = count+'0';
                //mine函数里的情况会反馈给show，再用show,展示出来
                //然后且有static函数来保留每次的结果  
                //会将常数转化为对应的数字字符
                //字符加上'0'就会转化为相对的数字
                //显示排查出的信息，展示棋盘
                DisplayBoard(show, row, col);
                win++;
            }
        }
        else
        {
            printf("坐标不合法，请重新输入\n");
        }
    }
    if (win == row * col - EASY_COUNT)//排查次数为71次的时候且没有碰到雷，则胜利
    {
        printf("恭喜你，排雷成功\n");
        DisplayBoard(mine, row, col);
    }
}

那我们怎么统计雷的个数呢？前面提到“是雷为1，不是则为0”，那么周围有3个雷，那么反馈的就是3，所以雷的个数就是选定区域周围八个区域的数字和

且，我们每次输出后，就需要保留当时展现的棋盘的状况，因此需要一个函数

——static函数，具体用法可以用msdn或者csdn上搜索

static int get_mine_count(char mine[11][11], int x, int y)
{
    return mine[x - 1][y] +
        mine[x - 1][y - 1] +
        mine[x][y - 1] +
        mine[x + 1][y - 1] +
        mine[x + 1][y] +
        mine[x + 1][y + 1] +
        mine[x][y + 1] +
        mine[x - 1][y + 1] - 8 * '0';//一个字符对应一个数字，所以需要乘'0'
}

重点是：由于数组里存放的是字符，那么我们可以用字符-'0'的形式来使字符转化为数字！！！！！！！！

实现多格的扫雷

上述显示的是9*9的情况，那如果我们想实现11*11,10*10,20*20，且改变雷的个数怎么办？

难道要一个一个修改吗？

这时候我们需要用宏定义，设立两个文件game.c(函数的实现)，game.h(函数的声明以及宏定义)

给大家展示最后的代码

//'game.h'
#include <stdio.h>
#include <stdlib.h>
#include <time.h>
//在宏定义里改变数字，就能轻易地改变雷的数量以及行列数

#define EASY_COUNT 10

#define ROW 9
#define COL 9

#define ROWS ROW+2
#define COLS COL+2


//初始化棋盘的
void InitBoard(char board[ROWS][COLS], int rows, int cols, char set);

//打印棋盘
void DisplayBoard(char board[ROWS][COLS], int row, int col);

//布置雷
void SetMine(char mine[ROWS][COLS], int row, int col);

//排查雷
void FindMine(char mine[ROWS][COLS], char show[ROWS][COLS], int row, int col);

//'game.c'
#define _CRT_SECURE_NO_WARNINGS 1

#include "game.h"

//初始化全部的方块
//为什么是11*11，因为在排查雷的时候，边界排查时会超出数组，为了减少代码量
//直接用11*11，超出部分直接默认为0
void InitBoard(char board[ROWS][COLS], int rows, int cols, char set)
{
    int i = 0;
    int j = 0;
    for (i = 0; i < rows; i++)
    {
        for (j = 0; j < cols; j++)
        {
            board[i][j] = set;//先设置好每个方块的状态—* 
        }
    }

}

//仅显示9*9的部分，但接收11*11的数组，多余的地方用来打印行列数
void DisplayBoard(char board[ROWS][COLS], int row, int col)//对应整个数组11*11
{
    int i = 0;
    int j = 0;
    printf("---------扫雷游戏-----------\n");
    //打印列号
    for (i = 0; i <= col; i++) //第一行就是打印列号
    {
        printf("%d ", i);//打印出的是数字，不是定义成数字
    }
    printf("\n");
    for (i = 1; i <= row; i++)//从第二行开始，就要先打印一个数字，剩下的就打印棋盘状态
    {
        printf("%d ", i);//先打印数字，剩下的打印状态—*
        for (j = 1; j <= col; j++)
        {
            printf("%c ", board[i][j]);//状态*
        }
        printf("\n");//空行
    }
    printf("---------扫雷游戏-----------\n");
}



void SetMine(char mine[ROWS][COLS], int row, int col)
{
    //布置10个雷
    int count = EASY_COUNT;//为什么要设置成EASY_COUNT?——因为宏定义里，EASY_COUNT就是雷的个数—10
    while (count)
    {
        //生成随机的下标,11*11--有效部分就是1-9
        int x = rand()%row+1;//rand%9--0-8  +1 --> 1-9
        int y = rand()%col+1;
        if (mine[x][y] == '0')//如果该地方没有雷，则放置，放置反复放置雷
        {
            mine[x][y] = '1';
            count--;
        }
    }
}

//static
//1. 修饰局部变量
//2. 修饰全局变量
//3. 修饰函数

//用static修饰，可以保证每次排查后的数字保存

//且有雷就是1，没有雷就是0，周围的数字相加后就是该地区周围雷的个数
//仅传入有效的部分9*9    超出9*9部分不用管，因为有雷才会是1，统计后的只会是雷的个数，
//超出部分未被定义就是0

static int get_mine_count(char mine[ROWS][COLS], int x, int y)
{
    return mine[x - 1][y] +
        mine[x - 1][y - 1] +
        mine[x][y - 1] +
        mine[x + 1][y - 1] +
        mine[x + 1][y] +
        mine[x + 1][y + 1] +
        mine[x][y + 1] +
        mine[x - 1][y + 1] - 8 * '0';//一个字符对应一个数字，所以需要乘'0'
}

void FindMine(char mine[ROWS][COLS], char show[ROWS][COLS], int row, int col)
{
    //1. 输入排查的坐标
    //2. 检查坐标处是不是雷
       // (1) 是雷   - 很遗憾炸死了 - 游戏结束
       // (2) 不是雷  - 统计坐标周围有几个雷 - 存储排查雷的信息到show数组，游戏继续

    int x = 0;
    int y = 0;
    int win = 0;

    while (win<row*col- EASY_COUNT)//最多行走71次，因为有10个雷
    {
        printf("请输入要排查的坐标:>");
        scanf("%d%d", &x, &y);//x--(1,9)  y--(1,9)

        //判断坐标的合法性
        if (x >= 1 && x <= row && y >= 1 && y <= col)
        {
            if (mine[x][y] == '1')//如果该位置是雷
            {
                printf("很遗憾，你被炸死了\n");
                DisplayBoard(mine, row, col);//展示一次游戏
                break;//停止循环跳出
            }
            else//若不是雷
            {
                //不是雷情况下，统计x,y坐标周围有几个雷
                int count = get_mine_count(mine, x, y);
                show[x][y] = count+'0';//会将常数转化为对应的数字字符
                //字符加上'0'就会转化为相对的数字
                //显示排查出的信息，展示棋盘
                DisplayBoard(show, row, col);
                win++;
            }
        }
        else
        {
            printf("坐标不合法，请重新输入\n");
        }
    }

    if (win == row * col - EASY_COUNT)//排查次数为71次的时候且没有碰到雷，则胜利
    {
        printf("恭喜你，排雷成功\n");
        DisplayBoard(mine, row, col);
    }
}

//'扫雷'
#define _CRT_SECURE_NO_WARNINGS 1

#include "game.h"

void menu()
{
    printf("******************************\n");
    printf("******    1. play      *******\n");
    printf("******    0. exit      *******\n");
    printf("******************************\n");
}

//用两个数组，一个数组用来显示，一个数组用来排雷
void game()
{
    char mine[ROWS][COLS] = {0};//存放布置好的雷的信息
    char show[ROWS][COLS] = {0};//存放排查出的雷的信息
    //初始化棋盘
    InitBoard(mine, ROWS, COLS, '0');//'0'表示不放置雷，初始化时，默认没有雷
    InitBoard(show, ROWS, COLS, '*');//'*'，表示位置

    //打印一下棋盘
    DisplayBoard(show, ROW, COL);

    //布置雷
    SetMine(mine, ROW, COL);
    //DisplayBoard(mine, ROW, COL);
    
    //排查雷
    FindMine(mine, show, ROW, COL);
}

int main()
{
    int input = 0;
    srand((unsigned int)time(NULL));//在主函数里使用，这样每次调用的时候随机值就已经定好

    do
    {
        menu();
        printf("请选择:>");
        scanf("%d", &input);
        switch (input)
        {
        case 1:
            game();//扫雷游戏
            break;
        case 0:
            printf("退出游戏\n");
            break;
        default:
            printf("选择错误，重新选择\n");
            break;
        }
    } while (input);

    return 0;
}

这个扫雷比起我们以往玩过的游戏，还缺少了自动扫出为0区域的功能，所以需要大家可以思考，我会在后些日子发布出来，供大家参考讨论交流

祝：除夕快乐

Nick-An
关注
C语言实现扫雷游戏简易版
01-21
本文实例为大家分享了C语言实现扫雷游戏的简易版，供大家参考，具体内容如下 game.h #pragma once #include #include #include #include #define ROW 12 #define COL 12 #define NUMS 20 #pragma warning...
C语言实现简易版扫雷小游戏
08-18
C语言实现简易版扫雷小游戏是一种使用C语言编写的简易版扫雷游戏，旨在帮助初学者了解C语言的编程思想和实现扫雷游戏的基本原理。本文将详细介绍C语言实现简易版扫雷小游戏的设计思路、代码实现和游戏逻辑。 1. ...
扫雷(简易版）
yanyongfu523的博客
05-13 447
简易版扫雷 源代码 程序主体 #define _CRT_SECURE_NO_WARNINGS #include "game.h" void menu() { printf("====================\n"); printf("=======1.扫雷=======\n"); printf("=======0.退出=======\n"); printf("====================\n"); } void game() { char mine[ROWS][COLS] =
扫雷—简易版
fsbwb的博客
02-05 126
此篇文章是介绍如何用C语言来写一个简易版的扫雷小游戏。扫雷的规则很简单，有X*X的棋盘，在棋盘中布置n个雷，玩家选择棋盘中任意一个位置，如果该位置是雷则游戏结束，如果不是雷显示该位置周围8个位置中一共有几个雷并且显示出来，玩家直到把所有雷都排查出来则游戏结束排雷成功。效果图如下。下面介绍如何完成这个小游戏。
扫雷小游戏（简易版）
m0_62534424的博客
03-06 4262
写个小游戏娱乐娱乐！ 目录：1.简要分析 2.实现扫雷游戏细节 3.总代码 1.简要分析 一般写这种小游戏要分为两个模块：头文件，源文件。头文件中声明各种函数和库函数以及宏定义，全局变量等。源文件中主要是实现函数和逻辑函数等。 在扫雷游戏中，我将我的模块分为三部分，一部分是game.h--声明头文件等，game.c--实现游戏函数，test.c--实现总体逻辑 接下来就是扫雷游戏的细节处理 2.游戏细节 1.定义两个数组 char mi...
简易版扫雷（C语言实现）
qq_64438318的博客
02-14 2495
还是一样，我们要想做出这个游戏需要先了解游戏的玩法。就是在一个棋盘上面有若干个雷（隐藏的），当点击棋盘空格区域时，会显示相邻1格的雷的个数，若点中了雷，则游戏结束。
简单版扫雷-java
伍传琴的博客-极客营
01-12 477
简单版扫雷 首先设计一个二维数组，用于存放雷和周围八个格子雷的个数，再定义两个变量，用于存放地雷个数和数组大小。 使用随机数据生成雷，并给雷四周都添加1。 public class Test01 { // 扫雷 public static void main(String[] args) { int mapSize = 6; int[][] map = new i
扫雷游戏简易版
2202_75400006的博客
07-28 1693
扫雷游戏简易版
扫雷1.0简易版使用js、html、css进行制作.zip
08-19
【扫雷1.0简易版】是一款利用JavaScript（js）、HTML和CSS技术开发的小游戏，专为学习完JavaScript基础知识并希望提升实践经验的开发者设计。这个项目可以帮助初学者深入理解前端开发的基本流程，以及如何将这三种...
C语言扫雷小游戏（简易版）
08-19
【C语言扫雷小游戏（简易版）】是一个适合初学者的编程项目，它实现了基本的扫雷游戏逻辑，包括开始游戏、选择难度、查看排行榜等核心功能。虽然没有使用图形用户界面，但通过命令行交互，依然能提供游戏体验。这个...
C语言简易版扫雷+进阶版扫雷
04-14
扫雷小游戏源代码
扫雷（简单版+升级版）
weixin_60478154的博客
05-07 2692
✨作者：@平凡的人1 ✨专栏：《C语言从0到1》 ✨一句话：凡是过往，皆为序章 ✨说明: 过去无可挽回， 未来可以改变 文章目录@[toc]简单版💌game.h📄test.c📄game.c📄测试运行🔧升级版💌game.h📄test.c📄game.c📄测试运行🔧💺结语 🎁前言 大家好，今天又开始了新的篇章，本篇博客将用两种方式实现扫雷游戏的逻辑实现，第一种简单版——是直接输入一个坐标看看周围雷的数量，当然，如果你很不幸踩到雷了游戏自然game over，自然每次我们都要输入一个坐标，而不会展开，每次都.
制作扫雷（简易版）
yyy_3yu的博客
12-15 1042
这篇博客将为大家带来一个c语言写的小程序——扫雷。用到的知识——数组，函数。快来围观呀！
简化版扫雷详细解
爱敲代码的三毛的博客
01-31 2902
C语言实现简化版扫雷 如果代码有问题，希望大家能指出来！ 先简单说一下扫雷的游戏规则吧！ 《扫雷》是一款大众类的益智小游戏，游戏规则是在最短的时间内，根据点击格子出现的数字找出所有非雷格子，同时避免踩雷，踩到一个雷即全盘皆输，但许多玩过扫雷的人却仍然有一些规则不明白。 听说点赞评论的人以后工资能过万。 比如在扫雷的时候棋盘上出现的数字是什么意思？很多人可能现在都搞不懂，所以一直在用运气扫雷 比如这里的数字2，就是说明它周围与它相邻的8个位置有2个雷，同样如果是数字8那它周围全是雷。 然后就来看一下C语言
Unity 设计模式 之 行为型模式 -【状态模式】【观察者模式】【备忘录模式】
最新发布
仙魁XAN
09-23 829
设计模式是指在软件开发中为解决常见问题而总结出的一套可复用的解决方案。这些模式是经过长期实践证明有效的编程经验总结，并可以在不同的项目中复用。设计模式并不是代码片段，而是对常见问题的抽象解决方案，它提供了代码结构和模块间交互的一种设计思路，帮助开发者解决特定的设计问题。设计模式的特点：通用性：设计模式针对的是软件开发中常见的设计问题，适用于各种软件工程项目。可复用性：设计模式可以在不同项目和环境下被重复使用，提高代码的可维护性和扩展性。可扩展性：设计模式有助于让代码结构更加灵活，易于扩展和修改。
Unity3D 游戏数据本地化存储与管理详解
voidinit的专栏
09-18 1037
但是，使用JsonUtility需要手动编写序列化和反序列化的代码，增加了开发的复杂性。本文介绍了Unity3D中游戏数据的本地化存储与管理技术，包括PlayerPrefs类、JsonUtility类和SQLite数据库等。这不仅涉及到游戏状态、玩家信息、游戏设置等关键数据的保存，还关系到游戏的稳定性和用户体验。本文将详细介绍Unity3D中游戏数据的本地化存储与管理的技术方法，并给出相应的代码实现。除了选择合适的存储技术外，还需要制定合理的数据管理策略，以确保数据的完整性和安全性。csharp复制代码。
适用于QF的存档系统
2301_80005044的博客
09-20 372
今天分享一个适用于QF的存档系统这个系统的优点为1、轻量化，总共代码不超过400行2、自动化，基于QF框架，自动注入值缺点：1、不能序列化Unity内部类型，如Vector2、需要给能被序列化的类加上【Serialize】属性。
计算机毕业设计推荐-基于python的游戏资讯分享平台
BYSJLG的博客
09-18 1420
在数字化时代，游戏已成为全球范围内最受欢迎的娱乐形式之一。随着技术的进步，游戏行业经历了从简单的像素图形到复杂的虚拟现实的转变，游戏的种类和玩法也日益丰富。与此同时，玩家对于获取游戏资讯的需求也在不断增长。他们渴望了解最新的游戏动态、评测、攻略以及社区讨论，以提升游戏体验和社交互动。然而，现有的游戏资讯平台往往存在信息分散、更新不及时、用户体验不佳等问题，这限制了玩家获取信息的效率和质量。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

Nick-An

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值