C++ QT中国象棋双人单机对战代码总结

最新推荐文章于 2024-06-18 18:00:49 发布
最新推荐文章于 2024-06-18 18:00:49 发布
阅读量1.4k 收藏 13
点赞数 3
分类专栏： 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/wwxy1995/article/details/88381289
版权

Stone.h

#ifndef STONE_H
#define STONE_H

#include <QString>
class Stone
{
public:
    Stone();
    //定义棋子的所有类型
    enum TYPE{JIANG,CHE,PAO,MA,BING,SHI,XIANG};
    //棋子所处的行
    int _row;
    //棋子所处的列
    int _col;
    //棋子的id
    int _id;
    //棋子是否已死
    bool _dead;
    //棋子是否为红子
    bool _red;
    //棋子类型
    TYPE _type;
    //初始化棋子
    void init(int id);
    //获取棋子的类型名
    QString getText();
};
#endif // STONE_H

Stone.cpp

#include "Stone.h"

Stone::Stone()
{

}

void Stone::init(int id)
{
    // 总共有16种棋子
    struct
    {
        int row,col;
        Stone::TYPE type;
    } pos[16] = {
    {0,0,Stone::CHE},
    {0,1,Stone::MA},
    {0,2,Stone::XIANG},
    {0,3,Stone::SHI},
    {0,4,Stone::JIANG},
    {0,5,Stone::SHI},
    {0,6,Stone::XIANG},
    {0,7,Stone::MA},
    {0,8,Stone::CHE},

    {2,1,Stone::PAO},
    {2,7,Stone::PAO},
    {3,0,Stone::BING},
    {3,2,Stone::BING},
    {3,4,Stone::BING},
    {3,6,Stone::BING},
    {3,8,Stone::BING},
    };

    _id = id;
    _dead = false;
    _red = id<16;

    if(id<16)
    {
        _row = pos[id].row;
        _col = pos[id].col;
        _type = pos[id].type;
    }
    else
    {
        _row = 9 - pos[id-16].row;
        _col = 8 - pos[id-16].col;
        _type = pos[id-16].type;
    }

}

QString Stone::getText()
{
    switch (this->_type)
    {
    case CHE:
        return "车";
    case MA:
        return "马";
    case PAO:
        return "炮";
    case BING:
        return "兵";
    case JIANG:
        return "将";
    case SHI:
        return "士";
    case XIANG:
        return "相";
    }
    return "Wrong";
}

 

Board.h

#ifndef BOARD_H
#define BOARD_H

#include <QWidget>
#include "Stone.h"

class Board : public QWidget
{
    Q_OBJECT

public:
    explicit Board(QWidget *parent = 0);

    Stone _s[32];     // 32个棋子
    int _r;           // r棋子的半径,格子一半的宽度
    int _selectid;    // 被选中的棋子
    bool _bRedTurn;   // 是否轮到红方走


    // 根据行和列获取棋子的id
    int getStoneId(int row, int col);
    //计算即将行走的棋子与某一坐标之间有几颗棋子
    int num_of_Stone(int moveid,int row,int col);
    //输入行列坐标判断该坐标上有没有棋子
    bool beStone(int row,int col);
    // 判断棋子的颜色是否相同
    bool sameColor(int moveid,int killid);
    // 由点击坐标转化为棋子的行列编号
    bool getRowCol(QPoint pt, int &row, int &col);



    bool canSelect(int id);
    //最基本的能不能走的判断判断
    bool canMove(int moveid,int row,int col,int killid);
    //判断将能不能走
    bool canMoveJIANG(int moveid,int row,int col,int killid);
    //判断士能不能走
    bool canMoveSHI(int moveid,int row,int col,int killid);
    //判断象能不能走
    bool canMoveXIANG(int moveid,int row,int col,int killid);
    //判断车能不能走
    bool canMoveCHE(int moveid,int row,int col,int killid);
    //判断马能不能走
    bool canMoveMA(int moveid,int row,int col,int killid);
    //判断炮能不能走
    bool canMovePAO(int moveid,int row,int col,int killid);
    //判断兵能不能走
    bool canMoveBING(int moveid,int row,int col,int killid);



