用C语言实现简单的一字棋游戏

最新推荐文章于 2024-05-01 12:15:08 发布
最新推荐文章于 2024-05-01 12:15:08 发布
阅读量3.8k 收藏 24
点赞数 4
文章标签： c语言 游戏 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_46028455/article/details/122633796
版权

问题分析设计目录

棋盘显示和标记以及棋盘的设计

用int一维数组表示一字棋的棋盘位置，0~8，数组位置i即棋盘位置，数组元素的值表示该位置的下棋情况。0表示未下棋，1表示用户选手下棋，2表示电脑下棋。比如
chessman[6] = 1; 表示第六个位置下了用户选手的棋。
在这里插入图片描述

//一字棋棋盘 一共9个格子 
typedef struct{
	int chessman[9];
}ChessBoard;

搜索树叶子节点设计

定义一个BiTNode节点，只表示搜索树的叶子节点，里面存放了一个棋盘，这个棋盘是棋局中某一步棋的情况，里面包括了电脑可能下棋的位置和用户选手可能做的下一步棋的位置。Value值是该节点的静态估值，当该节点形成后，可以计算静态估值。

//搜索树节点的定义 
typedef struct BiTNode{
	ChessBoard chessboard;   //chessboard 一个棋盘以及所有棋子落子的情况 
	int CoordinateAI;         //这一步棋子的位置 ChessMan[]0~8 
	int CoordinatePlayer;     //这一步是选手可能落下棋子的位置 
	int Value;              //节点的估价值 
}BiTNode; 

BiTNode Head;     //头结点 
//BiTNode *TreeBoard;

 #define MAX  100
 #define MIN  -100
 #define DOGFALL 50  //平局

搜索树设计

本次设计我没有用到数据结构中严格意义上的树，设计时觉得有点麻烦，没有用二叉树表示，但我又有自己的想法实现逻辑上的搜索树，并且这棵搜索树做两层就够了，这个想法目前只适用于一字棋。搜索树用节点二维数组表示。
Max节点的估价值用一维数组aFatherValue[9]表示。

BiTNode a[9][9];   //极大极小搜索树用数组表示  
int aFatherValue[9];      //Max节点的估价函数值，选取该节点所有孩子节点的最小估价函数赋值

搜索树表示如图所示：
在这里插入图片描述

节点静态估值计算

在一盘棋中，又八种可能连成一线的的结果。在博弈当中的任何一方都考虑完他们八种情况的结局有几种是可能实现的就行了。横竖各三种，斜着两种一共八种。计算设计如下所示。用二维数组judge[8][[3]]列出八种情况对应的位置值，然后按着顺序遍历一组一组遍历八组就行了。当一组位置中的三个位置只要有一处是存在对手中的棋子，则这一组就不可能用自己的棋子连成三点一线。

//判断某一方可能获胜结果的个数 
int checkValue(int x, int y, ChessBoard *chessboard){
	
	int value = 0;
	int judge[8][3] = {{0,1,2},{3,4,5},{6,7,8},{0,3,6},{1,4,7},{2,5,8},{0,4,8},{2,4,6}};
	int coordinate ;
	
	for(int i=0; i<=7; i++){
		int j = 0;;
		for(j=0; j<=2; j++){
			coordinate = judge[i][j];
			 //判断8个胜利的可能是否有对手的棋子，如果有，则可判定这个结果不可能胜算 
			if(chessboard->chessman[coordinate] == x ){  
				break;
			}			
		}
		if(j>2){
			value++;
		}	
	}
	return value;
}

因为只需要电脑的考虑，所以用电脑的减去用户选手可能胜利的个数，就能得到静态估值。在计算节点的静态估价值函数中，如果对手的棋连成了三点一线，则直接返回Min，如果是电脑的棋连成线，则返回Max。

