[MM] 随机生成迷宫地牢

最新推荐文章于 2025-04-20 13:44:10 发布
最新推荐文章于 2025-04-20 13:44:10 发布
阅读量635 收藏 2
点赞数
分类专栏： module
本文介绍了一种基于随机算法的地牢生成方法，通过不断尝试在地图上添加房间和走廊来构建复杂的地牢结构，并确保地图中包含至少一个入口和出口。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

// Author: FreeKnight 2014-09-02
#include "stdafx.h"
#include <iostream>
#include <string>
#include <random>
#include <cassert>
 
/*
简单逻辑流程描述：
将整个地图填满土
在地图中间挖一个房间出来
选中某一房间（如果有多个的话）的墙壁
确定要修建某种新元素
查看从选中的墙延伸出去是否有足够的空间承载新的元素
如果有的话继续，不然就返回第 3 步
从选中的墙处增加新的元素
返回第 3 步，直到地牢建设完成
在地图的随机点上安排上楼和下楼的楼梯
最后，放进去怪兽和物品
*/
//-------------------------------------------------------------------------------
// 暂时支持的最大的地图块个数
#define MAX_TILES_NUM    10000
 
// 房间的大小
#define MAX_ROOM_WIDTH   8
#define MAX_ROOM_HEIGHT  8
#define MIN_ROOM_WIDTH   4
#define MIN_ROOM_HEIGHT  4
 
// 房间和走廊的合计最大个数
#define DEFAULT_FEATURE_NUM  1000
 
// 尝试生成房间和走廊的测试次数（即步长）
#define MAX_TRY_TIMES    1000
 
// 默认创建房间的概率（100-该值则为创建走廊的概率）
#define DEFAULT_CREATE_ROOM_CHANCE   70
 
// 走廊长度
#define MIN_CORRIDOR_LEN     3
#define MAX_CORRIDOR_LEN     6
//-------------------------------------------------------------------------------
// 格子块
enum class Tile
{
    Unused,  // 没用的格子（土块）
    DirtWall,    // 墙壁
    DirtFloor,   // 房间地板
    Corridor,    // 走廊
    Door,    // 房门
    UpStairs,    // 入口
    DownStairs  // 出口
};
//-------------------------------------------------------------------------------
// 朝向
enum class Direction
{
    North,   // 北
    South,   // 南
    East,    // 东
    West,    // 西
};
//-------------------------------------------------------------------------------
class Map
{
public:
 
    Map():
        xSize(0), ySize(0),
        data() { }
 
    // 构造函数，全屏填土
    Map(int x, int y, Tile value = Tile::Unused):
        xSize(x), ySize(y),
        data(x * y, value) { }
 
    // 填充某块类型
    void SetCell(int x, int y, Tile celltype)
    {
        assert(IsXInBounds(x));
        assert(IsYInBounds(y));
 
        data[x + xSize * y] = celltype;
    }
 
    // 获取某块类型
    Tile GetCell(int x, int y) const
    {
        assert(IsXInBounds(x));
        assert(IsYInBounds(y));
 
        return data[x + xSize * y];
    }
 
    // 设置一块区域为指定类型块
    void SetCells(int xStart, int yStart, int xEnd, int yEnd, Tile cellType)
    {
        assert(IsXInBounds(xStart) && IsXInBounds(xEnd));
        assert(IsYInBounds(yStart) && IsYInBounds(yEnd));
 
        assert(xStart <= xEnd);
        assert(yStart <= yEnd);
 
        for (auto y = yStart; y != yEnd + 1; ++y)
        {
            for (auto x = xStart; x != xEnd + 1; ++x)
            {
                SetCell(x, y, cellType);
            }
        }
    }
 
    // 判断一块是否在有效范围内
    bool IsXInBounds(int x) const
    {
        return x >= 0 && x < xSize;
    }
 
    // 判断一块是否在有效范围内
    bool IsYInBounds(int y) const
    {
        return y >= 0 && y < ySize;
    }
 