    virtual void paintEvent(QPaintEvent *);
    //与显示到窗口中有关的函数
    void drawStone(QPainter& painter,int id);
    //输入行列坐标 返回像素坐标
    QPoint center(int row,int col);
    //输入棋子的id 返回像素坐标
    QPoint center(int id);


    void trySelectStone(int id);
    void tryMoveStone(int id,int row,int col);
    void click(QPoint pt);
    void click(int id, int row, int col);
    void moveStone(int _selectid, int killid, int row, int col);

    void mouseReleaseEvent(QMouseEvent *);
    //void click(QPoint pt);



    ~Board();
};
#endif // BOARD_H

Board.cpp

#include "Board.h"
#include <QPainter>
#include <QMouseEvent>


Board::Board(QWidget *parent)
    : QWidget(parent)
{
    for(int i=0;i<32;i++)
    {
        _s[i].init(i);
    }
    _selectid = -1;
    _bRedTurn = true;

}

Board::~Board()
{

}

void Board::paintEvent(QPaintEvent *)
{
    QPainter painter(this);

    int d=40;
    // 画10条横线
    _r = d/2;
    for(int i=1;i<=10;i++)
    {
        painter.drawLine(QPoint(d, i*d),QPoint(9*d,i*d));
    }

    for(int i=1;i<=9;i++)
    {
        if(i==1 || i==9)
            painter.drawLine(QPoint(i*d,d),QPoint(i*d,10*d));
        else
        {
            painter.drawLine(QPoint(i*d,d),QPoint(i*d,5*d));
            painter.drawLine(QPoint(i*d,6*d),QPoint(i*d,10*d));
        }

    }

    // 九宫格
    painter.drawLine(QPoint(4*d,1*d),QPoint(6*d,3*d));
    painter.drawLine(QPoint(6*d,1*d),QPoint(4*d,3*d));
    painter.drawLine(QPoint(4*d,8*d),QPoint(6*d,10*d));
    painter.drawLine(QPoint(6*d,8*d),QPoint(4*d,10*d));


    // 绘制32个棋子
    for(int i=0;i<32;i++)
    {
        drawStone(painter,i);
    }

}


QPoint Board::center(int row, int col)
{
    return QPoint((col+1)*_r*2,(row+1)*_r*2);
}

QPoint Board::center(int id)
{
    return center(_s[id]._row, _s[id]._col);
}

void Board::drawStone(QPainter & painter, int id)
{
    if(_s[id]._dead)
        return;

    QPoint c=center(id);
    QRect rect = QRect(c.x()-_r,c.y()-_r,_r*2,_r*2);
    if(id == _selectid)
        painter.setBrush(QBrush(Qt::gray));
    else
        painter.setBrush(QBrush(Qt::yellow));
    painter.setPen(Qt::black);
    painter.drawEllipse(c,_r,_r);
    if(_s[id]._red)
        painter.setPen(Qt::red);
    painter.setFont(QFont("system",_r,700));
    painter.drawText(rect,_s[id].getText(),QTextOption(Qt::AlignCenter));
}

/*确定某个行列位置上是否有棋子*/
bool Board::beStone(int row,int col)
{
    for(int i=0;i<32;i++)
        if(_s[i]._row==row&&_s[i]._col==col&&!_s[i]._dead)
                return true;

    return false;
}

//计算即将行走的棋子与某一坐标之间有几颗棋子 默认返回值为-1
int Board::num_of_Stone(int moveid,int row,int col)
{
    int i;
    int sum=0;
    if(_s[moveid]._row==row)
    {
        if(col-_s[moveid]._col>0)
            for(i=_s[moveid]._col+1;i<col;i++)
            {
                if(beStone(_s[moveid]._row,i)==true)
                    sum++;
            }
        else
            for(i=_s[moveid]._col-1;i>col;i--)
            {
                if(beStone(_s[moveid]._row,i)==true)
                    sum++;
            }
        return sum;
    }
    else if(_s[moveid]._col==col)
    {
        if(row-_s[moveid]._row>0)
            for(i=_s[moveid]._row+1;i<row;i++)
            {
                if(beStone(i,_s[moveid]._col)==true)
                    sum++;
            }
        else
            for(i=_s[moveid]._row-1;i>row;i--)
            {
                if(beStone(i,_s[moveid]._col)==true)
                    sum++;
            }
        return sum;
    }

    //两个棋子不在一条直线上
    return -1;
}