//计算节点的静态估价值 
int EvaluationFunction(ChessBoard *chessboard){
//	ChessBoard *p = &chessboard; 
	int EvaluationAI = checkValue(1,2,chessboard);     //AI的胜算 
	int EvaluationPlayer = checkValue(2,1,chessboard);  //对手的胜算 
	int Evaluation = EvaluationAI - EvaluationPlayer;
	
	int judge[8][3] = {{0,1,2},{3,4,5},{6,7,8},{0,3,6},{1,4,7},{2,5,8},{0,4,8},{2,4,6}};
	int coordinate ;
	int valueX;
	int valueY;
	for(int i=0; i<=7; i++){
		valueX = 0;
		valueY = 0;
		for(int j=0; j<=2;j++){
			coordinate = judge[i][j];
			if(chessboard->chessman[coordinate] == 1){
				valueX++;
			}
			if(chessboard->chessman[coordinate] == 2){
				valueY++;
			}
		}
		if(valueX == 3){
			return MIN;
		}
		if(valueY == 3){
			return MAX;
		}
	}
			
	return Evaluation; 
}

完整代码

#include<stdio.h>
#include<windows.h>

//棋子  x,y是棋子的坐标位置，value是判断该坐标是否落有棋子  0表示没有落棋 1表示X自己下的棋 2表示〇AI下的棋 

//一字棋棋盘 一共9个格子 
typedef struct{
	int chessman[9];
}ChessBoard; 

//搜索树节点的定义 
typedef struct BiTNode{
	ChessBoard chessboard;   //chessboard 一个棋盘以及所有棋子落子的情况 
	int CoordinateAI;         //这一步棋子的位置 ChessMan[]0~8 
	int CoordinatePlayer;     //这一步是选手可能落下棋子的位置 
	int Value;              //节点的估价值 
}BiTNode; 

BiTNode Head;     //头结点 
//BiTNode *TreeBoard;
 
 #define MAX  100
 #define MIN  -100
 #define DOGFALL 50  //平局 
 
 void initialBoard(ChessBoard *chessboard);   //初始化一个棋盘，对一字棋棋盘的每个格子规定坐标
 int EvaluationFunction(ChessBoard *chessboard);  //计算节点的静态估价值 
 int checkValue(int x,int y, ChessBoard *chessboard); //判断某一方可能获胜结果的个数 
 void PlayChess(int x, int play, ChessBoard *chessboard);   //下棋 
 int PlayAI(ChessBoard *chessboard);          //AI考虑下棋  
 void DrawBoard(ChessBoard *chessboard);      //绘画棋盘,给用户显示 
 int PlayAI(ChessBoard *chessboard);          //电脑考虑下棋 
 int judgeBoard(ChessBoard *chessboard);     当某一方下棋后，判断结果  


int main(){
	
	int first = 0;
	int play; 
	int playNum = 0;      //记录运行步数  如果大于9，说明平局 
	
	printf("欢迎来到一字棋游戏；x代表你下的棋，〇代表电脑下的棋  该棋盘9个棋子的位置对应坐标如下：\n");
	printf("-------------------\n") ;
	printf("|  0  |  1  |  2  |\n\n");
	printf("|  3  |  4  |  5  |\n\n");
	printf("|  6  |  7  |  8  |\n");
	printf("-------------------\n\n");
	printf("当你和机器对弈时，请输入你下的棋子位置对应的坐标，比如想下在最中间的位置就输入4\n");
	printf("现在请选择这局一字棋游戏谁先走第一步，请输入0或1，0代表机器先下 1代表你先下\n");
	scanf("%d",&first);
	
	ChessBoard playChessBoard;        //整局游戏的一盘棋，同时也可当作头结点 
	ChessBoard *playBoard = &playChessBoard;  //棋盘指针   
		
	initialBoard(playBoard);     //传指针 	
	
	if(first == 1){
		printf("-------------------\n") ;
		printf("|  0  |  1  |  2  |\n\n");
	    printf("|  3  |  4  |  5  |\n\n");
	    printf("|  6  |  7  |  8  |\n");
		printf("-------------------\n\n");
		printf("请输入你下棋的位置：");
		scanf("%d",&play);
		PlayChess(1,play, playBoard);	 //用户选手下棋 
		DrawBoard(playBoard);
		playNum++;
	}else{
		int AI = PlayAI(playBoard);            //AI考虑下棋 	
		printf("电脑下棋的位置: %d\n",AI);	
		PlayChess(2,AI, playBoard);    //电脑选手下棋 
		playNum++;
		DrawBoard(playBoard);          //显示给用户下棋 
		printf("请你做下一步棋：");
		scanf("%d",&play);
	}
	
	int playNext = 1;        //定义一个整形数据，决定下一步谁下棋  1表示用户选手下棋 2表示电脑下棋 
	
	if(first == 1){
		playNext = 2;
	}
	
	int finalResult = 0;
	
	while(playNum<9){
		
		if(playNext == 2){        
			int AI = PlayAI(playBoard);
			PlayChess(2,AI, playBoard);      //电脑下棋 
			printf("电脑下棋的位置: %d\n",AI);
			DrawBoard(playBoard);
			finalResult = judgeBoard(playBoard);
			if(playNum != 8 && finalResult!= 2){
				printf("请你做下一步棋：");
		        scanf("%d",&play);
			} 
			
			playNext = 1;      
		}else if(playNext == 1){
			PlayChess(1,play, playBoard);	 //用户选手下棋 
			DrawBoard(playBoard);
		    playNext = 2;         //下一步电脑下棋 
		}
		
		finalResult = judgeBoard(playBoard);
		
		if(finalResult == 1){
			printf("你赢了!\n");
			break;
		}
		
		if(finalResult == 2){
			printf("电脑赢了！");
			break;
		}
				
		playNum++;
		
	}
	
	if(playNum == 9){
		printf("结果平局\n");
	}
	
	printf("游戏结束！");
			
	return 0;
} 

