.Net Micro Framework研究—用MF编写俄罗斯方块

最新推荐文章于 2022-07-23 18:29:31 发布
最新推荐文章于 2022-07-23 18:29:31 发布
阅读量7.1k 收藏 12
点赞数
分类专栏： 〖.Net MF〗 〖嵌入式〗 文章标签： .net colors 游戏 math windows 平台
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/yfiot/article/details/2023960
版权

          上次编写俄罗斯方块，好像是N年前的大学时代，使用TC2.0在DOS平台上开发的，由于当时的代码是保存在3.5寸软盘上的，到现在那些程序早已经作了古，没有了踪影。俄罗斯方块其实编写并不太容易，要考虑的东西还是蛮多的，以前想在PPC上用.Net精简框架集实现，后来起了个头，没有太大的动力，也就作罢了。现在对MF充满了激情，所以从零做起（没有参考任何现成代码，只不过还是依照我早期的思路编写而成），花费我大半天的时间才编写完毕（在编写过程中，还发现MF对二维数组支持不大好，我后面会提到）。

好了，让我们在.Net Micro Framework模拟器（由于我这里没有带LCD屏的MF开发板，所以很遗憾，不知道在实际的设备上该程序的性能会怎样）上体验一下俄罗斯方块游戏吧。
进入MF Windows（姑且这么叫吧），单击“开始”菜单按钮（MF平台不支持鼠标，是单击模拟器上的Menu按钮，或在键盘敲“空格”或“Windows”键），我们用光标键选中“俄罗斯方块”游戏，按OK键（或按键盘上的“回车”键）进入游戏。
通过开始菜单进入“俄罗斯方块”游戏
编写的俄罗斯方块游戏可是具备经典版的所有功能哟！可以翻转，可以移动，可以得分，可以快速降落等等！要认真玩，否则很快就“Game Over”的。
 
 
在编写过程中发现MF对二维数组支持不是太好。
下面的代码编译时会报错：
bool[,] bFlag=new bool[10,20];
所以在MF中二维数组必须这样声明才行：
bool [][] bShowFlag = new bool[22][];             // 主显示区含边框    
    for (int i = 0; i < 22; i++)
     {
  bShowFlag[i] = new bool[12];
}
 