bool Board::sameColor(int moveid, int killid)
{
    return _s[moveid]._red == _s[killid]._red;
}

// 总的逻辑判断函数
// 总的逻辑判断函数
bool Board::canMove(int moveid, int killid, int row, int col)
{
    if(killid==-1||!sameColor(moveid,killid))
    {
        switch(_s[moveid]._type)
        {
        case Stone::JIANG:
            return canMoveJIANG(moveid,row,col,killid);
            break;
        case Stone::SHI:
            return canMoveSHI(moveid,row,col,killid);
            break;
        case Stone::XIANG:
            return canMoveXIANG(moveid,row,col,killid);
            break;
        case Stone::CHE:
            return canMoveCHE(moveid,row,col,killid);
            break;
        case Stone::MA:
            return canMoveMA(moveid,row,col,killid);
            break;
        case Stone::PAO:
            return canMovePAO(moveid,row,col,killid);
            break;
        case Stone::BING:
            return canMoveBING(moveid,row,col,killid);
            break;
        default: break;
        }
    }

    //move的棋子和kill的棋子是相同颜色的
    if(sameColor(moveid,killid))
    {
        /*换选择*/
        _selectid=killid;
        update();
        return false;
    }
    return true;
}



bool Board::canMoveSHI(int moveid,int row,int col,int killid)
{
    if(_s[moveid]._red)
    {
        //判断红方士的纵向行走是否超出米字格范围
        if(row>2) return false;
    }
    else
    {
        //判断黑方士的纵向行走是否超出米字格范围
        if(row<7) return false;
    }

    //判断红黑双方方士的横向行走是否超出米字格范围
    if(col<3) return false;
    if(col>5) return false;

    //判断是否为沿着对角线斜着行走
    int dr=_s[moveid]._row-row;
    int dc=_s[moveid]._col-col;
    if(abs(dr)==1&&abs(dc)==1)
        return true;

    return false;
}


bool Board::canMoveBING(int moveid,int row,int col,int killid)
{
    /*兵的走棋规则*/
    int dr=_s[moveid]._row-row;
    int dc=_s[moveid]._col-col;

    //红棋
    if(_s[moveid]._red)
    {
        //过河前
        if(_s[moveid]._row>=3&&_s[moveid]._row<=4)
        {
            //竖着走
            if(dr==-1&&dc==0)
                return true;
            //横着走
            else
                return false;
        }
        //过河后
        else
        {
            if(abs(dr)==1&&abs(dc)==0||(abs(dc)==1&&abs(dr)==0))
            {
                //竖着走
                if(dr==1)
                    //竖着走走了回头路就要返回错误
                    return false;
                //横着走
                else
                    return true;
            }
            else
                return false;
        }
    }
    //黑棋
    else
    {
        //过河前
        if(_s[moveid]._row>=5&&_s[moveid]._row<=6)
        {
            //竖着走
            if(dr==1&&dc==0)
                return true;
            //横着走
            else
                return false;
        }
        //过河后
        else
        {
            //竖着走
            if(abs(dr)==1&&abs(dc)==0||(abs(dc)==1&&abs(dr)==0))
            {
                //竖着走走了回头路就要返回错误
                if(dr==-1)
                    return false;
                //横着走
                else
                    return true;
            }
            else
                return false;
        }
    }
    return true;
}

bool Board::canMoveXIANG(int moveid,int row,int col,int killid)
{
    //不能过河
    if(_s[moveid]._red)
    {
        if(row>4) return false;
    }
    else
    {
        if(row<5) return false;
    }

    //走田字格
    int dr=_s[moveid]._row-row;
    int dc=_s[moveid]._col-col;
    int medium_r=(_s[moveid]._row+row)/2;
    int medium_c=(_s[moveid]._col+col)/2;
    if(abs(dr)==2&&abs(dc)==2)
        //别象眼检验
        if(!beStone(medium_r,medium_c))
            return true;

    return false;
}