    // 判断一个区域是否已被使用过
    bool IsAreaUnused(int xStart, int yStart, int xEnd, int yEnd)
    {
        assert(IsXInBounds(xStart) && IsXInBounds(xEnd));
        assert(IsYInBounds(yStart) && IsYInBounds(yEnd));
 
        assert(xStart <= xEnd);
        assert(yStart <= yEnd);
 
        for (auto y = yStart; y != yEnd + 1; ++y)
        {
            for (auto x = xStart; x != xEnd + 1; ++x)
            {
                if (GetCell(x, y) != Tile::Unused)
                {
                    return false;
                }
            }
        }
 
        return true;
    }
 
    // 判断一个地图块周围是否临接某种地图块
    bool IsAdjacent(int x, int y, Tile tile)
    {
        assert(IsXInBounds(x - 1) && IsXInBounds(x + 1));
        assert(IsYInBounds(y - 1) && IsYInBounds(y + 1));
 
        return (GetCell(x - 1, y) == tile || GetCell(x + 1, y) == tile ||
            GetCell(x, y - 1) == tile || GetCell(x, y + 1) == tile);
    }
 
    // 输出地图
    void Print() const
    {
        for (auto y = 0; y != ySize; y++)
        {
            for (auto x = 0; x != xSize; x++)
            {
                switch(GetCell(x, y))
                {
                case Tile::Unused:
                    std::cout << " ";
                    break;
                case Tile::DirtWall:
                    std::cout << "#";
                    break;
                case Tile::DirtFloor:
                    std::cout << "_";
                    break;
                case Tile::Corridor:
                    std::cout << ".";
                    break;
                case Tile::Door:
                    std::cout << "+";
                    break;
                case Tile::UpStairs:
                    std::cout << "<";
                    break;
                case Tile::DownStairs:
                    std::cout << ">";
                    break;
                };
            }
 
            std::cout << std::endl;
        }
 
        std::cout << std::endl;
    }
 
private:
    // 地图总宽高
    int xSize, ySize;
    // 全部地图块数据
    std::vector<Tile> data;
};
//-------------------------------------------------------------------------------
class DungeonGenerator
{
public:
    int m_nSeed;     // 随机数种子
    int m_nXSize, m_nYSize;  // 地图最大宽高
    int m_nMaxFeatures;  // 房间和走廊的最大个数
    int m_nChanceRoom;   // 创建房间的概率【0,100】
    int m_nChanceCorridor;   // 创建走廊的概率【0,100】 该概率+创建房间的概率应当 = 100
 
    typedef std::mt19937 RngT;
public:
    DungeonGenerator( int XSize, int YSize ):
        m_nSeed(std::random_device()()),
        m_nXSize( XSize ), m_nYSize( YSize ),
        m_nMaxFeatures( DEFAULT_FEATURE_NUM ),
        m_nChanceRoom( DEFAULT_CREATE_ROOM_CHANCE )
    {
        m_nChanceCorridor = 100 - m_nChanceRoom;
    }
 
    Map Generate()
    {
        assert( m_nMaxFeatures > 0 && m_nMaxFeatures <= DEFAULT_FEATURE_NUM);
        assert( m_nXSize > 3 );
        assert( m_nYSize > 3 );
 
        auto rng = RngT(m_nSeed);
        // step1: 满地图填土
        auto map = Map(m_nXSize, m_nYSize, Tile::Unused);
 
        MakeDungeon(map, rng);
 
        return map;
    }
 
private:
    // 获取随机int
    int GetRandomInt(RngT& rng, int min, int max) const
    {
        return std::uniform_int_distribution<int>(min, max)(rng);
    }
 
    // 获取随机方向
    Direction GetRandomDirection(RngT& rng) const
    {
        return Direction(std::uniform_int_distribution<int>( static_cast<int>(Direction::North), static_cast<int>(Direction::West) )(rng));
    }
 
