用C语言实现 扫雷完整版 (可选游戏难度，含自定义模式)

于 2023-08-03 21:21:13 发布
阅读量742 收藏 117
点赞数 120
文章标签： c语言 游戏 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_31709205/article/details/132091915
版权

根据我不久前发布的扫雷基础版本，我做了一个扫雷完整版，有可选难度，未使用变长数组，可自定义游戏。具体内容写在代码和注释里。

创建test文件，写好整个程序的框架。这样可以让我们写代码具有明确的目的性。

#include "game.h"

//用于标记第一步不会踩雷
int FIRSTMINE = 0;

void game(int rows, int cols, int counts)
{
    //创建两个二维数组mine和show   
    char** mine = mine_creat(rows, cols);
    char** show = show_creat(rows, cols);

    InitBoard(mine, rows, cols, '0');
    InitBoard(show, rows, cols, '*');
    system("cls");
    DisplayBoard(show, rows, cols);
    SetMine(mine, rows, cols, counts);
    FindMine(mine, show, rows, cols, counts);

    //释放内存    
    for (int i = 0; i < rows; i++)
    {
        free(mine[i]);
    }
    free(mine);
    //释放内存    
    for (int i = 0; i < rows; i++)
    {
        free(show[i]);
    }
    free(show);

}

int main()
{
    int input1;
    int input2;
    int ROW4, COL4, COUNT4;

    do {
        // 打印菜单  
        print_menu1();

        // 获取用户选择  
        printf("请选择是否进行游戏:>>");
        scanf("%d", &input1);

        // 检查用户选择是否合法  
        if (input1 == 1 || input1 == 0) {
            do {

                system("cls");

                // 打印子菜单  
                print_menu2();

                // 获取用户选择  
                printf("请选择游戏难度:>>");
                scanf("%d", &input2);

                // 根据用户选择执行相应操作，值得注意的是，当game函数结束时，我们需要把FIRSTMINE重新赋值为零，否则第一步不会踩雷只能维持一局游戏
                switch (input2) {
                case 1:
                    game(ROW1, COL1, COUNT1);
                    FIRSTMINE = 0;
                    break;
                case 2:
                    game(ROW2, COL2, COUNT2);
                    FIRSTMINE = 0;
                    break;
                case 3:
                    game(ROW3, COL3, COUNT3);
                    FIRSTMINE = 0;
                    break;
                case 4:
                    printf("请输入尺寸 X Y 和雷的数量 N :");
                    scanf("%d %d %d", &ROW4, &COL4, &COUNT4);
                    ROW4 += 2;
                    COL4 += 2;
                    game(ROW4, COL4, COUNT4);
                    FIRSTMINE = 0;
                    break;
                default:
                    printf("选项错误，请重新选择！！！\n");
                }
            } while (input2 != 1 && input2 != 2 && input2 != 3 && input2 != 4);
        }
        else {
            printf("选项错误，请重新选择！！！\n");
        }
    } while (input1);

    return 0;
}

创建game.h文件，同时我们定义了三种难度下的棋盘的尺寸以及对应的雷的数量。当然了，自定义模式下的尺寸和雷的数量是交给用户决定的。接下来我们规定了每一种函数的参数以及其返回类型和我们希望的函数所具备的功能。

#define _CRT_SECURE_NO_WARNINGS
#pragma once

#define ROW1 11
#define COL1 11
#define COUNT1 10
#define ROW2 18
#define COL2 18
#define COUNT2 40
#define ROW3 18
#define COL3 32
#define COUNT3 99

#include <stdio.h>
#include <time.h>
#include <windows.h>
#include <stdbool.h>  
#include <stdlib.h>  

//打印菜单一
void  print_menu1();

//打印菜单二
void  print_menu2();

//通过动态内存创建mine数组，并初始化为 '0'  
char** mine_creat(int x, int y);

//通过动态内存创建show数组 ，并初始化为 '0'   
char** show_creat(int x, int y);

// 初始化棋盘
void InitBoard(char** p, int rows, int cols, char ch);

// 展示棋盘
void DisplayBoard(char** board, int rows, int cols);

// 设置雷
void SetMine(char** board, int rows, int cols, int counts);