//初始化一个棋盘，对一字棋棋盘的每个格子规定坐标
void initialBoard(ChessBoard *chessboard){
	
	for(int i=0; i<=8; i++){         //将棋盘的所有棋子标为0，表示为未落子 
	//	*chessboard.chessman[i] = 0; 
	    chessboard->chessman[i] = 0;
	}
} 

//计算节点的静态估价值 
int EvaluationFunction(ChessBoard *chessboard){
//	ChessBoard *p = &chessboard; 
	int EvaluationAI = checkValue(1,2,chessboard);     //AI的胜算 
	int EvaluationPlayer = checkValue(2,1,chessboard);  //对手的胜算 
	int Evaluation = EvaluationAI - EvaluationPlayer;
	
	int judge[8][3] = {{0,1,2},{3,4,5},{6,7,8},{0,3,6},{1,4,7},{2,5,8},{0,4,8},{2,4,6}};
	int coordinate ;
	int valueX;
	int valueY;
	for(int i=0; i<=7; i++){
		valueX = 0;
		valueY = 0;
		for(int j=0; j<=2;j++){
			coordinate = judge[i][j];
			if(chessboard->chessman[coordinate] == 1){
				valueX++;
			}
			if(chessboard->chessman[coordinate] == 2){
				valueY++;
			}
		}
		if(valueX == 3){
			return MIN;
		}
		if(valueY == 3){
			return MAX;
		}
	}
			
	return Evaluation; 
}

//判断某一方可能获胜结果的个数 
int checkValue(int x, int y, ChessBoard *chessboard){
	
	int value = 0;
	int judge[8][3] = {{0,1,2},{3,4,5},{6,7,8},{0,3,6},{1,4,7},{2,5,8},{0,4,8},{2,4,6}};
	int coordinate ;
	
	for(int i=0; i<=7; i++){
		int j = 0;;
		for(j=0; j<=2; j++){
			coordinate = judge[i][j];
			 //判断8个胜利的可能是否有对手的棋子，如果有，则可判定这个结果不可能胜算 
			if(chessboard->chessman[coordinate] == x ){  
				break;
			}			
		}
		if(j>2){
			value++;
		}	
		
	}
	
	return value;
}

//下棋 
void PlayChess(int x, int play, ChessBoard *chessboard){
	chessboard->chessman[play] = x;
}

//绘画棋盘,给用户显示 
void DrawBoard(ChessBoard *chessboard){
	int i;
	int num = 0;
	printf("-------------------\n");
	for(i=0; i<=8; i++){
		if(chessboard->chessman[i] == 1){
			printf("|  X  ");
		}else if(chessboard->chessman[i] == 2){
			printf("|  〇 ");
		}else{
			printf("|  %d  ",i);
		}
		num++;
		if(num%3 == 0){
			printf("|\n\n");
		}
	}
	printf("-------------------\n\n");
} 