bool Board::canMoveMA(int moveid,int row,int col,int killid)
{
    int dr=_s[moveid]._row-row;
    int dc=_s[moveid]._col-col;
    int medium_r=(_s[moveid]._row+row)/2;
    int medium_c=(_s[moveid]._col+col)/2;
    if(abs(dr)==1&&abs(dc)==2||(abs(dr)==2&&abs(dc)==1))
    {
        if(abs(dr)==2)
        {
            //别马腿检验
            if(beStone(medium_r,_s[moveid]._col)==false)
                return true;
        }
        else
        {
            //别马腿检验
            if(beStone(_s[moveid]._row,medium_c)==false)
                return true;
        }
    }
    return false;
}


bool Board::canMoveJIANG(int moveid, int row, int col, int killid)
{
    if(_s[moveid]._red)
    {
        if(row > 2)
            return false;
    }
    else
    {
        if(row < 7)
            return false;
    }
    if(col < 3)
        return false;
    if(col > 5)
        return false;

    int dr = _s[moveid]._row - row;
    int dc = _s[moveid]._col - col;
    int d = abs(dr)*10 + abs(dc);
    if(d==1||d==10)
        return true;

    return false;
}

bool Board::canMovePAO(int moveid,int row,int col,int killid)
{
    int ret = num_of_Stone(moveid,row,col);
    if(killid!=-1 && ret == 1)
        return true;
    else if(killid==-1 && ret ==0)
        return true;
    else
        return false;

}

bool Board::canMoveCHE(int moveid,int row,int col,int killid)
{

    int ret = num_of_Stone(moveid,row,col);
    return !ret;

}

bool Board::getRowCol(QPoint pt, int &row, int &col)
{
    for(row=0;row<=9;row++)
    {
        for(col=0;col<=8;col++)
        {
            QPoint c = center(row,col);
            int dx = c.x() - pt.x();
            int dy = c.y() - pt.y();
            int dist = dx*dx+dy*dy;
            if(dist<_r*_r)
                return true;
        }
    }
    return false;
}

int Board::getStoneId(int row, int col)
{
    for(int i=0;i<32;i++){
        if(_s[i]._row == row && _s[i]._col == col)
            return i;
    }
    return -1;
}

void Board::click(int id, int row, int col)
{
    if(this->_selectid == -1)        // 如果没有选择到棋子，选择棋子
        trySelectStone(id);
    else                             // 选择到棋子，移动棋子
        tryMoveStone(id,row,col);
}

void Board::click(QPoint pt)
{
    int row, col;
    bool bClicked = getRowCol(pt, row, col);
    if(!bClicked)            // 点击地方不合理
        return;

    int id = getStoneId(row,col);
    click(id,row,col);

}

void Board::trySelectStone(int id)
{
    if(_bRedTurn == _s[id]._red){
        _selectid = id;
        update();
    }

}


// 尝试走棋
void Board::tryMoveStone(int killid, int row, int col)
{
    // 如果尝试吃颜色相同的棋子，那么重新选择棋子
    if(killid!=-1 && sameColor(killid, _selectid)){
        trySelectStone(killid);
        return;
    }

    // 如果可以移动棋子，那么移动棋子
    if(canMove(_selectid, killid, row, col)){
        moveStone(_selectid, killid, row, col);
        _selectid = -1;
        update();
    }
}

void Board::moveStone(int _selectid, int killid, int row, int col)
{
    _s[_selectid]._row = row;
    _s[_selectid]._col = col;
    if(killid!=-1)
    {
        _s[killid]._dead = true;
    }
    _selectid = -1;
    _bRedTurn = !_bRedTurn;                // 对方回合
}

void Board::mouseReleaseEvent(QMouseEvent *ev)
{
    QPoint pt = ev->pos();
    click(pt);
}

 

wwxy261
关注
  • 3
    点赞
  • 踩
  • 13
    收藏
    觉得还不错? 一键收藏
  • 2
    评论