//玩家指定坐标进行排雷或标雷
void FindMine(char** mine_board, char** show_board, int rows, int cols, int counts);

//游戏的实现
void game(int rows, int cols, int counts);

创建game.c文件

#include "game.h"

//用于标记第一步不会踩雷
extern FIRSTMINE;

//打印菜单一
void  print_menu1()
{
	printf("***************************\n");
	printf("******  1. 开始游戏  ******\n");
	printf("******  0. 退出游戏  ******\n");
	printf("***************************\n");
}

//打印菜单二
void  print_menu2()
{
	printf("***************************\n");
	printf("******  1. 初级难度  ******\n");
	printf("******  2. 中级难度  ******\n");
	printf("******  3. 高级难度  ******\n");
	printf("******  4. 自由定义  ******\n");
	printf("***************************\n");
}

//通过动态内存创建mine数组，并初始化为 '0'  
char** mine_creat(int x, int y)
{
    char** mine = (char**)malloc(x * sizeof(char*));
    for (int i = 0; i < x; i++)
    {
        mine[i] = (char*)malloc(y * sizeof(char));
        for (int j = 0; j < y; j++)
        {
            mine[i][j] = '0';
        }
    }
    return mine;
}

//通过动态内存创建show数组 ，并初始化为 '0'   
char** show_creat(int x, int y)
{
    char** show = (char**)malloc(x * sizeof(char*));
    for (int i = 0; i < x; i++)
    {
        show[i] = (char*)malloc(y * sizeof(char));
        for (int j = 0; j < y; j++)
        {
            show[i][j] = '0';
        }
    }
    return show;
}

//初始化棋盘，初始化为 ch
void InitBoard(char** board, int row, int col, char ch)
{
    for (int i = 0; i < row; ++i)
    {
        for (int j = 0; j < col; ++j)
        {
            board[i][j] = ch;
        }
    }
}

// 展示棋盘
void DisplayBoard(char** board, int rows, int cols)
{
    int i = 0;
    int j = 0;

    printf("游戏提示，需要扫开所有的非雷区域后才可以胜利哦！\n\n");

    //打印横坐标
    printf("   ");
    for (j = 1; j < cols - 1; ++j)
    {
        if (j < 9)
        {
            printf(" %d ", j);
        }
        else if (j == 9)
        {
            printf(" %d  ", j);
        }
        else
        {
            printf("%d ", j);
        }
    }
    printf("\n");

    //打印横向上边界
    printf("-----");
    for (i = 1; i < cols - 1; ++i)
    {
        printf("---");
    }

    printf("\n");
    for (i = 1; i < rows - 1; ++i)
    {
        if (i <= 9)
        {
            printf("%d | ", i);
        }
        else
        {
            printf("%d| ", i);
        }
        for (j = 1; j < cols - 1; ++j)
        {
            if (j == cols - 2)
            {
                printf(" %c |", board[i][j]);
            }
            else if (j == 1)
            {
                printf("%c ", board[i][j]);
            }
            else
            {
                printf(" %c ", board[i][j]);
            }
        }
        printf("\n");
    }

    //打印横向下边界
    printf("-----");
    for (i = 1; i < cols - 1; ++i)
    {
        printf("---");
    }
    printf("\n");

}

//放置雷
void SetMine(char** mine_board, int rows, int cols, int counts)
{
    // 设置的雷的数量  
    while (counts)
    {
        int x = rand() % rows - 1;
        int y = rand() % cols - 1;
        if (x > 0 && y > 0 && x <= rows - 1 && y <= cols - 1)
        {
            if (mine_board[x][y] == '0') // 确保该位置没有雷  
            {
                mine_board[x][y] = 'M'; // 将该位置设置为雷  
                counts--;
            }
        }
    }
}

// 检查周围的雷的数量
static int GetMineCount(char** mine_board, int rows, int cols, int x, int y)
{
    int count = 0;
    int i = 0;
    int j = 0;
    for (i = x - 1; i <= x + 1; ++i)
    {
        for (j = y - 1; j <= y + 1; ++j)
        {
            if (i >= 0 && i < rows && j >= 0 && j < cols && mine_board[i][j] == 'M')
            {
                count++;
            }
        }
    }
    return count;
}