附：MF俄罗斯方块核心代码
 
 //俄罗斯方块(叶帆工作室：http://blog.csdn.net/yefanqiu)
        public class ElsGame
        {
            int Current_Y = -2, Current_X =3;
            int intGrade = 0;
            bool[][] bShowFlag = new bool[22][];             // 主显示区含边框     
            bool[][] bMetaShowFlag = new bool[4][];          // 下一个方块显示区
            bool[][] bCurrentMetaShowFlag = new bool[4][];   // 当前方块显示区
 
            int intNextNo = 0;                               // 下一个方块索引
            int intCurrentNo = 0;                            // 当前方块索引
 
            enum MoveWay{Left,Down,Right};
            DispatcherTimer GameTimer;                       // 游戏时钟
 
            bool bGameRunFlag = false;                       // 游戏运行标志
 
            public ElsGame(DispatcherTimer GameTimer)
            {
                this.GameTimer = GameTimer;
                Init();
            }
 
            // 元素
            private bool[][] GetElsMeta(int intNo)
            {
                bool[][] ElsMetaFlag = new bool[4][];
                for (int i = 0; i < 4; i++)
                {
                    ElsMetaFlag[i] = new bool[4];
                }
                switch (intNo)
                {
                    case 0:   // 田
                        ElsMetaFlag[1][1] = true;
                        ElsMetaFlag[1][2] = true;
                        ElsMetaFlag[2][1] = true;
                        ElsMetaFlag[2][2] = true;
                        return ElsMetaFlag;
                    case 1: //-
                        ElsMetaFlag[2][0] = true;
                        ElsMetaFlag[2][1] = true;
                        ElsMetaFlag[2][2] = true;
                        ElsMetaFlag[2][3] = true;
                        return ElsMetaFlag;
                    case 2: //|
                        ElsMetaFlag[0][2] = true;
                        ElsMetaFlag[1][2] = true;
                        ElsMetaFlag[2][2] = true;
                        ElsMetaFlag[3][2] = true;
                        return ElsMetaFlag;
                    case 3: // ┻
                        ElsMetaFlag[1][2] = true;
                        ElsMetaFlag[2][1] = true;
                        ElsMetaFlag[2][2] = true;
                        ElsMetaFlag[2][3] = true;
                        return ElsMetaFlag;
                    case 4: // ┣
                        ElsMetaFlag[2][2] = true;
                        ElsMetaFlag[1][1] = true;
                        ElsMetaFlag[2][1] = true;
                        ElsMetaFlag[3][1] = true;
                        return ElsMetaFlag;
                    case 5: // ┳
                        ElsMetaFlag[2][2] = true;
                        ElsMetaFlag[1][1] = true;
                        ElsMetaFlag[1][2] = true;
                        ElsMetaFlag[1][3] = true;
                        return ElsMetaFlag;
                    case 6: // ┫
                        ElsMetaFlag[2][1] = true;
                        ElsMetaFlag[1][2] = true;
                        ElsMetaFlag[2][2] = true;
                        ElsMetaFlag[3][2] = true;
                        return ElsMetaFlag;
                    case 7: // ┖
                        ElsMetaFlag[3][2] = true;
                        ElsMetaFlag[1][1] = true;
                        ElsMetaFlag[2][1] = true;
                        ElsMetaFlag[3][1] = true;
                        return ElsMetaFlag;
                    case 8: // ┍
                        ElsMetaFlag[2][1] = true;
                        ElsMetaFlag[1][1] = true;
                        ElsMetaFlag[1][2] = true;
                        ElsMetaFlag[1][3] = true;
                        return ElsMetaFlag;
                    case 9: // ┒
                        ElsMetaFlag[1][1] = true;
                        ElsMetaFlag[1][2] = true;
                        ElsMetaFlag[2][2] = true;
                        ElsMetaFlag[3][2] = true;
                        return ElsMetaFlag;
                    case 10: // ┙
                        ElsMetaFlag[1][3] = true;
                        ElsMetaFlag[2][1] = true;
                        ElsMetaFlag[2][2] = true;
                        ElsMetaFlag[2][3] = true;
                        return ElsMetaFlag;
                    case 11: // ┕
                        ElsMetaFlag[1][1] = true;
                        ElsMetaFlag[2][1] = true;
                        ElsMetaFlag[2][2] = true;
                        ElsMetaFlag[2][3] = true;
                        return ElsMetaFlag;
                    case 12: // ┎
                        ElsMetaFlag[1][2] = true;
                        ElsMetaFlag[1][1] = true;
                        ElsMetaFlag[2][1] = true;
                        ElsMetaFlag[3][1] = true;
                        return ElsMetaFlag;
                    case 13: // ┑
                        ElsMetaFlag[2][3] = true;
                        ElsMetaFlag[1][1] = true;
                        ElsMetaFlag[1][2] = true;
                        ElsMetaFlag[1][3] = true;
                        return ElsMetaFlag;
                    case 14: // ┚
                        ElsMetaFlag[3][1] = true;
                        ElsMetaFlag[1][2] = true;
                        ElsMetaFlag[2][2] = true;
                        ElsMetaFlag[3][2] = true;
                        return ElsMetaFlag;
                }
                return null;
            }
 
            // 翻转
            private int GetTurnMeta(int intNo)
            {
                switch (intNo)
                {
                    case 0:   // 田
                        return 0;
                    case 1: //-
                        return 2;
                    case 2: //|
                        return 1;
                    case 3: // ┻
                        return 4;
                    case 4: // ┣
                        return 5;
                    case 5: // ┳
                        return 6;
                    case 6: // ┫
                        return 3;
                    case 7: // ┖
                        return 8;
                    case 8: // ┍
                        return 9;
                    case 9: // ┒
                        return 10;
                    case 10: // ┙
                        return 7;
                    case 11: // ┕
                        return 12;
                    case 12: // ┎
                        return 13;
                    case 13: // ┑
                        return 14;
                    case 14: // ┚
                        return 11;
                }
                return intNo;
            }
 
            // 初始化
            public void Init()
            {
                if (!bGameRunFlag)
                {
                    // 主显示区
                    for (int i = 0; i < 22; i++)
                    {
                        bShowFlag[i] = new bool[12];
                        for (int j = 0; j < 12; j++)
                        {
                            if (i == 21 || j == 0 || j == 11)
                            {
                                bShowFlag[i][j] = true;
                            }
                            else
                            {
                                bShowFlag[i][j] = false;
                            }
                        }
                    }
 
                    // 辅助显示区
                    for (int i = 0; i < 4; i++)
                    {
                        bMetaShowFlag[i] = new bool[4];
                        for (int j = 0; j < 4; j++)
                        {
                            bMetaShowFlag[i][j] = false;
                        }
                    }
 
                    // 方块初始化
                    Microsoft.SPOT.Math.Randomize();
 
                    intCurrentNo = Microsoft.SPOT.Math.Random(15);
                    bCurrentMetaShowFlag = GetElsMeta(intCurrentNo);
 
                    intNextNo = Microsoft.SPOT.Math.Random(15);
                    bMetaShowFlag = GetElsMeta(intNextNo);
 
                    // 时钟开始
                    GameTimer.Start();
 
                    // 积分清零
                    intGrade = 0;
 
                    // 游戏运行标志
                    bGameRunFlag = true;
                }
            }
 
            // 下降
            public bool DoDownMove()
            {
               if (IsMove(Current_X, Current_Y, bCurrentMetaShowFlag, MoveWay.Down) && bGameRunFlag)
                {
                    Current_Y++;
                    MoveBlock(Current_X, Current_Y, bCurrentMetaShowFlag, MoveWay.Down);                   
                }
                else
                {
                   // 时钟恢复正常
                    GameTimer.Interval = new TimeSpan(0, 0, 1);
                    // 判断是否得分及游戏是否结束
                    int intRet=GetGameState() ;
                    if (intRet == -1)
                    {
                        GameTimer.Stop();
                        bGameRunFlag = false;
                        // 主显示区
                        for (int i = 0; i < 22; i++)
                        {
                            bShowFlag[i] = new bool[12];
                            for (int j = 0; j < 12; j++)
                            {
                                if (i==1 || i == 20 || j == 1 || j == 10)
                                {
                                    bShowFlag[i][j] = true;
                                }
                                else
                                {
                                    bShowFlag[i][j] = false;
                                }
                            }
                        }
                    }
                    else
                    {
                        intGrade += intRet;
                        Current_Y = -3;
                        Current_X = 3;
                        NextBlock();
                    }
                }
                return true;
            }
 
            // 判断游戏状态
            private int GetGameState()
            {
                bool bFlag = false;
                int intNum = 0;
                // 判断游戏是否结束
                for (int i = 1; i < 11; i++)
                {
                    if (bShowFlag[1][i])
                    {
                        return -1;
                    }
                }
 
                // 判断得分
                for (int i = 1; i < 21; i++)
                {
                    bFlag = true;
                    for (int j = 1; j < 11; j++)
                    {
                        if (!bShowFlag[i][j]) bFlag = false;
                    }
                    if (bFlag)
                    {
                        // 移动数组
                        for (int e = i; e>0; e--)
                        {
                            for (int k = 1; k < 11; k++)
                            {
                                bShowFlag[e][k] =bShowFlag[e-1][k];
                            }
                        }
                        intNum++;
                    }
                }
                switch (intNum)
                {
                    case 1:
                        intNum = 100;
                        break;
                    case 2:
                        intNum = 300;
                        break;
                    case 3:
                        intNum = 500;
                        break;
                    case 4:
                        intNum = 800;
                        break;
                }
                return intNum;
            }
 
            // 左移
            public bool DoLeftMove()
            {
                if (!bGameRunFlag) return false;
                if (IsMove(Current_X, Current_Y, bCurrentMetaShowFlag, MoveWay.Left))
                {
                    Current_X--;
                    MoveBlock(Current_X, Current_Y, bCurrentMetaShowFlag, MoveWay.Left);
                    return true;
                }
                return false;
            }
 
            // 右移
            public bool DoRightMove()
            {
                if (!bGameRunFlag) return false;
                if (IsMove(Current_X, Current_Y, bCurrentMetaShowFlag, MoveWay.Right))
                {
                    Current_X++;
                    MoveBlock(Current_X, Current_Y, bCurrentMetaShowFlag, MoveWay.Right);
                    return true;
                }
                return false;
            }
                           
            // 方块翻转
            public bool DoTurn()
            {
                if (!bGameRunFlag) return false;
                #region // 判断是否能翻转
                int mX=0, mY = 0;
                bool bFlag = true;
                // 翻转后的标志
                bool[][] bFlags = GetElsMeta(GetTurnMeta(intCurrentNo));
                SetBlock(Current_X, Current_Y, bCurrentMetaShowFlag, false);              
                for (int i = 0; i < 4; i++)
                {
                    for (int j = 0; j < 4; j++)
                    {
                        mX = Current_X + j + 1;
                        mY = Current_Y + i + 1;
                        if (mX > -1 && mX < 12 && mY > -1 && mY < 22)
                        {
                            if (bShowFlag[mY][mX] && bFlags[i][j])
                            {
                                bFlag = false;
                            }
                        }
                    }
                }
                SetBlock(Current_X, Current_Y, bCurrentMetaShowFlag, true);
                #endregion
 
                if (bFlag)
                {
                    SetBlock(Current_X, Current_Y, bCurrentMetaShowFlag, false);
                    intCurrentNo = GetTurnMeta(intCurrentNo);
                    bCurrentMetaShowFlag = GetElsMeta(intCurrentNo);
                    SetBlock(Current_X, Current_Y, bCurrentMetaShowFlag, true);
                    return true;
                }
                return false;
            }
 
            // 设置方块
            private void SetBlock(int X, int Y, bool[][] bFlags, bool bFlag)
            {
                 略 ;-)
            }
 
            // 下一个方块
            private void NextBlock()
            {
                intCurrentNo = intNextNo;
                bCurrentMetaShowFlag = bMetaShowFlag;
                intNextNo = Microsoft.SPOT.Math.Random(15);
                bMetaShowFlag = GetElsMeta(intNextNo);
            }
 
            // 移动方块
            private void MoveBlock(int X, int Y, bool[][] bFlags,MoveWay mw)
            {
                switch (mw)
                {
                    case MoveWay.Left:
                        SetBlock(X+1, Y, bCurrentMetaShowFlag, false);
                        SetBlock(X, Y, bCurrentMetaShowFlag, true);
                        break;
                    case MoveWay.Down:
                        SetBlock(X, Y - 1, bCurrentMetaShowFlag, false);
                        SetBlock(X, Y, bCurrentMetaShowFlag, true);
                        break;
                    case MoveWay.Right:
                        SetBlock(X-1, Y, bCurrentMetaShowFlag, false);
                        SetBlock(X, Y, bCurrentMetaShowFlag, true);
                        break;
                    default:
                        break;
                }             
            }           
 
           // 是否可以移动
            private bool IsMove(int X, int Y, bool[][] bFlags, MoveWay mw)
            {
                略 ;-)
            }
 
            // 绘制
            public void Draw(DrawingContext dc)
            {
                int BarTop = 26;
                int BarHeight = SystemMetrics.ScreenHeight - BarTop * 2;
                dc.DrawRectangle(new SolidColorBrush(Colors.Gray), new Pen(Colors.Gray), 0, BarTop, SystemMetrics.ScreenWidth, BarHeight);
 
                // 主显示区
                dc.DrawRectangle(new SolidColorBrush(Colors.Black), new Pen(Colors.White), 79, BarTop + 3, 92, 182);
 
                // 辅助显示区
                dc.DrawRectangle(new SolidColorBrush(Colors.Black), new Pen(Colors.White), 222,120, 38, 38);
 
                // 积分区
                dc.DrawRectangle(new SolidColorBrush(Colors.White), new Pen(Colors.Blue), 205, 180, 74, 20);
                dc.DrawText(intGrade.ToString(), YFWinApp.YFFont,ColorUtility.ColorFromRGB(0,120,0), 224 + 17 - intGrade.ToString().Length * 3, 184);
               
                // 显示
                DrawEls(80, BarTop + 4, 9, 9, dc);
 
                // 结束
                if (!bGameRunFlag)
                {
                    dc.DrawText("Game Over!", YFWinApp.YFFont, Colors.Red,96, 110);
                }
            }
 
            // 显示方块
            private void DrawEls(int X,int Y,int Width,int Height,DrawingContext dc)
            {
                SolidColorBrush sb=new SolidColorBrush(Colors.Green);
                Pen pen=new Pen(Colors.Blue);   
               
                // 主显示区
                for (int i = 0; i < 20; i++)
                {
                    for (int j = 0; j < 10; j++)
                    {
                        if(bShowFlag[i+1][j+1])
                           dc.DrawRectangle(sb, pen, X +j * Width, Y + i * Height, Width, Height);
                    }
                }
 
                // 辅助显示区
                for (int i = 0; i < 4; i++)
                {
                    for (int j = 0; j < 4; j++)
                    {
                        if(bMetaShowFlag[i][j])
                             dc.DrawRectangle(sb, pen,223 + j * Width, 121 + i * Height, Width, Height);
                    }
                }
            }
}
叶帆
关注
  • 0
    点赞
  • 踩
  • 12
    收藏
    觉得还不错? 一键收藏
  • 10
    评论