    // 创建走廊
    bool MakeCorridor(Map& map, RngT& rng, int x, int y, int maxLength, Direction direction) const
    {
        assert(x >= 0 && x < m_nXSize);
        assert(y >= 0 && y < m_nYSize);
 
        assert(maxLength > 0 && maxLength <= std::max(m_nXSize, m_nYSize));
 
        // 设置走廊长度
        auto length = GetRandomInt(rng, MIN_CORRIDOR_LEN, maxLength);
 
        auto xStart = x;
        auto yStart = y;
 
        auto xEnd = x;
        auto yEnd = y;
 
        if (direction == Direction::North)
            yStart = y - length;
        else if (direction == Direction::East)
            xEnd = x + length;
        else if (direction == Direction::South)
            yEnd = y + length;
        else if (direction == Direction::West)
            xStart = x - length;
 
        // 检查整个走廊是否在地图内
        if (!map.IsXInBounds(xStart) || !map.IsXInBounds(xEnd) || !map.IsYInBounds(yStart) || !map.IsYInBounds(yEnd))
            return false;
 
        // 检查走廊区域是否有被占用
        if (!map.IsAreaUnused(xStart, yStart, xEnd, yEnd))
            return false;
 
        map.SetCells(xStart, yStart, xEnd, yEnd, Tile::Corridor);
 
        return true;
    }
 
    // 创造房间
    bool MakeRoom(Map& map, RngT& rng, int x, int y, int xMaxLength, int yMaxLength, Direction direction) const
    {
        assert( xMaxLength >= MIN_ROOM_WIDTH );
        assert( yMaxLength >= MIN_ROOM_HEIGHT );
 
        // 创建的房间最小是4 * 4，随机出房间大小
        auto xLength = GetRandomInt(rng, MIN_ROOM_WIDTH, xMaxLength);
        auto yLength = GetRandomInt(rng, MIN_ROOM_HEIGHT, yMaxLength);
 
        auto xStart = x;
        auto yStart = y;
        auto xEnd = x;
        auto yEnd = y;
 
        // 根据房间朝向随机出房间起始和终结位置
        if (direction == Direction::North)
        {
            yStart = y - yLength;
            xStart = x - xLength / 2;
            xEnd = x + (xLength + 1) / 2;
        }
        else if (direction == Direction::East)
        {
            yStart = y - yLength / 2;
            yEnd = y + (yLength + 1) / 2;
            xEnd = x + xLength;
        }
        else if (direction == Direction::South)
        {
            yEnd = y + yLength;
            xStart = x - xLength / 2;
            xEnd = x + (xLength + 1) / 2;
        }
        else if (direction == Direction::West)
        {
            yStart = y - yLength / 2;
            yEnd = y + (yLength + 1) / 2;
            xStart = x - xLength;
        }
 
        // 要保证生成的房间一定四个点都在地图中
        if (!map.IsXInBounds(xStart) || !map.IsXInBounds(xEnd) || !map.IsYInBounds(yStart) || !map.IsYInBounds(yEnd))
            return false;
 
        // 要保证房间所占用土地未被其他地占用
        if (!map.IsAreaUnused(xStart, yStart, xEnd, yEnd))
            return false;
 
        // 周围种墙
        map.SetCells(xStart, yStart, xEnd, yEnd, Tile::DirtWall);
        // 房间内铺地板
        map.SetCells(xStart + 1, yStart + 1, xEnd - 1, yEnd - 1, Tile::DirtFloor);
 
        return true;
    }
 
 
    // 创建一个房间或者走廊
    bool MakeRoomOrCorridor(Map& map, RngT& rng, int x, int y, int xmod, int ymod, Direction direction) const
    {
        //  随机选择创建类型（房间或者走廊）
        auto chance = GetRandomInt(rng, 0, 100);
 
        if (chance <= m_nChanceRoom)
        {
            // 创建房间
            if (MakeRoom(map, rng, x + xmod, y + ymod, MAX_ROOM_WIDTH, MAX_ROOM_HEIGHT, direction))
            {
                // 当前位置设置门
                map.SetCell(x, y, Tile::Door);
 
                // 删除门旁边的墙壁，改建为墙壁
                map.SetCell(x + xmod, y + ymod, Tile::DirtFloor);
 
                return true;
            }
 
            return false;
        }
        else
        {
            // 创建走廊
            if (MakeCorridor(map, rng, x + xmod, y + ymod, MAX_CORRIDOR_LEN, direction))
            {
                // 当前位置设置门
                map.SetCell(x, y, Tile::Door);
 
                return true;
            }
 
            return false;
        }
    }
 
 
    // 对全地图进行随机处理生成房间和走廊
    bool MakeRandomFeature(Map& map, RngT& rng) const
    {
        for( auto tries = 0 ; tries != MAX_TRY_TIMES; ++tries)
        {
            // 获取一个有意义的地形格
            int x = GetRandomInt(rng, 1, m_nXSize - 2);
            int y = GetRandomInt(rng, 1, m_nYSize - 2);
 
            // 获取一个随机墙壁 或者 走廊
            if (map.GetCell(x, y) != Tile::DirtWall && map.GetCell(x, y) != Tile::Corridor)
                continue;
 
            // 保证该墙壁和走廊不临接门
            if (map.IsAdjacent(x, y, Tile::Door))
                continue;
 
            // 找个临接墙壁或者走廊的格子 创建新房间或者走廊
            if (map.GetCell(x, y+1) == Tile::DirtFloor || map.GetCell(x, y+1) == Tile::Corridor)
            {
                if (MakeRoomOrCorridor(map, rng, x, y, 0, -1, Direction::North))
                    return true;
            }
            else if (map.GetCell(x-1, y) == Tile::DirtFloor || map.GetCell(x-1, y) == Tile::Corridor)
            {
                if (MakeRoomOrCorridor(map, rng, x, y, 1, 0, Direction::East))
                    return true;
            }
            else if (map.GetCell(x, y-1) == Tile::DirtFloor || map.GetCell(x, y-1) == Tile::Corridor)
            {
                if (MakeRoomOrCorridor(map, rng, x, y, 0, 1, Direction::South))
                    return true;
            }
            else if (map.GetCell(x+1, y) == Tile::DirtFloor || map.GetCell(x+1, y) == Tile::Corridor)
            {
                if (MakeRoomOrCorridor(map, rng, x, y, -1, 0, Direction::West))
                    return true;
            }
        }
 
        return false;
    }
 