//实现扫雷的递归展开
static void OpenBoard(char** mine_board, char** show_board, int rows, int cols, int x, int y)
{
    int i = 0;
    int j = 0;
    int count = GetMineCount(mine_board, rows, cols, x, y);

    //如果点位(x,y)周围的雷的数量是零，则进入该语句
    if (count == 0)
    {
        show_board[x][y] = ' ';//防止重复递归导致栈溢出
        for (i = x - 1; i <= x + 1; i++)
        {
            for (j = y - 1; j <= y + 1; j++)
            {
                if (i > 0 && j > 0 && i < rows - 1 && j < cols - 1 && (show_board[i][j] == '*') && (show_board[i][j] != '#') && (mine_board[i][j] != '1'))
                    OpenBoard(mine_board, show_board, rows, cols, i, j);//递归，连续展开
            }
        }
    }
    else
    {
        show_board[x][y] = count + '0';
    }
}

//统计全局当中还未被排开的雷的总数
static int Number(char** board, int rows, int cols)
{
    int i = 0;
    int j = 0;
    int count = 0;
    for (i = 1; i < rows - 1; i++)
    {
        for (j = 1; j < cols - 1; j++)
        {
            if (board[i][j] == '*' || board[i][j] == '#')//未被展开的点和已经被标记的点都要算上去
            {
                count++;
            }
        }
    }
    return count;
}

//玩家指定坐标进行排雷或标雷
void FindMine(char** mine_board, char** show_board, int rows, int cols, int counts)
{
    int m = 0;
    int x = 0;
    int y = 0;
    int x0 = 0;
    int y0 = 0;
    int number = Number(show_board, rows, cols);

    while (number > counts)
    {
        printf("要扫雷请输入1，要标雷请输入0，请输入:>>");
        scanf("%d", &m);

        if (m == 0)
        {
            printf("已进入标记模式，请输入要标雷的位置坐标(格式：x y)：");
            scanf("%d %d", &x0, &y0);
            if (x0 >= 0 && x0 < rows - 1 && y0 >= 0 && y0 < cols - 1)
            {
                show_board[x0][y0] = '#';
                system("cls");
                DisplayBoard(show_board, rows, cols);
            }
            else
            {
                printf("坐标超出范围，请重新输入。\n");
            }
            // 每次排雷结束后计算还未被扫到的数量，当未扫到的数量等于雷的数量，则游戏成功  
            number = Number(show_board, rows, cols);
            if (number == counts)
                break;
        }
        else if (m == 1)
        {
            printf("请输入要排查的坐标(格式: x y )：");
            scanf("%d %d", &x, &y);
            // 如果第一步是雷，则把第一个雷清除掉，重新再放置一个雷，放置结束后把标志FIRSTMINE赋值为1  
            if ((mine_board[x][y] == 'M') && (FIRSTMINE == 0))
            {
                mine_board[x][y] = '0';
                SetMine(mine_board, rows, cols, counts);
                FIRSTMINE = 1;
            }

            FIRSTMINE = 1;//第一步结束后把标志FIRSTMINE赋值为1

            if (x >= 0 && x < rows - 1 && y >= 0 && y < cols - 1)
            {
                if (mine_board[x][y] == 'M') // 踩到雷，游戏结束  
                {
                    show_board[x][y] = mine_board[x][y];
                    printf("很遗憾，你踩到了雷！游戏结束。\n");
                    break;
                }
                else
                {
                    show_board[x][y] = mine_board[x][y];
                    if (mine_board[x][y] == '0') // 如果排雷的位置是0，翻开周围的位置  
                    {
                        OpenBoard(mine_board, show_board, rows, cols, x, y);
                    }
                    system("cls");
                    DisplayBoard(show_board, rows, cols);
                }
            }
            else
            {
                printf("坐标超出范围，请重新输入。\n");
            }

            // 每次排雷结束后计算还未被扫到的数量，当未扫到的数量等于雷的数量，则游戏成功  
            number = Number(show_board, rows, cols);
        }
        else
        {
            printf("输入错误，请重新输入。\n");
        }
    }
    if (number == counts)
    {
        printf("\n恭喜你游戏成功！！！！\n");
    }
}