专栏目录
c++课设--基于QT实现的象棋
qq_52495761的博客
11-25 1613
组员姓名：XXXX通过这次课程设计，更加深入的了解了 qt的使用，以及掌握了C++语言的基本语法和面向对象编程思想，同时通过实践来加深对C++语言的理解和应用。通过这次的课设一定程度上提高了自己的编程能力，能够利用所学的基本知识和技能，解决简单的面向对象程序设计问题，能够熟练地使用C++的特点继承，封装，多态，加深对面向对象编程思想的理解，同时也为学习其他高级语言和开发其他复杂应用程序打下坚实的基础。
基于C++的简易的国际象棋双人对战程序设计
毕业作品网站
09-12 2568
国际象棋是世界上一个古老的棋种。据现有史料记载，国际象棋的发展历史已将近2000年。关于它的起源，有多种不同的说法，诸如起源于古印度、中国、阿拉伯国家等。国际象棋分为黑白两方共32枚，每方各16枚；棋盘为正方形，由64个黑白（深色与浅色）相间的格子组成。每方有王、后、象、车、马、兵六种棋子，不同棋子走子和吃子的方法不同，不再赘述。
基于QT和C++实现的中国象棋
2303_76580416的博客
06-18 922
中国象棋
基于Qt开发的中国象棋 （1） 双人对战
weixin_43582715的博客
12-27 1572
开发工具 Qt5.9 前置知识 ， QPainter ， paintEvent， mouseReleaseEvent 本次实现的是双人对战的象棋。需要实现的功能如下 1. 棋盘的显示 2. 棋子的生成 3.棋子的移动 4.走棋 5. 轮流下棋 6. 判断胜利
C++ QT中国象棋项目讲解(三） 单机双人对战走棋
wwxy1995的博客
03-10 1029
在前面的基础上增加鼠标点击函数即可 click函数由鼠标点击坐标点得到对应棋子的坐标点 void Board::click(QPoint pt) { int row, col; bool bClicked = getRowCol(pt, row, col); if(!bClicked) // 点击地方不合理 return; ...
项目实战：Qt5／C++：QT象棋【初版】
热门推荐
07-05 1万+
项目实战：Qt5／C++：QT象棋【初版】 ================================================================== ===完整基于QT的跨平台网络对战中国象棋的项目完整版大更新 2019-04-13 ===QT5/C++项目：基于QT的跨平台网络对战象棋（一） ===QT5/C++项目：基于QT的跨平台网络对战象棋（二） =...
Qt实现中国象棋：(一)项目建立控件布局和简单的需求分析
qq_41588862的博客
11-27 1176
Qt实现中国象棋
QT5/C++项目：基于QT的跨平台网络对战象棋（二）（推荐★★★★）
04-13 5998
QT5/C++项目：基于QT的跨平台网络对战象棋（二） 文章目录QT5/C++项目：基于QT的跨平台网络对战象棋（二）**本篇副标题：****本篇博客讲了什么or解决了什么问题？****项目简介：****项目特色：****实现功能：****责任描述：****其他：****项目演示效果：**视频演示：图片演示：**开发平台环境：****项目思路分析：**需求以及实现：功能流程图：系统流程图：总体设计...
【C++课程设计】期末大作业 - 基于Qt开发的中国象棋软件
小米子的成长日记
12-15 3481
本项目主要目的为实现中国传统双人对弈游戏—中国象棋，实现了在单机或联网状态下，无论是单人还是多人，无论使用系统是否相同，均可以实现象棋游戏功能。开发全程使用 Qt Creator 4.3.0 (Community) 的 C/C++功能，基本不使用控件拖拽，并且尽量手写代码来实现相应的函数功能，以此来熟悉面向对象编程，提高手写代码能力。
用C++开发的双人对战五子棋
一只在校程序猿的技术贴
12-09 1万+
前言：有了用C++开发象棋及其AI的经验后，我就萌生了再用C++开发五子棋及其AI的想法。有了想法还等什么？付诸实施呗！ 首先明确一盘五子棋需要什么属性：一盘五子棋有黑棋有白棋，与象棋不同的是，五子棋的棋子数目不是确定的，而是随着下棋随着增加的，所以，需要一个存放整盘棋棋子数目的整型变量num_of_Stone。五子棋下棋的有两方，黑方和白方，所以需要一个存放当前该谁走的布尔型变量_bBl...
Qt5，c++单机双人国际象棋（全注释，可增添人机功能）
06-17
"Qt5，c++单机双人国际象棋（全注释，可增添人机功能）" 这个标题表明了我们正在讨论一个基于Qt5框架、用C++语言编写的单机版双人国际象棋游戏。这个项目不仅实现了基本的双人对弈功能，而且源代码已经进行了全程...
基于C++(QT)设计的简易国际象棋双人对战程序【100011696】
04-07
使用Qt自带的Socket编程，实现客户端和服务端一对一的网络对战，正确复现国际象棋的规则。在基本的走子和吃子回合制下，要求有： 对局中，出现下列情况之一，本方算输，对方赢： 己方王被将死（不允许送吃）； 2）...
wobuku-ChineseChess-master_人机对战_QT_中国象棋_源码
10-01
描述中的“基于Qt Creator实现中国象棋人机对战，c++实现”进一步细化了标题中的信息。Qt Creator是一个集成开发环境（IDE），支持C++语言，这里提到它，意味着开发人员使用了这个工具来编写和调试代码。同时，强调...
Qt写的人人对战中国象棋
11-05
【Qt写的人人对战中国象棋】是一个基于Qt框架开发的桌面应用程序，它使用C++编程语言，并遵循面向对象编程（OOP）原则。Qt是一个跨平台的应用程序开发框架，广泛用于创建GUI（图形用户界面）应用，同时也支持命令行...
基于Qt C++的象棋小游戏
04-23
本项目“基于Qt C++的象棋小游戏”就是利用Qt的特性，实现了一个简易版的中国象棋游戏。 首先，我们需要了解Qt中的关键概念。Qt框架的核心是QObjects，它是所有Qt对象的基类，提供了信号与槽机制，这是Qt事件处理的...
2019年中国民航大学电子制作比赛---蓝牙音响.zip
08-03
大学生参加学科竞赛有着诸多好处，不仅有助于个人综合素质的提升，还能为未来职业发展奠定良好基础。以下是一些分析： 首先，学科竞赛是提高专业知识和技能水平的有效途径。通过参与竞赛，学生不仅能够深入学习相关专业知识，还能够接触到最新的科研成果和技术发展趋势。这有助于拓展学生的学科视野，使其对专业领域有更深刻的理解。在竞赛过程中，学生通常需要解决实际问题，这锻炼了他们独立思考和解决问题的能力。 其次，学科竞赛培养了学生的团队合作精神。许多竞赛项目需要团队协作来完成，这促使学生学会有效地与他人合作、协调分工。在团队合作中，学生们能够学到如何有效沟通、共同制定目标和分工合作，这对于日后进入职场具有重要意义。 此外，学科竞赛是提高学生综合能力的一种途径。竞赛项目通常会涉及到理论知识、实际操作和创新思维等多个方面，要求参赛者具备全面的素质。在竞赛过程中，学生不仅需要展现自己的专业知识，还需要具备创新意识和解决问题的能力。这种全面的综合能力培养对于未来从事各类职业都具有积极作用。 此外，学科竞赛可以为学生提供展示自我、树立信心的机会。通过比赛的舞台，学生有机会展现自己在专业领域的优势，得到他人的认可和赞誉。这对于培养学生的自信心和自我价值感非常重要，有助于他们更加积极主动地投入学习和未来的职业生涯。 最后，学科竞赛对于个人职业发展具有积极的助推作用。在竞赛中脱颖而出的学生通常能够引起企业、研究机构等用人单位的关注。获得竞赛奖项不仅可以作为个人履历的亮点，还可以为进入理想的工作岗位提供有力的支持。
22NM60N-VB TO220一款N-Channel沟道TO220的MOSFET晶体管参数介绍与应用说明
最新发布
08-03
22NM60N-VB TO220；Package：TO220；Configuration：Single-N-Channel；VDS：650V；VGS：30（±V）；Vth：3.5V；RDS(ON)=160mΩ@VGS=10V；ID：20A；Technology：SJ_Multi-EPI；
22N60L-VB一款N-Channel沟道TO247的MOSFET晶体管参数介绍与应用说明
08-03
22N60L-VB；Package：TO247；Configuration：Single-N-Channel；VDS：650V；VGS：30（±V）；Vth：3.5V；RDS(ON)=160mΩ@VGS=10V；ID：20A；Technology：SJ_Multi-EPI；
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值