    // 随机制作出入口
    bool MakeRandomStairs(Map& map, RngT& rng, Tile tile) const
    {
        auto tries = 0;
        auto maxTries = MAX_TILES_NUM;
 
        for ( ; tries != maxTries; ++tries)
        {
            // 随机获取一个非边缘的点
            int x = GetRandomInt(rng, 1, m_nXSize - 2);
            int y = GetRandomInt(rng, 1, m_nYSize - 2);
 
            // 如果周围没有地板并且没有走廊（通路）的话，直接放弃
            if (!map.IsAdjacent(x, y, Tile::DirtFloor) && !map.IsAdjacent(x, y, Tile::Corridor))
                continue;
 
            // 周围不允许有门
            if (map.IsAdjacent(x, y, Tile::Door))
                continue;
 
            map.SetCell(x, y, tile);
 
            return true;
        }
 
        return false;
    }
 
    // 随机生成地牢
    bool MakeDungeon(Map& map, RngT& rng) const
    {
        // step2 : 在正中间创建一个房间
        MakeRoom(map, rng, m_nXSize / 2, m_nYSize / 2, MAX_ROOM_WIDTH, MAX_ROOM_HEIGHT, GetRandomDirection(rng));
 
        for (auto features = 1; features != m_nMaxFeatures; ++features)
        {
            if (!MakeRandomFeature(map, rng))
            {
                std::cout << "生成地牢已满。（当前房间和走廊个数为： " << features << "）." << std::endl;
                break;
            }
        }
 
        // 创建随机入口点
        if (!MakeRandomStairs(map, rng, Tile::UpStairs))
            std::cout << "创建入口点失败！" << std::endl;
 
        // 创建随机出口点
        if (!MakeRandomStairs(map, rng, Tile::DownStairs))
            std::cout << "创建出口点失败！" << std::endl;
 
        return true;
    }
};
 
 
#include <windows.h>
void ResetConsoleSize()
{
    HANDLE hOut = GetStdHandle(STD_OUTPUT_HANDLE);
    // 获取标准输出设备句柄
    CONSOLE_SCREEN_BUFFER_INFO bInfo;   // 窗口缓冲区信息
    GetConsoleScreenBufferInfo(hOut, &bInfo );
    COORD size = {1000, 800};
    SetConsoleScreenBufferSize(hOut,size);  // 重新设置缓冲区大小
    SMALL_RECT rc = {0,0, 1000-1, 800-1};   // 重置窗口位置和大小
    SetConsoleWindowInfo(hOut,true ,&rc);
}
void FlushReadme()
{
    std::cout<< "=================================" << std::endl;
    std::cout<< " < 表示入口 " << std::endl;
    std::cout<< " > 表示出口 " << std::endl;
    std::cout<< " _ 下划线表示地板 " << std::endl;
    std::cout<< " # 表示墙壁 " << std::endl;
    std::cout<< " . 点表示走廊 " << std::endl;
    std::cout<< " + 表示门 " << std::endl;
    std::cout<< "纯黑表示啥都没有，是障碍" << std::endl;
    std::cout<< "=================================" << std::endl;
}
 