游戏的运行：

 

 

 

 

 

 

 

 

 

 

Herta_
关注
  • 120
    点赞
  • 踩
  • 117
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 2
    评论
使用C语言实现自定义难度游戏——扫雷
weixin_42438990的博客
05-24 1595
game.h #define _CRT_SECURE_NO_WARNINGS #include<stdio.h> #include<stdlib.h> #include<time.h> #include<string.h> #include<Windows.h> #define H 9 #define L 9 #define H2 H+...
C语言实现扫雷小游戏(扩展版可选择游戏难度)
08-25
游戏目标是找出所有没有地雷的方格，完成游戏；要是按了有地雷的方格，游戏失败；玩家可标记雷的位置,游戏以完成时间来评高低,并且用户可以选择游戏难度
C语言实现扫雷游戏(超详细讲解+全部源码)
m0_58950498的博客
10-24 4811
使用C语言实现扫雷游戏
扫雷——C语言【详解+全部码源】
2201_75366661的博客
02-10 6307
扫雷详解，附全部码源，还不来看看吗
扫雷 C语言源代码
03-11
C语言源程序，带注释
C语言实现扫雷游戏及其优化
08-25
主要为大家详细介绍了C语言实现扫雷游戏及其优化，具有一定的参考价值，感兴趣的小伙伴们可以参考一下
C语言实现简单扫雷小游戏
01-01
本文实例为大家分享了C语言实现扫雷小游戏的具体代码，供大家参考，具体内容如下 #define _CRT_SECURE_NO_WARNINGS #include #include #include /* 用 C 语言写一个简单的扫雷游戏 */ // 1.写一个游戏菜单 Menu...
小白C语言实现扫雷游戏
最新发布
02-17
利用函数和数组的有关知识，C语言实现简单的扫雷游戏，有助于刚学习C语言的新手对于代码和逻辑结构的理解和运用，比较有价值
c语言扫雷如何修改游戏难度,帕斯卡契约难度怎么改 中途修改游戏难度方法
weixin_35256923的博客
05-22 238
帕斯卡契约如何才可以修改这个游戏的难度呢?许多玩家觉得太简单了或者是太难了，导致无法继续玩下去，那么能不能修改游戏的难度，在哪才可以进行修改，下面小编就为大家介绍一下方法吧。修改难度方法：在游戏中可以进行修改难度哦，但是需要注意以下几点：就是如果你是普通难度的话，可以点击修改，然后来切换成为轻松模式，也就是高难度如果不适合，可以切换成为简单难度。但是如果你选择了简单难度，就不能切换成为普通难度了，...
【C语言游戏】扫雷游戏（含递归展开，难度选择，雷位标记等功能）
芥末虾的博客
09-08 2874
游戏功能： 1. 难度选择 2. 为棋盘动态分配内存 3. 自动调整窗口大小 4. 标记雷位 5. 递归展开 6. 优化游戏界面，提高游戏体验
自定义地雷数的扫雷（控制台运行）
weixin_52511846的博客
10-29 1006
本次项目是使用控制台打印扫雷布雷的结果
控制台实现扫雷游戏（C语言、空白区展开、自定义设置、标记地雷,超级详细哦）
ZHIYU0707的博客
08-03 1268
/******************mine_clearance.c中******************////自定义游戏设置int CustomizeSettings() //（mine_clearance.c中）int MINES;printf(">>自定义游戏设置
C语言实现入门级小游戏
热门推荐
Living_Amethyst的博客
11-10 1万+
上一期咱们用C语言实现了三子棋的小游戏 C语言实现三子棋 今天我们再来写个扫雷的游戏，说起扫雷，相信大家都不陌生，可能许多朋友还是玩扫雷的高手。 其实扫雷和三子棋有许多相似之处，都需要用到数组的知识。 今天的扫雷也是相当有趣的 由于博主是一个编程学习的小白，所以这只是扫雷的初级版，此版本有一些功能还无法实现，在后续的学习中，我会持续更新，不断对这个小游戏进行优化，期待大家的关注，还有，这篇文章中若有错误或不当的地方，欢迎大家指正！ 关于这个扫雷项目的代码，.........
详解C语言实现扫雷游戏
weixin_73053512的博客
05-13 1683
优点实现了扫雷函数的大部分功能，比如展开，标记，清除标记等等。游戏难度没办法由玩家手动设置，扫雷过程中标记和清除标记的顺序比较固定，这些交由读者来完善~
C语言小项目 -- 扫雷游戏完整代码（递归展开 + 选择标记）
IfYouHave的博客
04-11 3687
扫雷是一款大众类的益智小游戏，于1992年发行。游戏目标是在最短的时间内根据点击格子出现的数字找出所有非雷格子，同时避免踩雷，踩到一个雷即全盘皆输。
C语言实现扫雷游戏
m0_47179741的博客
08-17 2257
C语言实现扫雷游戏
C语言扫雷（递归展开）（详细注释）（完整代码）
AAAAA_9的博客
08-02 7810
c语言扫雷游戏
数据结构(C语言版)——共享栈(代码版)
qq_42683219的博客
09-23 558
一、代码 #include <stdio.h> #include <stdlib.h> #define OK 1 #define ERROR 0 #define MAXSIZE 10 typedef int Status; typedef struct sharingStack{ int data[MAXSIZE]; int top; int bottom; }Stack; typedef struct sharingStack* SHARINGSTACKPOINTER
手把手教你写个扫雷程序自己玩
patrick的博客
02-03 6300
文章目录 前言 一、扫雷是什么？ 二、代码详解(模块化) 1.创建文件 2.test.c 3.game.c 4.game.h 总结 前言 相信大家过年玩游戏玩王者都玩腻了吧,就算没有玩腻,也被各种队友坑得再也没有玩游戏的欲望了吧。真要玩游戏，还得看单机游戏。 扫雷才是永远的神！ 一、扫雷是什么？ 在写程序之前,我们必须先要了解扫雷游戏的原理:我们随便打开一个扫雷游戏： 我们可以看到：许多小正方形组成了一个大的正方形平面，我们点击其中一个正方形，如果他不是.
扫雷自定义最难C语言,C语言实现扫雷小游戏(扩展版可选择游戏难度)
05-26
实现扫雷小游戏涉及到的主要步骤包括生成雷区、处理用户输入、显示游戏界面等。以下是一个简单的扫雷游戏实现，包括自定义难度的扩展版： ```c #include <stdio.h> #include <stdlib.h> #include <time.h> // 定义雷区的宽度、高度、雷数和难度级别 #define WIDTH 10 #define HEIGHT 10 #define MINES 15 #define EASY 0 #define MEDIUM 1 #define HARD 2 // 定义雷区的格子状态 #define COVERED 0 #define UNCOVERED 1 #define FLAGGED 2 // 定义游戏状态 #define PLAYING 0 #define WON 1 #define LOST 2 // 定义计算周围雷数的辅助数组 int dx[] = {-1, -1, -1, 0, 0, 1, 1, 1}; int dy[] = {-1, 0, 1, -1, 1, -1, 0, 1}; // 定义雷区和游戏状态变量 int mines[WIDTH][HEIGHT]; int board[WIDTH][HEIGHT]; int state = PLAYING; // 初始化雷区 void init_mines() { int i, j, k, x, y; // 先将雷区全部标记为空 for (i = 0; i < WIDTH; i++) { for (j = 0; j < HEIGHT; j++) { mines[i][j] = 0; } } // 随机生成雷的位置 for (k = 0; k < MINES; k++) { do { x = rand() % WIDTH; y = rand() % HEIGHT; } while (mines[x][y] != 0); mines[x][y] = 1; } } // 计算指定格子周围的雷数 int count_mines(int x, int y) { int i, nx, ny, count = 0; for (i = 0; i < 8; i++) { nx = x + dx[i]; ny = y + dy[i]; if (nx >= 0 && nx < WIDTH && ny >= 0 && ny < HEIGHT) { count += mines[nx][ny]; } } return count; } // 显示游戏界面 void display_board() { int i, j; printf(" "); for (i = 0; i < WIDTH; i++) { printf("%d ", i); } printf("\n"); printf(" "); for (i = 0; i < WIDTH; i++) { printf("- "); } printf("\n"); for (i = 0; i < HEIGHT; i++) { printf("%d| ", i); for (j = 0; j < WIDTH; j++) { if (state == LOST && mines[j][i] == 1) { printf("* "); } else if (board[j][i] == COVERED) { printf(". "); } else if (board[j][i] == FLAGGED) { printf("F "); } else { printf("%d ", count_mines(j, i)); } } printf("\n"); } } // 处理玩家输入 void handle_input() { int x, y; char action; printf("Enter action (u: uncover, f: flag): "); scanf("%c", &action); printf("Enter coordinates (x y): "); scanf("%d %d", &x, &y); getchar(); if (x < 0 || x >= WIDTH || y < 0 || y >= HEIGHT) { printf("Invalid coordinates!\n"); return; } if (action == 'u') { // 如果玩家选择了揭开格子，检查该格子是否已经揭开或者标记为旗帜 if (board[x][y] == UNCOVERED || board[x][y] == FLAGGED) { printf("Invalid action!\n"); return; } if (mines[x][y] == 1) { // 如果玩家揭开了一个雷，游戏结束 state = LOST; } else { // 否则，揭开该格子，并检查是否揭开了整个雷区 board[x][y] = UNCOVERED; int i, j, uncovered = 0; for (i = 0; i < WIDTH; i++) { for (j = 0; j < HEIGHT; j++) { if (board[i][j] == UNCOVERED) { uncovered++; } } } if (uncovered == WIDTH * HEIGHT - MINES) { state = WON; } } } else if (action == 'f') { // 如果玩家选择了标记旗帜，检查该格子是否已经揭开 if (board[x][y] == UNCOVERED) { printf("Invalid action!\n"); return; } board[x][y] = (board[x][y] == FLAGGED) ? COVERED : FLAGGED; } else { printf("Invalid action!\n"); return; } } int main() { int level; printf("Enter level (0: easy, 1: medium, 2: hard): "); scanf("%d", &level); // 根据难度级别设置雷数 if (level == EASY) { MINES = 10; } else if (level == MEDIUM) { MINES = 20; } else if (level == HARD) { MINES = 30; } else { printf("Invalid level!\n"); return 1; } printf("Welcome to Minesweeper!\n"); srand(time(NULL)); init_mines(); while (state == PLAYING) { display_board(); handle_input(); } display_board(); if (state == WON) { printf("Congratulations, you won!\n"); } else { printf("Sorry, you lost!\n"); } return 0; } ``` 在这个实现中，我们使用了一个 `mines` 数组来表示雷区，其中 `mines[x][y]` 为 1 表示该格子为雷，为 0 表示该格子不是雷。另外，我们使用一个 `board` 数组来表示游戏界面，其中 `board[x][y]` 表示第 x 列、第 y 行格子的状态，可以为 COVERED（未揭开）、UNCOVERED（已揭开）或 FLAGGED（标记了旗帜）。`state` 变量表示游戏状态，可以为 PLAYING（正在进行中）、WON（已经胜利）、LOST（已经失败）。 在 `init_mines` 函数中，我们先将雷区全部标记为空，然后随机生成 `MINES` 个雷的位置。在 `count_mines` 函数中，我们计算指定格子周围的雷数。在 `display_board` 函数中，我们打印出游戏界面。在 `handle_input` 函数中，我们处理玩家输入。如果玩家选择了揭开格子，我们检查该格子是否已经揭开或者标记为旗帜，如果该格子是雷，游戏结束，否则揭开该格子，并检查是否揭开了整个雷区。如果玩家选择了标记旗帜，我们检查该格子是否已经揭开，然后将其状态设置为 COVERED 或 FLAGGED。最后，在主函数中，我们根据玩家选择的难度级别设置雷数，然后循环显示游戏界面并处理玩家输入，直到游戏结束。 这个实现是一个简单的扫雷游戏实现，可以根据自己的需要进行修改和扩展。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

Herta_

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

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

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

打赏作者

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

抵扣说明：

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

余额充值