//AI考虑下棋 
int PlayAI(ChessBoard *chessboard){
	 

	for(int i=0; i<=8; i++){
		//给头结点棋盘赋值 当前结点棋盘的棋子保持情况 
		Head.chessboard.chessman[i] = chessboard->chessman[i];   
	} 

	int aFatherValue[9];      //Max节点的估价函数值，选取该节点所有孩子节点的最小估价函数赋值 
	 
	for(int i=0;i<=8;i++){
		aFatherValue[i] = MIN;        //初始化 
	} 
	
    BiTNode a[9][9];   //极大极小搜索树用数组表示  
    		
	for(int i=0; i<=8; i++){          //这个for循环是遍历头结点的所有子节点，即max结点 
		for(int j=0; j<=8; j++){      //这个for循环是将max结点的所有子节点对局详情棋盘复写 
			for(int k=0; k<=8; k++){
				a[i][j].chessboard.chessman[k] = Head.chessboard.chessman[k];   //将当前对局的棋保存在结点棋盘里 
			}
			a[i][j].Value =MAX;           //该节点估价函数赋值为MIN  初始为最大 
			a[i][j].CoordinateAI = -1;
			a[i][j].CoordinatePlayer = -1;
		}	 
	} 
	
	
   //搜索树生成，并用极大极小值求出头结点的估价函数   求出电脑选手下棋的位置   
   int min = MAX;
   for(int i=0; i<=8; i++){
   	   if(Head.chessboard.chessman[i] == 0){
   	   	  min = MAX;
   		  for(int j=0; j<=8; j++){
   		  	a[i][j].CoordinateAI = i;
   		  	a[i][j].chessboard.chessman[i] = 2; 		  	//电脑可能下的棋 
   		  	
			if(a[i][j].chessboard.chessman[j] == 0){
				a[i][j].CoordinatePlayer = j;           //选手可能下的位置 
				a[i][j].chessboard.chessman[j] = 1;    //选手可能下的棋 
				ChessBoard *p = &a[i][j].chessboard;     //定义一个指针 用来（求估价函数 ）判断结果 
				a[i][j].Value = EvaluationFunction(p);     //求估价函数   求估价函数值还是需要传指针 
	
				if(a[i][j].Value <= min){          //求出max结点的估价函数值 
					min = a[i][j].Value; 
				}
			} 
			
		  }	
	  
		  aFatherValue[i] = min;			 //给有叶子节点的max节点赋值 求其所有叶子节点中最小的赋值 
		  
//		  printf("电脑下%d位置的max节点值为%d\n\n\n\n",i,aFatherValue[i]);
//		  printf(aFatherValue[i]); 
	   }
   }
   
   int max = MIN;
   for(int i=0; i<=8; i++){
   	 if(Head.chessboard.chessman[i] == 0){
        if(aFatherValue[i] > max){
   	  	max = aFatherValue[i];
   	  	Head.CoordinateAI = i;     //给头结点中电脑应下的位置做标记    有利于返回结果 
		 }
   	
     } 
	}
	
   	     
   return Head.CoordinateAI; 
   
}

//当某一方下棋后，判断结果 
int judgeBoard(ChessBoard *chessboard){
	int Co;
	int judge[8][3] = {{0,1,2},{3,4,5},{6,7,8},{0,3,6},{1,4,7},{2,5,8},{0,4,8},{2,4,6}};
	int x = 1;
	int y = 2;
	int valueX = 0;
	int valueY = 0;
	for(int i=0; i<=7; i++){
	    valueX =0;
	    valueY = 0;
		for(int j=0; j<=2; j++){
			Co = judge[i][j];
			if(chessboard->chessman[Co] == 1){
				valueX++;
			}
			if(chessboard->chessman[Co] == 2){
				valueY++;
			}
			
		}
		
		if(valueX == 3){
			return x;
		}
		
		if(valueY == 3){
			return y;
		}
	}
	
	return 0; 
}

总结