专栏目录
microbit python_python教程之micro:bit俄罗斯方块游戏
weixin_39869693的博客
11-24 546
我们正在创建一个俄罗斯方块游戏，并在BBC micro：bit上运行。游戏中落下的俄罗斯方块将基于以下四种形状：游戏规则如下：按钮A：将当前方块移动到左侧按钮B：将当前方块移动到右侧按钮A和B同时：顺时针旋转当前方块视频演示游戏将使用mico:bit的LED屏幕，其由5*5的25个LED组成。每个LED可以打开（值：9表示最大亮度）或关闭（值：0）并显示边界部分（未落下的方块）Python代码将使...
俄罗斯方块(.NET)
09-12
利用.net开发的俄罗斯方块，大家不放借鉴下
俄罗斯方块（.net）
10-15
俄罗斯方块游戏 c#源码，开发工具.net 2008 游戏可以定制砖块的形状、颜色，使用了当前比较流行的Xml记录游戏数据。
C#.NET俄罗斯方块
06-28
C#语言VS2012程序用winform窗体编写的俄罗斯方块，有大量的算法，可以运行游戏
ASP.NET版俄罗斯方块
12-05
ASP.NET版俄罗斯方块,适合新手。
使用.NET Micro Framework升级您的汽车
04-08
标题 "使用.NET Micro Framework升级您的汽车" 暗示了这个项目是关于将先进的软件技术应用于汽车硬件系统，特别是利用.NET Micro Framework (NETMF) 进行改造或增强。.NET Micro Framework 是一个轻量级的.NET框架，...
DSP中的ADI公司Blackfin处理器支持微软.NET Micro Framework
11-02
标题中的核心知识点是ADI公司的Blackfin处理器现在支持微软的.NET Micro Framework。这是一项重要的技术进步，使得嵌入式系统开发人员能够利用Blackfin处理器的强大性能和.NET Micro Framework的易用性来开发更复杂...
《玩转.NET Micro Framework移植-基于STM32F10x处理器》源程序.rar
01-30
《玩转.NET Micro Framework移植-基于STM32F10x处理器》这本书的主题聚焦于将.NET Micro Framework（简称.NET MF）应用到STM32F10x系列微控制器上，这是一个涉及嵌入式系统开发、C#编程以及硬件平台集成的重要技术...
microframework:.NET Micro Framework的库集
05-21
.NET Micro Framework库 .NET Micro Framework的库集。 ### Bansky.SPOT.IrDA 用于WPF的红外接收器和...俄罗斯方块游戏作为Micro Framework功能的演示 ### devantech Devantech Ltd.提供的用于不同硬件的驱动程序
Expert .NET Micro Framework
01-06
The Microsoft .NET Micro Framework is a small and efficient .NET runtime environment used to run managed code on devices that are too small and resource constrained for Windows CE and the Compact ...
vb.net做的俄罗斯方块
06-14
Vb写的俄罗斯方块 基本功能全'声明一个整数常量Width,表示游戏界面横向的小正方形数目,初始化为16 Public Const Width As Integer = 16 '声明一个整数常量Height,表示游戏界面横向的小正方形数目,初始化为30 Public Const Height As Integer = 30 '游戏界面的背景色 Public Shared BackColor As Color '小正方形的大小 Public Shared SquareSize As Size = New Size(10, 10) Public Shared g As Graphics '声明一个Graphics变量,用于绘制下一个方块 Public Shared gNext As Graphics '声明一个数组,用于表示游戏界面上的所有小正方形 Private Shared ArrGameField(Width - 1, Height - 1) As CSquare '函数功能:判断ArrGameField(x, y)是否有正方形,有则返回False,无则返回True Public Shared Function IsEmpty(ByVal x As Integer, ByVal y As Integer) As Boolean If x >= 0 And x = 0 And y =0 '在循环体中,先判断第y行是否是满的,是的话result增1,并把第y行上的所有小正方形下降一行.最后y递减1 '如果实现把第y行的所有小正方形下降一行:从第y行扫描至第0行,每扫描一行,把上一行的每个小正方形赋值给该行,并修改每一个小正方形的Location属性的值 While Y >= 0 If IsLineFull(Y) Then result += 1 For i As Integer = Y To 0 Step -1 If i > 0 Then For x As Integer = 0 To Width - 1 ArrGameField(x, i) = ArrGameField(x, i - 1) If Not ArrGameField(x, i) Is Nothing Then ArrGameField(x, i).Location = New Point(ArrGameField(x, i).Location.X, ArrGameField(x, i).Location.Y + SquareSize.Height) End If Next Else For x As Integer = 0 To Width - 1 ArrGameField(x, i) = Nothing Next End If Next Else
基于.net框架的俄罗斯方块（源代码+实验报告）.rar
09-21
该项目是基于.net框架的俄罗斯方块游戏的实现代码与实验报告，适合.net框架的初学者，以及想了解如何使用.net框架开发游戏的同学学习了解。
c#俄罗斯方块，原创，.net开发俄罗斯方块
11-05
本人在工作之余，想想能不能平时写一个俄罗斯方块的设计模块。于是慢慢编写代码。该代码完成90%，思路都已在程序中加以注释。未完成的10%为当同事消除几行时，尤其是这几行不是连续的时候，如何实现二维数组的变换和消除效果。希望有兴趣的朋友一起研究，在这里发布这个程序是希望能交到有经验的朋友。QQ:174510355
c#(asp.net)俄罗斯方块
11-06
c#(asp.net)俄罗斯方块(含源码)。
俄罗斯方块.net源代码
06-01
俄罗斯方块.net源代码俄罗斯方块.net源代码俄罗斯方块.net源代码俄罗斯方块.net源代码俄罗斯方块.net源代码
俄罗斯方块(C#.net 2003)
张远山的专栏
05-25 1607
这个俄罗斯方块本来设计是放在像联众大厅那样的系统里运行的，但是后来大厅和服务器没有继续做下去，所以只实现单人玩，双人共玩，没有做积分的功能(有兴趣的朋友可以改改)，双人对玩有惩罚的功能。usingvisual studio.net 2003俄罗斯方块源码： http://download1.csdn.net/down3/20070526/26013522260.rar可执行程序
俄罗斯方块-C#
10-01
适合C#初学者使用,参考学习的俄罗斯方块源程序。已成功调试，适合新手拿来练习。
micro:bit 5x5点阵屏玩迷宫、俄罗斯方块、贪食蛇
weixin_43475661的博客
07-23 2603
microbit点阵屏玩迷宫、贪食蛇、俄罗斯方块游戏
C#俄罗斯方块源码完整版
05-08
完整的代码，仅供学习交流使用。可以下载安装使用，也可直接运行使用
micropython单片机俄罗斯方块
最新发布
04-27
Micropython是一种在单片机上运行的Python解释器，因此可以使用Micropython编写俄罗斯方块游戏。在Micropython中，你可以使用micro:bit或其他类似的硬件作为游戏控制器，并使用LED矩阵显示方块和游戏界面。具体的实现方式可以参考Micropython官方文档和类似的项目示例。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值