int main()
{
    ResetConsoleSize();
    FlushReadme();
 
    DungeonGenerator* pGenerator = new DungeonGenerator( 150, 50 );
    if( pGenerator == NULL )
        return -1;
    auto map = pGenerator->Generate();
    map.Print();
 
    int n;
    std::cin >> n;
}
unity随机方向的代码_unity3d随机地牢生成代码
weixin_33240229的博客
01-14 643
做完了以后我又想了一下，发现其实根本不需要这么麻烦，果然demo里的代码对我的思路影响还是有点大。demo里的c++代码为了展示地牢的墙壁，在二维数组中加上了wall这个东西表示墙壁。事实上用unity来做的话，只需要考虑地板的位置，然后根据邻接的地板有没有东西来判断是否生成墙壁即可。首先用一个枚举类型代表地牢迷宫中的各个元素：public enumTile{Default,DirtFloor,/...
（原创 untiy） 随机地牢生成算法（一）
weixin_30883311的博客
03-06 661
转载注明出处：http://www.cnblogs.com/m-f-s/p/6509135.html 根据http://www.gamelook.com.cn/2015/12/239245 翻译整理 进行实现： 我最终在unity里面随机出的地牢，因为我不需要走廊所以就没有做： 生成房间 首先，你要生成一些宽和高不同的房间，随机地放在一个圈内。TKdev的...
随机地牢设计 - Random Dungeon Design
08-20
一篇英文的关于随机地牢(Dungeon)迷宫的设计
Rot.js 随机地牢，迷宫地图生成
weixin_41604051的博客
02-10 1280
js 随机地图生成插件
unity3d随机地牢生成代码
aiwanliao4788的博客
12-14 844
现在也是处于失业状态，碰巧看到个面试题是要用unity生成个随机地牢，就把做题过程中的思路和代码记录一下吧。 做完了以后我又想了一下，发现其实根本不需要这么麻烦，果然demo里的代码对我的思路影响还是有点大。demo里的c++代码为了展示地牢的墙壁，在二维数组中加上了wall这个东西表示墙壁。事实上用unity来做的话，只需要考虑地板的位置，然后根据邻接的地板有没有东西来判断是否生...
C++实现随机生成迷宫地牢
09-03
主要介绍了C++实现随机生成迷宫地牢的相关资料及代码分享，推荐给大家，有需要的小伙伴可以参考下。
c语言怎么随机生成迷宫地图,C++实现随机生成迷宫地牢
weixin_34561373的博客
05-23 2131
可以用这个地图核心做成一个无限迷宫类的游戏main.cpp// Author: FreeKnight 2014-09-02#include "stdafx.h"#include #include #include #include /*简单逻辑流程描述：将整个地图填满土在地图中间挖一个房间出来选中某一房间(如果有多个的话)的墙壁确定要修建某种新元素查看从选中的墙延伸出去是否有足够的空间承载新的元素...
C++编程：随机生成迷宫地牢算法
"C++实现随机生成迷宫地牢，主要涉及C++编程语言、随机数生成、迷宫算法和游戏开发。代码作者为FreeKnight，创建日期为2014-09-02。" 这篇内容描述了一个C++程序，用于生成随机迷宫地牢，可以作为游戏开发的基础。...
随机地牢生成器详解：迷宫算法解析
生成随机地牢的第一步是构建一个随机迷宫。实现这一目标的方法众多，涉及多种类型的算法。这些算法包括但不限于经典的如深度优先搜索 (DFS)、广度优先搜索 (BFS)、Prim's 算法或 Kruskal's 算法等，每种方法都有其...
UE5 随机生成地牢关卡和随机生成敌人
hi
11-06 834
接下来创建BP_MasterRoom的子蓝图，并添加三个箭头（绿色的），这个箭头是生成新区块的位置。这三个是场景组件，这个ExitsFolder下面的箭头等会会在子蓝图中添加。最后再创建一个蓝图，就一个可以封堵住上面区块的墙。这个Class里添加之前创建的各个子蓝图区块。这个BOX碰撞提是和地板重叠的。这里生成的区块建议选这样摆放的。创建一个新蓝图，用来生成关卡。首先创建一个父项Actor。最后在生成蓝图写写下逻辑。
Unity-RandomDungeonGenerator:随机地牢生成器的 Unity 端口 (C#) by drow
06-23
unity-RandomDungeonGenerator drow 随机地牢生成器的 Unity 端口（C#）： : 工作正在进行中 学分 图块表： ://opengameart.org/content/instant-dungeon-v14-art-pack 去做 一旦修复了所有错误，让我们开始面向对象！ 单元测试
Unity 自动迷宫生成demo
09-22
Unity 迷宫插件，通过配置自动化生成迷宫地图，适合探险类游戏的开发
Unity版本的随机迷宫.rar
03-29
可以支持理论无限大的正方形随机迷宫生成,适用于UNITY的所有版本,使用方法超级简单.需要的朋友可以下载验证下,绝对不会后悔.
unity第一人称迷宫游戏【迷踪失路】恐怖风
08-28
一个第一人称小游戏，展示了恐怖风格和迷宫的制作
迷宫生成算法和迷宫寻径算法
09-14
本源码通过C# GDI+ 编写。提供三种生成迷宫的算法（深度优先法，递归分割法，随机PRIM法），提供基于广度优先算法的迷宫自动寻径算法。迷宫大小、单元格大小、线粗均可自定义。优化了算法，递归改为栈实现，能够生成任意大地图而不会引起原来的函数递归栈溢出问题。生成迷宫后，支持键盘按键进行手动走迷宫。
Unity 2D 随机矩形地牢（房间，走廊，门）的生成（使用RuleTile和Tilemap）--第一部分
lusen_j的博客
04-20 936
网络上 2D 随机地牢生成教程多依赖繁杂公式与算法，效果却不尽人意。核心算法上，通过初始化房间坐标列表与房间数量变量，检测随机方向的可行性，循环生成房间坐标。最后，创建 ruleTile，对素材进行切割与导入。此教程以清晰易懂的步骤，帮助初学者掌握 2D 随机地牢生成要点，后续还将带来房间与走廊完整生成的深度讲解，值得期待。
Unity 2D 随机矩形地牢（房间，走廊，门）的生成（使用RuleTile和Tilemap）--第二部分
最新发布
lusen_j的博客
04-20 753
具体步骤包括创建并命名 Tilemap 为 Map，构建相应结构，创建 DungeonGenerator.cs 脚本并挂载。在编写初始代码时，设置了房间、走廊尺寸等参数，并定义了获取方向映射、检测可用方向、生成房间坐标等函数。之后阐述创建矩形房间和走廊的方法，通过生成矩形函数和计算坐标来实现。最后补充完整 InstantiateRooms 函数，实现完整的地牢生成流程。该教程逻辑清晰，避免复杂算法，适合初学者上手。
探索随机地牢生成算法的奇妙世界
gitblog_00095的博客
06-17 466
探索随机地牢生成算法的奇妙世界 去发现同类优质开源项目:https://gitcode.com/ 项目介绍 这个开源项目，以其动画演示的方式，向我们展示了随机地下城生成算法的魅力。源代码的创建灵感来源于一篇详尽的博客文章，它通过动态的方式来呈现这一算法的工作过程。尽管这可能不是最优化的实现方式，但无疑为开发者提供了一个直观的学习和实验平台。 项目技术分析 该项目的核心是一个将静态算法转化为动态演示...
【用unity实现100个游戏之16】Unity程序化生成随机2D地牢游戏3（附项目源码）
向宇
11-21 704
前两期我们使用了随机游走算法已经实现了地牢的生成，本期再说另外一种生成地牢的方法，使用二叉空间分割算法，可以用来生成规则的房间或者不规则的地牢。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值