我的一字棋游戏实现落棋输入没有进行限制，用户违规下棋了没有进行相应的阻止和提示。这是本程序缺点中的一个。棋盘显示不是我个人原创的，但算法的实现是自己设计的。本次算法没有考虑是棋盘对称问题，我是把所有落子的情况都考虑了，最原始的搜索树是固定大小的。就是一个二维数组，把有棋的位置不做考虑。当游戏进行到后面时，逻辑上的搜索树是越来越小的。我写的搜索树在逻辑上是极大极小搜素树的，但是树的实际存储空间是同样大小的。在编程方面，模块化结构设计非常好用，本次写程序出现bug时，绘画棋盘DrawBoard（）函数就能发挥非常大的用处了。

玩^耍^玩
关注
  • 4
    点赞
  • 踩
  • 24
    收藏
    觉得还不错? 一键收藏
  • 4
    评论
C语言教程 C语言编程 一字棋小游戏（3到10阶）
12-03
在本教程中，我们将深入探讨如何使用C语言编写一字棋（N-in-a-row）小游戏，一个可以在3到10阶棋盘上进行的简单而有趣的游戏。一字棋的基本规则是，玩家轮流放置自己的棋子，目标是连续放置N个棋子，无论是水平、...
MATLAB—一字棋（极大极小搜索）
LY_624的专栏
06-10 1927
init.m %初始化棋盘状态 function cur=init() cur=rand(3,3); %存储当前棋盘的状态 %计算机为先手时的初值，即均为0 for i=1:3 for j=1:3 cur(i,j)=0; end end end checkWin.m %检查是否有一方赢棋（0：没有任
基于启发式搜索的一字棋
学习日常分享
06-26 2881
“一字棋"游戏（又叫"三子棋"或"井字棋”），是一款十分经典的益智小游戏。“井字棋"的棋盘很简单，是一个 3×3 的格子，很像中国文字中的"井"字，所以得名"井字棋”。"井字棋"游戏的规则与"五子棋"十分类似，"五子棋"的规则是一方首先五子连成一线就胜利；"井字棋"是一方首先三子连成一线就胜利。 尽可能的朝着可以让计算机获胜的方向走步。需要采用极大极小搜索算法。 “一字棋”游戏（又叫“三子棋”或“井字棋”），是一款十分经典的益智小游戏。“井字棋”的棋盘很简单，是一个 3×3 的格子，很像中国文字中的“井”字
人工智能实验二 利用α-β搜索的博弈树算法编写一字棋游戏
2401_84769813的博客
05-01 874
当然还用一个评估函数，即getvalue()函数，用以对后续状态进行考虑，计算评估值，赢的评估值设为100，输的评估值设为-100，其他情况为 e(P)=e(那些仍为 MAX 空着的完全的行、列或对角线的总数)-e(那些仍为 MIN 空着的完全的行、列或对角线的总数)，通过评估值来表示赢面，数值最大时，为当前局面的最佳落棋位置。MAX节点的评估下限α设为第一个MIN子节点的值，若后续的子节点高于α，则取为新的α，而对于后续评估值小于等于α的节点的搜索可以停止，即进行了α剪枝。这一过程称为 α 剪枝。
5 对抗搜索（11.9）
我是一只小嵩鼠
12-16 1258
博弈是一类多Agent的竞争活动，如下棋、战争等。对于简单的博弈问题，可生成整个博奔树，并找到必胜的策略。对于复杂的博弈问题，不可能生成整个搜索树。
一字棋游戏设计-极大极小搜索
热门推荐
Work Hard, Play Harder!
02-02 1万+
1.     问题定义 一字棋游戏，包括两个选手。用户可以在一个3*3的棋盘上任意的选择空闲的位置拜访棋子，最早在水平方向上，或者垂直方向上或者对角线方向上形成三子一线者获胜。棋盘如图1所示。这里我们实现的是用户和计算机进行对弈。本程序要实现的是让计算机可以自动的根据当前棋局计算下一步对自己最有利的走步，尽可能的朝着可以让计算机获胜的方向走步。需要采用极大极小搜索算法。 图1.一字棋棋盘
五子棋智能算法——博弈树编程实现一字棋（四）
viafcccy的博客
06-02 1万+
一字棋指的是：在一个九宫格内率先连成三个字的取胜 首先，基于前面决策树的讲解 博弈的棋类游戏等等 只要找到合适的估值函数都可以使用博弈树来实现 下面我们来使用博弈树完成一字棋的算法。 根据前面的算法思想我们算法大致分为几步： 1.对棋局落子有正确的估值 2.通过遍历建立博弈树 3.对博弈树进行α-β剪枝增快查找速度（这里由于数据量较小 放在最后一起讲解） 4.根据极大值 极小值搜索...
人工智能技术导论——博弈树搜索
Z875983491的专栏
12-19 4844
我在之前整理过一篇博客关于博弈论和纳什均衡的几个例子https://www.cnblogs.com/wkfvawl/p/11725263.html 这里来介绍博弈树搜索。 一、博弈树的概念 在博弈过程中, 任何一方都希望自己取得胜利。因此,当某一方当前有多个行动方案可供选择时, 他总是挑选对自己最为有利而对对方最为不利的那个行动方案。 此时,如果我们站在A方的立场上,则可供A方...
C语言实现一字棋游戏.doc
09-29
C语言实现一字棋游戏.doc
C语言实现简单五子棋小游戏
08-24
在本文中，我们将详细介绍如何使用C语言实现简单的五子棋小游戏。 1. 棋盘的实现 在五子棋游戏中，棋盘是游戏的基础。我们使用二维数组char board[15][15]来表示棋盘，其中每个元素可以是空格或棋子。为了显示棋盘...
基于c语言实现的黑白棋ai游戏源码
最新发布
05-11
在黑白棋游戏中，AI通常采用最小-最大搜索法配合Alpha-Beta剪枝来预测对手的可能走法并选择最优策略。开发者需要理解这些基本的搜索算法，并根据游戏特性调整搜索深度和启发式函数，以平衡计算效率和游戏难度。 在...
博弈树 一字棋
05-24
人工智能 可曾作业 非常牛逼的作业 欢迎大家参考
一字棋的决策树搜索
01-17
含有详细注释，在linux下编译（在windows下修改环境参数可编译运行）。 实现了人工智能的博弈树范例，运用minmax对策获取一字棋（也成为“井”字棋）游戏的胜利
人工智能下五子棋（基于博弈树极大极小值alpha-beta剪枝搜索算法）
06-23
人工智能下五子棋（基于博弈树极大极小值alpha-beta剪枝搜索算法），代码解析链接参见网址：https://blog.csdn.net/m0_38106923/article/details/93347117
Linux系统下c语言实现简单五子棋游戏
04-07
解压缩后得到main.c和golang.c。 将main.c和golang.c移动到Linux目录下，然后使用 gcc main.c golang.c -o golang 即可编译成功， ./golang 即可运行程序。
井字游戏/一字棋——Max-Min智能算法
wwx1239021388的博客
03-04 2056
西安电子科技大学人工智能概论大作业设计， 采取智能算法中的博弈树思想， 本程序主要采取了Max-Min算法。
约束满足解决8皇后与数独
MrGong123的博客
10-30 2050
算法总结：与前面介绍的基于状态空间的搜索方法相比，CSP可以使用通用策略而不是问题特定的启发式方法来求解复杂问题的原因在于：CSP 将状态进行进一步细分，利用一组变量及其值来表示状态。当每个变量的值满足所有关于变量的约束时，问题就得到了求解。 求解 CSP 的通用方法
一字棋c语言实现
m0_53255923的博客
04-14 214
【代码】一字棋c语言实现。
【人工智能】利用α-β搜索的博弈树算法编写一字棋游戏（QDU）
LJR的博客
01-06 1万+
人工智能 α-β剪枝 博弈树 井字棋 青岛大学 QDU
C语言编写的黑白棋游戏源代码.docx
04-04
这篇文档提供的是一份用C语言编写的黑白棋游戏源代码。黑白棋，又称反棋、翻转棋，是一款双人对战的游戏，玩家通过翻转对手的棋子来赢得比赛。下面我们将详细探讨这份源代码中的关键知识点。 1. **游戏流程控制**：...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值