精华内容
下载资源
问答
  • c语言游戏编程入门到精通
  • c语言游戏编程入门到精通 附带光盘

    千次下载 热门讨论 2007-05-11 09:26:40
    c语言游戏编程入门到精通 附带光盘 压缩包 5M 解压后接近70M的源代码
  • 仅供学习使用,我上传时设定的下载积分为0,如果上涨了,请留言给我修改回来。 请勿用于商业用途,嘿嘿嘿。
  • C语言游戏编程入门到精通,真的不错的一本书籍,推荐学习
  • C语言游戏编程入门到精通.真心不错,希望大家喜欢
  • c语言游戏编程入门到精通,自己还没看,先上传给大伙
  • C语言游戏编程入门到精通.7z 7-zip压缩文件 包含: C语言游戏编程入门到精通.pdf 影印版 C语言游戏编程入门到精通(光盘) 文件夹 DOS下游戏编程的C语言教程,包含图形绘制、中文显示、动画实现、文件调用、...
  • 不错的c语言游戏编程书.很适合喜欢的游戏的朋友
  • C语言游戏编程入门到精通PDF书及源代码光盘
  • c语言游戏编程入门到精通(1)

    热门讨论 2011-03-11 14:27:54
    一本讲述c语言开发游戏的入门书籍,讲解了基本的游戏编程原理与实现,入门参考书籍
  • 一本讲述c语言开发游戏的入门书籍,讲解了基本的游戏编程原理与实现,入门参考书籍
  • 这是提高c语言编程的一本书,希望可以对大家有所帮助!
  • C语言游戏编程

    2011-09-12 17:50:36
    通过本教程,可以简单入门,学习游戏编程
  • 学习C语言的必备资料,大家值得一看,确实可心帮助大家!
  • C语言简单游戏编程入门之中国象棋

    千次阅读 热门讨论 2020-02-11 01:44:11
    //判断是否已经结束游戏(-1:黑胜 0:还没结束 1:红胜) int isOver() { int i,j; //没有將时红胜,没有帥时黑胜 int haveShuai=0,haveJiang=0; for(i=0;i;i++) { for(j=0;j;j++) { if(map[i][j]==...

    运行截图

    在这里插入图片描述

    实现思路

    老套路,二维数组存储棋盘,宏定义各种棋子,每次棋子的移动实质为二维数组的赋值。
    重点是判断棋子是否可移动到目标位置,移动有两种可能,一是单纯移动,二是吃子移动。主要飞将的特殊规则。废话不多说,贴源码(主要下面是两个源文件哦,嘿嘿。)

    源码

    main.c
    #include<stdio.h>
    #include<string.h>
    #include<windows.h>
    //自定义源文件(棋谱结构) 
    #include"manual.c"
    //棋盘行列 
    #define ROWS 10
    #define COLS 9
    //空地 
    #define white 0
    //红方棋子 
    #define isred (map[i][j]>0&&map[i][j]<10)
    #define ju 1
    #define ma 2
    #define xiang 3
    #define shi 4
    #define shuai 5
    #define pao 6
    #define bing 7
    //黑方棋子
    #define isblack (map[i][j]>10)
    #define Ju 11
    #define Ma 12
    #define Xiang 13
    #define Shi 14
    #define Jiang 15
    #define Pao 16
    #define Zu 17 
    //控制输出颜色 
    #define NONECOLOR SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE),7)
    #define REDCOLOR SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE),FOREGROUND_RED)
    #define GREENCOLOR SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE),FOREGROUND_GREEN)
    //当前玩家
    #define red 1
    #define black 0 
    
    //地图 
    int map[ROWS][COLS]={white};
    //棋步 
    char step[20];
    
    //初始化地图 
    void InitializeMap()
    {
    	int i,j;
    	for(i=0;i<ROWS;i++)
    	{
    		for(j=0;j<COLS;j++)
    		{
    			map[i][j]=white;
    		}
    	}
    	
    /*
          0 1 2 3 4 5 6 7 8
    	0车马象士将士象马车
    	1
    	2  砲          砲
    	3卒  卒  卒  卒  卒
    	4
    	5
    	6兵  兵  兵  兵  兵
    	7  炮          炮
    	8  
    	9車馬相仕帥仕相馬車 
    */
    	//黑方子力配置 
    	map[0][0]=Ju;
    	map[0][1]=Ma;
    	map[0][2]=Xiang;
    	map[0][3]=Shi;
    	map[0][4]=Jiang;
    	map[0][5]=Shi;
    	map[0][6]=Xiang;
    	map[0][7]=Ma;
    	map[0][8]=Ju;
    	map[2][1]=Pao;
    	map[2][7]=Pao;
    	map[3][0]=Zu;
    	map[3][2]=Zu;
    	map[3][4]=Zu;
    	map[3][6]=Zu;
    	map[3][8]=Zu;
    	//红方子力配置
    	map[6][0]=bing;
    	map[6][2]=bing;
    	map[6][4]=bing;
    	map[6][6]=bing;
    	map[6][8]=bing; 
    	map[7][1]=pao;
    	map[7][7]=pao;
    	map[9][0]=ju;
    	map[9][1]=ma;
    	map[9][2]=xiang;
    	map[9][3]=shi;
    	map[9][4]=shuai;
    	map[9][5]=shi;
    	map[9][6]=xiang;
    	map[9][7]=ma;
    	map[9][8]=ju;
    }
    
    //打印地图
    void displayMap()
    {
    	int i,j,k;
    	printf(" ");
    	for(k=0;k<COLS;k++)
    	{
    		printf(" %d",k);
    	}
    	printf("\n");
    	for(i=0;i<ROWS;i++)
    	{
    		printf("%d ",i);
    		for(j=0;j<COLS;j++)
    		{
    			if(map[i][j]==white)
    			{
    				NONECOLOR;
    				printf("  ");
    			}
    			else
    			{
    				if(isred)
    				{
    					REDCOLOR;
    				}
    				else if(isblack)
    				{
    					GREENCOLOR;
    				}
    				switch(map[i][j])
    				{
    					case ju:
    						printf("車");
    						break;
    					case Ju:
    						printf("车");
    						break;
    					case ma:
    						printf("馬");
    						break;
    					case Ma:
    						printf("马");
    						break;
    					case xiang:
    						printf("相");
    						break;
    					case Xiang:
    						printf("象");
    						break;
    					case shi:
    						printf("仕");
    						break;
    					case Shi:
    						printf("士");
    						break;
    					case shuai:
    						printf("帥");
    						break;
    					case Jiang:
    						printf("將");
    						break;
    					case pao:
    						printf("炮");
    						break;
    					case Pao:
    						printf("砲");
    						break;
    					case bing:
    						printf("兵");
    						break;
    					case Zu:
    						printf("卒");
    						break;
    				}	
    			}
    		}	
    		NONECOLOR;
    		printf("\n");
    	}	
    	/*
    	char border[][3]={"九","八","七","六","五","四","三","二","一"};
    	printf("  ");
    	for(k=0;k<9;k++)
    	{
    		printf("%s",border[k]);
    	}
    	*/
    	printf("\n\n"); 
    } 
    
    //将(x1,y1)的棋子移动到(x2,y2) 
    void movePiece(int x1,int y1,int x2,int y2)
    {
    	map[x2][y2]=map[x1][y1];
    	map[x1][y1]=white;
    }
    
    //获取玩家需要移动的棋子位置和移动到的目标位置
    int getInput(int *x1,int *y1,int *x2,int *y2)
    {
    	printf("\n输入棋子坐标和目的坐标(全为-1时表示查看当前棋谱):\n");
    	scanf("%d %d %d %d",x1,y1,x2,y2);
    	if((*x1)<0||(*x1)>ROWS||(*y1)<0||(*y1)>COLS||(*x2)<0||(*x2)>ROWS||(*y2<0)||(*y2)>COLS)
    	{
    		return 0;
    	}
    	else if((*x1)==(*x2)&&(*y1)==(*y2))
    	{
    		return 0;
    	}
    	return 1;
    } 
    
    //判断是否已经结束游戏(-1:黑胜 0:还没结束 1:红胜) 
    int isOver()
    {
    	int i,j;
    	//没有將时红胜,没有帥时黑胜
    	int haveShuai=0,haveJiang=0;
    	for(i=0;i<ROWS;i++)
    	{
    		for(j=0;j<COLS;j++)
    		{
    			if(map[i][j]==shuai)
    			{
    				haveShuai=1;		
    			}	
    			else if(map[i][j]==Jiang)
    			{
    				haveJiang=1;
    			}
    		}	
    	}	
    	if(haveShuai==0)
    	{
    		return -1;
    	}
    	else if(haveJiang==0)
    	{
    		return 1;
    	}
    	else
    	{
    		return 0;
    	}
    } 
    
    //输出赢家 
    void displayWinner(int winner)
    {
    	if(winner==1)
    	{
    		printf("红胜!\n");
    	}
    	else if(winner==-1)
    	{
    		printf("黑胜!\n");
    	}
    }
    
    //打印当前回合的玩家
    void displayPlayer(int player)
    {
    	printf("=======");
    	if(player==red)
    	{
    		printf("红方回合"); 
    	}
    	else if(player==black)
    	{
    		printf("黑方回合"); 	
    	}
    	printf("=======");	
    } 
    
    //交替到对方回合 
    void exchangePlayer(int *player)
    {
    	if((*player)==red)
    	{
    		*player=black;
    	}
    	else if((*player)==black)
    	{
    		*player=red;
    	}
    }
    
    //坐标(x1,y1)上的棋子是否能移动到(x2,y2)上 
    int canMove(int x1,int y1,int x2,int y2,int player)
    {
    	//当(x2,y2)为己方棋子时,不可以
    	if(map[x2][y2]>0&&map[x2][y2]<10&&player==red||map[x2][y2]>10&&player==black)
    	{
    		return 0;	
    	} 
    	int piece=map[x1][y1];
    	int i,j;
    	int start,end;
    	int eye_x=-1,eye_y=-1;
    	int count=0;
    	switch(piece)
    	{
    		//車、车 
    		case ju:
    		case Ju:
    			if(x1==x2)
    			{
    				start=y1;
    				end=y2;
    				i=x1;
    				if(y1>y2)
    				{
    					start=y2;
    					end=y1;
    				}
    				for(j=start+1;j<end;j++)
    				{
    					if(map[i][j]!=white)
    					{
    						return 0;
    					}
    				}
    			}
    			else if(y1==y2)
    			{
    				start=x1;
    				end=x2;
    				j=y1;
    				if(x1>x2)
    				{
    					start=x2;
    					end=x1;
    				}
    				for(i=start+1;i<end;i++)
    				{
    					if(map[i][j]!=white)
    					{
    						return 0;
    					}
    				}
    			}
    			else
    			{
    				return 0;
    			}
    			break;
    		case ma:
    		case Ma:
    			if(abs(x1-x2)==1&&y1-y2==2)
    			{
    				eye_x=x1;
    				eye_y=y1-1;
    			}
    			else if(abs(x1-x2)==1&&y1-y2==-2)
    			{
    				eye_x=x1;
    				eye_y=y1+1;
    			}
    			else if(abs(y1-y2)==1&&x1-x2==2)
    			{
    				eye_x=x1-1;
    				eye_y=y1;
    			}
    			else if(abs(y1-y2)==1&&x1-x2==-2)
    			{
    				eye_x=x1+1;
    				eye_y=y1;
    			}
    			if(eye_x==-1&&eye_y==-1)
    			{
    				return 0;
    			}
    			else if(map[eye_x][eye_y]!=white)
    			{
    				return 0;
    			}
    			break;
    		case xiang:
    		case Xiang:
    			//相(象)过河 
    			if((player==red&&x2<5)||(player==black&&x2>4)) 
    			{
    				return 0;
    			}
    			else if(abs(x1-x2)==2&&abs(y1-y2)==2)
    			{
    				eye_x=(x1+x2)/2;
    				eye_y=(y1+y2)/2;
    				if(map[eye_x][eye_y]!=white)
    				{
    					return 0;
    				}
    			}
    			else
    			{
    				return 0;
    			}
    			break;
    		case shi:
    		case Shi:
    			//出九宫
    			if(player==red&&(x2<7||y2<3||y2>5)||player==black&&(x2>2||y2<3||y2>5))
    			{
    				return 0;	
    			} 
    			//不是走的斜一格 
    			else if(abs(x1-x2)!=1||abs(y1-y2)!=1)
    			{
    				return 0;
    			}
    			break;
    		case shuai:
    		case Jiang:
    			//飞将
    			if((player==red&&x2<3||player==black&&x2>6)&&y1==y2)
    			{
    				start=x1;
    				end=x2;
    				j=y1;
    				if(x1>x2)
    				{
    					start=x2;
    					end=x1;	
    				}	
    				for(i=start+1;i<end;i++)
    				{
    					if(map[i][j]!=white)
    					{
    						return 0;
    					}
    				}
    			} 
    			else if(y2<3||y2>5||player==red&&x2<7||player==black&&x2>2||abs(x1-x2)+abs(y1-y2)!=1)
    			{
    				return 0;
    			}
    			break;
    		case pao:
    		case Pao:
    			if(x1==x2)
    			{
    				start=y1;
    				end=y2;
    				i=x1;
    				if(y1>y2)
    				{
    					start=y2;
    					end=y1;
    				}
    				for(j=start+1;j<end;j++)
    				{
    					if(map[i][j]!=white)
    					{
    						count++;
    					}
    				}
    				if(count>1)
    				{
    					return 0;
    				}
    				else if(count==1)
    				{
    					if(map[x2][y2]>10&&player==red||map[x2][y2]>0&&map[x2][y2]<10&&player==black)
    					{
    						return 1;
    					}
    					else
    					{
    						return 0;
    					}
    				}
    			}
    			else if(y1==y2)
    			{
    				start=x1;
    				end=x2;
    				j=y1;
    				if(x1>x2)
    				{
    					start=x2;
    					end=x1;
    				}
    				for(i=start+1;i<end;i++)
    				{
    					if(map[i][j]!=white)
    					{
    						count++;
    					}
    				}
    				if(count>1)
    				{
    					return 0;
    				}
    				else if(count==1)
    				{
    					if(map[x2][y2]>10&&player==red||map[x2][y2]>0&&map[x2][y2]<10&&player==black)
    					{
    						return 1;
    					}
    					else
    					{
    						return 0;
    					}
    				}
    			}
    			else
    			{
    				return 0;
    			}
    			break;
    		case bing:
    		case Zu:
    			//不是横或纵走一格 
    			if((abs(x1-x2)+abs(y1-y2))!=1)
    			{
    				return 0;
    			}
    			//没过河时便左右移动 
    			if(player==red&&x1>=5&&(abs(y1-y2)==1)||player==black&&(x1<=4)&&(abs(y1-y2)==1))
    			{
    				return 0;
    			}
    			//往后退 
    			else if(player==red&&(x1-x2==-1)||player==black&&(x2-x1==-1))
    			{
    				return 0;
    			}
    			break;
    	}
    	return 1;
    } 
    
    //获得棋子名字 
    char *getPieceName(int piece)
    {
    	switch(piece)
    	{
    		case Ju:
    			return "车";
    		case ju:
    			return "車";
    		case Ma:
    			return "马";
    		case ma:
    			return "馬";
    		case Xiang:
    			return "象";
    		case xiang:
    			return "相";
    		case Shi:
    			return "士";
    		case shi:
    			return "仕";
    		case Jiang:
    			return "將";
    		case shuai:
    			return "帥";
    		case Pao:
    			return "砲";
    		case pao:
    			return "炮";
    		case Zu:
    			return "卒";
    		case bing:
    			return "兵";
    	}
    	return "";
    }
    
    //获得棋步 
    void getStep(int x1,int y1,int x2,int y2,int player)
    {
    	//清空之前棋步 
    	step[0]='\0';
    	char border_red[][3]={"九","八","七","六","五","四","三","二","一"};
    	char border_black[][3]={"1","2","3","4","5","6","7","8","9"};
    	int i,j;
    	int piece=map[x1][y1];
    	int last=0,next=0;
    	j=y1;
    	for(i=0;i<x1;i++)
    	{
    		if(map[i][j]==piece)
    		{
    			last=1;
    			break;
    		}
    	}
    	for(i=x1+1;i<ROWS;i++)
    	{
    		if(map[i][j]==piece)
    		{
    			next=1;
    			break;
    		}
    	}
    	if(last==1&&next==1)
    	{
    		strcat(step,"中");
    	}	
    	else if(last==1)
    	{
    		if(player==red)
    		{
    			strcat(step,"后");
    		}
    		else
    		{
    			strcat(step,"前");
    		}
    	}
    	else if(next==1)
    	{
    		if(player==red)
    		{
    			strcat(step,"前");
    		}
    		else
    		{
    			strcat(step,"后");
    		}
    	}
    	strcat(step,getPieceName(map[x1][y1]));
    	if(last==0&&next==0)
    	{
    		if(player==red)
    		{
    			strcat(step,border_red[y1]);
    		}
    		else
    		{
    			strcat(step,border_black[y1]);	
    		}
    	}
    	if(x1==x2)
    	{
    		strcat(step,"平");
    		if(player==red)
    		{
    			strcat(step,border_red[y2]);
    		}
    		else
    		{
    			strcat(step,border_black[y2]);	
    		}
    		return;
    	}
    	int distance=x2-x1;
    	switch(map[x1][y1])
    	{
    		case Ju:
    		case Jiang:
    		case Pao:
    		case Zu:
    			if(distance>0)
    			{
    				strcat(step,"进");
    			}
    			else
    			{
    				strcat(step,"退");
    			}
    			strcat(step,border_black[abs(distance)-1]);
    			break;
    		case Ma:
    		case Xiang:
    		case Shi:
    			if(distance>0)
    			{
    				strcat(step,"进");
    			}
    			else
    			{
    				strcat(step,"退");
    			}
    			strcat(step,border_black[y2]);
    			break;
    		case ju:
    		case shuai:
    		case pao:
    		case bing:
    			if(distance>0)
    			{
    				strcat(step,"退");
    			}
    			else
    			{
    				strcat(step,"进");
    			}
    			strcat(step,border_red[9-abs(distance)]);
    			break;
    		case ma:
    		case xiang:
    		case shi:
    			if(distance>0)
    			{
    				strcat(step,"退");
    			}
    			else
    			{
    				strcat(step,"进");
    			}
    			strcat(step,border_red[y2]);
    			break;
    	}
    }
    
    int main()
    {
    	InitializeMap();
    	//棋谱 
    	manual m;
    	//初始化棋谱 
    	initializeManual(&m);
    	//游戏是否已经结束 
    	int isEnd=0;
    	//坐标
    	int x1,y1,x2,y2; 
    	//输入是否合法
    	int inputRight; 
    	//移动是否成功
    	int moveSuccess; 
    	//当前玩家
    	int player=red; 
    	while(!isEnd)
    	{
    		system("cls");							//清屏
    		displayMap();							//打印现在棋局
    		displayPlayer(player);					//当前玩家回合 
    		inputRight=getInput(&x1,&y1,&x2,&y2);	//接收玩家输入
    		if(x1==-1&&x2==-1&&y1==-1&&y2==-1)		//请求打印棋谱 
    		{
    			displayManual(m);					//打印棋谱 
    		}
    		if(inputRight)							//输入成功 
    		{
    												//是否选择己方棋子 
    			if(map[x1][y1]>0&&map[x1][y1]<10&&player==red||map[x1][y1]>10&&player==black)
    			{
    												//是否可以移动 
    				moveSuccess=canMove(x1,y1,x2,y2,player);
    				if(moveSuccess)					//可以移动 
    				{								//按照输入移动棋子 
    					getStep(x1,y1,x2,y2,player);
    					insertStep(step,&m);		//添加棋步到棋谱中 
    					printf("当前棋步为-->>%s\n",step);//打印当前棋步 
    					system("pause");
    					movePiece(x1,y1,x2,y2);	
    					exchangePlayer(&player);	//移动成功,轮到对方回合							
    					isEnd=isOver();				//判断棋局是否已经结束		
    				}
    			}	
    		} 
    	}
    	system("cls");
    	displayMap();								//打印现在棋局
    	displayWinner(isEnd);
    	saveManual(m,"manual.txt");
    	return 0;
    }
    
    
    manual.c
    #ifndef manual_c
    #define manual_c
    #define MAXCOUNT 200
    //棋谱结构 
    typedef struct manual
    {
    	int count;
    	char step[MAXCOUNT][20];	
    }manual;
    
    //初始化棋谱 
    void initializeManual(manual *m)
    {
    	m->count=0;
    }
    
    //打印棋谱 
    void displayManual(manual m)
    {
    	printf("\n");
    	if(m.count==0)
    	{
    		printf("当前棋谱为空!\n");	
    	} 
    	int i;
    	for(i=0;i<m.count;i++)
    	{
    		if(i%2==0)
    		{
    			printf("%d-->>",i/2+1);
    		}
    		printf("%s  ",m.step[i]);
    		if(i%2==1)
    		{
    			printf("\n");
    		}
    	}
    	printf("\n");
    	system("pause"); 
    }
    
    //添加棋步
    void insertStep(char step[],manual *m)
    {
    	if(m->count>=MAXCOUNT)
    	{
    		return;
    	}
    	int i=m->count;
    	strcpy(m->step[i],step);
    	i++;
    	m->count=i;	
    } 
    
    //删除棋步
    void deleteStep(manual *m)
    {
    	int i=m->count;
    	i--;
    	m->count=i;	
    } 
    
    //保存棋谱 
    void saveManual(manual m,char filepath[])
    {
    	int i;
    	FILE *fp=fopen(filepath,"w");
    	for(i=0;i<m.count;i++)
    	{
    		fprintf(fp,"%s\n",m.step[i]);
    	}
    	fclose(fp);
    	printf("\n棋谱保存成功!\n");
    }
    
    //读取棋谱
    void readManual(manual *m,char filepath[])
    {
    	int i=0;
    	FILE *fp=fopen(filepath,"r");
    	if(fp==NULL)
    	{
    		printf("棋谱文件丢失!\n");
    		return;
    	}
    	while(1)
    	{
    		if(fscanf(fp,"%s",m->step[i])==EOF)
    		{
    			break;
    		}
    		i++;
    	}
    	m->count=i;
    	fclose(fp);	
    } 
    #endif
    
    展开全文
  • 内容十分有用,并且生动。十分有利于初学者入门。可谓,入门必备。且有源代码。对我而言相当不错。希望对你也有用。
  • 对给定四个1~10的正整数求解计算24点的运算过程 效果截图 源码 /* 头文件引入 */ #include<stdio.h> #include<string.h> #include<stdlib.h> #include<math.h> /* 问题分析 */ ...d)

    对给定四个1~10的正整数求解计算24点的运算过程

    效果截图

    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述

    源码

    /* 头文件引入 */
    #include<stdio.h>
    #include<string.h>
    #include<stdlib.h>
    #include<math.h>
    
    /* 问题分析 */
    /*
    	假设四个数排列顺序为 a,b,c,d 
    	则其计算顺序总共有:
    	1.((a?b)?c)?d 
    	2.(a?b)?(c?d)
    	3.(a?(b?c)?)d 
    	4.a?((b?c)?d)
    	5.a?(b?(c?d))
    	其中?代表(+ - * /)中的任意一个运算符号 
    	
    	排列有24种可能,计算顺序有5种可能,运算符号有64种可能,暴力破解有7680种可能,远远小于计算机一秒能执行指令的条数 
    	设计算法时,先遍历所有的四数排列顺序,再遍历计算顺序,最后再遍历运算符号,由于问题规模不大,可以通过暴力破解得到运算结果。 
    */
    
    /* 常量定义 */
    #define LENGTHARRAY 300						//数组长度
    #define LENGTHANSWER 20						//答案长度 
    #define MIN 1e-6							//绝对值最接近0的代表数 
    
    /* 数据结构定义 */
    typedef struct answer						//答案结构 
    {
    	char s[LENGTHARRAY][LENGTHANSWER];		//答案数组 
    	int length;								//答案数组长度 
    }Answer;
    
    /* 全局变量定义 */
    float number[4];							//四个1~10的正整数
    float nums[24][4];							//排列好的四个正整数列表 
    char operater[4]={'+','-','*','/'};			//加减乘除 
    Answer a;									//答案数组
    
    /* 函数定义 */
    void input();								//输入四个正整数 
    void arrange();								//对输入的四个正整数进行排列 
    float count(float n1,float n2,char op);		//对两数和运算符计算 
    void maybe_01(float n[]);					//第一种可能的运算顺序(1.((a?b)?c)?d )
    void maybe_02(float n[]);					//第二种可能的运算顺序(2.(a?b)?(c?d) )
    void maybe_03(float n[]);					//第三种可能的运算顺序(3.(a?(b?c)?)d )
    void maybe_04(float n[]);					//第四种可能的运算顺序(4.a?((b?c)?d) )
    void maybe_05(float n[]);					//第五种可能的运算顺序(5.a?(b?(c?d)) )
    void getAnswer();							//破解答案 
    void print();								//输出所有答案 
    
    /* 主函数 */
    int main()
    {
    	input();
    	arrange();
    	getAnswer();
    	print();
    	system("pause");						//按任意键继续 
    	return 0;
    }
    
    /* 函数实现 */
    void input()								//输入四个正整数 
    {
    	printf("\n请分别输入四个1~10的正整数(以空格隔开):\n");
    	scanf("%f %f %f %f",&number[0],&number[1],&number[2],&number[3]);
    	printf("输入完毕!\n"); 
    } 
    
    void arrange()								//对输入的四个正整数进行排列(abcd,abdc,acbd,acdb...总24中可能) 
    {
    	printf("\n正在对四个正整数进行排列!\n");
    	int v,w,x,y;
    	int i=0;
    	for(v=0;v<4;v++)
    	{
    		for(w=0;w<4;w++)
    		{
    			for(x=0;x<4;x++)
    			{
    				for(y=0;y<4;y++)
    				{
    					if(!(v==w||v==x||v==y||w==x||w==y||x==y))
    					{
    						nums[i][0]=number[v];
    						nums[i][1]=number[w];
    						nums[i][2]=number[x];
    						nums[i][3]=number[y];
    						i++; 
    					}
    				}
    			}
    		}
    	}
    	printf("排列完毕!\n");
    }
    
    float count(float n1,float n2,char op)		//对两数和运算符计算 
    {
    	switch(op)
    	{
    		case '+':
    			return n1+n2;
    			break;
    		case '-':
    			return n1-n2;
    			break;
    		case '*':
    			return n1*n2;
    			break;
    		case '/':
    			if(fabs(n2-0)<MIN)
    			{
    				return 1000;
    			}
    			else
    			{
    				return n1/n2;
    			}
    			break;
    	}
    }
    
    void maybe_01(float n[])					//第一种可能的运算顺序(1.((a?b)?c)?d )
    {
    	int i,j,k;
    	char r[20]="\0";
    	float one,two,three;
    	int m,flag,p;
    	for(i=0;i<4;i++)
    	{
    		one=count(n[0],n[1],operater[i]);
    		if(fabs(one-1000)<MIN)
    		{
    			continue;
    		}
    		for(j=0;j<4;j++)
    		{
    			two=count(one,n[2],operater[j]);
    			if(fabs(two-1000)<MIN)
    			{
    				continue;
    			}
    			for(k=0;k<4;k++)
    			{
    				three=count(two,n[3],operater[k]);
    				if(fabs(three-24)<MIN)
    				{
    					r[0]='(';
    					r[1]='(';
    					r[2]=(int)n[0]+'0';
    					r[3]=operater[i];
    					r[4]=(int)n[1]+'0';
    					r[5]=')';
    					r[6]=operater[j];
    					r[7]=(int)n[2]+'0';
    					r[8]=')';
    					r[9]=operater[k];
    					r[10]=(int)n[3]+'0';
    					r[11]='\0';
    					flag=0;
    					for(m=0;m<a.length;m++)
    					{
    						if(strcmp(a.s[m],r)==0)
    						{
    							flag=1;
    							break;
    						}
    					}
    					if(flag==0)
    					{
    						m=a.length;
    						for(p=0;p<20;p++)
    						{
    							a.s[m][p]=r[p];
    							if(r[p]=='\0')
    							{
    								break;
    							}
    						}
    						a.length++;
    					}
    				}
    			}
    		}
    	}
    }
    
    void maybe_02(float n[])					//第二种可能的运算顺序(2.(a?b)?(c?d) )
    {
    	int i,j,k;
    	char r[20]="\0";
    	float one,two,three;
    	int m,flag,p;
    	for(i=0;i<4;i++)
    	{
    		one=count(n[0],n[1],operater[i]);
    		if(fabs(one-1000)<MIN)
    		{
    			continue;
    		}
    		for(j=0;j<4;j++)
    		{
    			two=count(n[2],n[3],operater[j]);
    			if(fabs(two-1000)<MIN)
    			{
    				continue;
    			}
    			for(k=0;k<4;k++)
    			{
    				three=count(one,two,operater[k]);
    				if(fabs(three-24)<MIN)
    				{
    					r[0]='(';
    					r[1]=(int)n[0]+'0';
    					r[2]=operater[i];
    					r[3]=(int)n[1]+'0';
    					r[4]=')';
    					r[5]=operater[k];
    					r[6]='(';
    					r[7]=(int)n[2]+'0';
    					r[8]=operater[j];
    					r[9]=(int)n[3]+'0';
    					r[10]=')';
    					r[11]='\0';
    					flag=0;
    					for(m=0;m<a.length;m++)
    					{
    						if(strcmp(a.s[m],r)==0)
    						{
    							flag=1;
    							break;
    						}
    					}
    					if(flag==0)
    					{
    						m=a.length;
    						for(p=0;p<20;p++)
    						{
    							a.s[m][p]=r[p];
    							if(r[p]=='\0')
    							{
    								break;
    							}
    						}
    						a.length++;
    					}
    				}
    			}
    		}
    	}
    }
    
    void maybe_03(float n[])					//第三种可能的运算顺序(3.(a?(b?c)?)d )
    {
    	int i,j,k;
    	char r[20]="\0";
    	float one,two,three;
    	int m,flag,p;
    	for(i=0;i<4;i++)
    	{
    		one=count(n[1],n[2],operater[i]);
    		if(fabs(one-1000)<MIN)
    		{
    			continue;
    		}
    		for(j=0;j<4;j++)
    		{
    			two=count(n[0],one,operater[j]);
    			if(fabs(two-1000)<MIN)
    			{
    				continue;
    			}
    			for(k=0;k<4;k++)
    			{
    				three=count(two,n[3],operater[k]);
    				if(fabs(three-24)<MIN)
    				{
    					r[0]='(';
    					r[1]=(int)n[0]+'0';
    					r[2]=operater[j];
    					r[3]='(';
    					r[4]=(int)n[1]+'0';
    					r[5]=operater[i];
    					r[6]=(int)n[2]+'0';
    					r[7]=')';
    					r[8]=')';
    					r[9]=operater[k];
    					r[10]=(int)n[3]+'0';
    					r[11]='\0';
    					flag=0;
    					for(m=0;m<a.length;m++)
    					{
    						if(strcmp(a.s[m],r)==0)
    						{
    							flag=1;
    							break;
    						}
    					}
    					if(flag==0)
    					{
    						m=a.length;
    						for(p=0;p<20;p++)
    						{
    							a.s[m][p]=r[p];
    							if(r[p]=='\0')
    							{
    								break;
    							}
    						}
    						a.length++;
    					}
    				}
    			}
    		}
    	}
    }
    
    void maybe_04(float n[])					//第四种可能的运算顺序(4.a?((b?c)?d) )
    {
    	int i,j,k;
    	char r[20]="\0";
    	float one,two,three;
    	int m,flag,p;
    	for(i=0;i<4;i++)
    	{
    		one=count(n[1],n[2],operater[i]);
    		if(fabs(one-1000)<MIN)
    		{
    			continue;
    		}
    		for(j=0;j<4;j++)
    		{
    			two=count(one,n[3],operater[j]);
    			if(fabs(two-1000)<MIN)
    			{
    				continue;
    			}
    			for(k=0;k<4;k++)
    			{
    				three=count(n[0],two,operater[k]);
    				if(fabs(three-24)<MIN)
    				{
    					r[0]=(int)n[0]+'0';
    					r[1]=operater[k];
    					r[2]='(';
    					r[3]='(';
    					r[4]=(int)n[1]+'0';
    					r[5]=operater[i];
    					r[6]=(int)n[2]+'0';
    					r[7]=')';
    					r[8]=operater[j];
    					r[9]=(int)n[3]+'0';
    					r[10]=')';
    					r[11]='\0';
    					flag=0;
    					for(m=0;m<a.length;m++)
    					{
    						if(strcmp(a.s[m],r)==0)
    						{
    							flag=1;
    							break;
    						}
    					}
    					if(flag==0)
    					{
    						m=a.length;
    						for(p=0;p<20;p++)
    						{
    							a.s[m][p]=r[p];
    							if(r[p]=='\0')
    							{
    								break;
    							}
    						}
    						a.length++;
    					}
    				}
    			}
    		}
    	}
    }
    
    void maybe_05(float n[])					//第五种可能的运算顺序(5.a?(b?(c?d)) )
    {
    	int i,j,k;
    	char r[20]="\0";
    	float one,two,three;
    	int m,flag,p;
    	for(i=0;i<4;i++)
    	{
    		one=count(n[2],n[3],operater[i]);
    		if(fabs(one-1000)<MIN)
    		{
    			continue;
    		}
    		for(j=0;j<4;j++)
    		{
    			two=count(n[1],one,operater[j]);
    			if(fabs(two-1000)<MIN)
    			{
    				continue;
    			}
    			for(k=0;k<4;k++)
    			{
    				three=count(n[0],two,operater[k]);
    				if(fabs(three-24)<MIN)
    				{
    					r[0]=(int)n[0]+'0';
    					r[1]=operater[k];
    					r[2]='(';
    					r[3]=(int)n[1]+'0';
    					r[4]=operater[j];
    					r[5]='(';
    					r[6]=(int)n[2]+'0';
    					r[7]=operater[i];
    					r[8]=(int)n[3]+'0';
    					r[9]=')';
    					r[10]=')';
    					r[11]='\0';
    					flag=0;
    					for(m=0;m<a.length;m++)
    					{
    						if(strcmp(a.s[m],r)==0)
    						{
    							flag=1;
    							break;
    						}
    					}
    					if(flag==0)
    					{
    						m=a.length;
    						for(p=0;p<20;p++)
    						{
    							a.s[m][p]=r[p];
    							if(r[p]=='\0')
    							{
    								break;
    							}
    						}
    						a.length++;
    					}
    				}
    			}
    		}
    	} 
    }
    
    void getAnswer()							//破解答案 
    {
    	int i;
    	printf("\n正在破解答案\n");
    	for(i=0;i<24;i++)
    	{
    		maybe_01(nums[i]);
    		maybe_02(nums[i]);
    		maybe_03(nums[i]);
    		maybe_04(nums[i]);
    		maybe_05(nums[i]);
    	}
    	printf("破解完毕!\n");
    }
    
    void print()								//输出所有答案 
    {
    	int i,j;
    	if(a.length==0)
    	{
    		printf("\n无解!\n");
    		return;
    	}
    	printf("\n答案如下:\n");
    	for(i=0;i<a.length;i++)
    	{
    		printf("%d-->>",i+1);
    		for(j=0;j<20;j++)
    		{
    			if(a.s[i][j]=='\0')
    			{
    				printf("\n");
    				break;
    			}
    			else if(a.s[i][j]==':')
    			{
    				printf("10");
    			}
    			else
    			{
    				printf("%c",a.s[i][j]);
    			}
    		}
    	}
    	printf("答案打印完毕!\n\n");
    }
    

    设计思路

    求解思路及理论基础:四个数abcd,排列有24种可能[ abcd , abdc , acbd , acdb , adbc , adcb …),运算顺序有5种可能[ (a?(b?c))?d , a?((b?c)?d) , ((a?b)?c)?d , (a?b)?(c?d) , a?(b?(c?d)) ],其中问号属于运算符[ + , - , * , / ]中的一种,运算符的排列有64种可能[ + + + , + + - , + + * , + + / , … ]。不去重情况下总共7680种可能,计算机每秒大概执行1亿条指令,所以说本问题可以考虑用暴力破解强行遍历所有可能进行求解。
    子问题分离划分模块
    1.输入并排列输入的四个数。
    2.给定顺序的四个数按每个可能的运算顺序和运算符号匹配时可以算出24点且没有重复时保存到答案数组中去。
    3.求解结束,输入结果。
    我的设计过程
    1.定义全局变量:浮点型数组number[4]用于接收用户输入的四个待求解正整数,这里肯定有小伙伴疑惑用浮点数而不是用整形int来声明,我简单说明一下(在计算的过程中有的时候会用到小数,比如以上运行截图中的,由于C语言中小数是不能判断等于与否的,只能将两数相减,再求结果的绝对值和一个极其近似于0的小数比较,小于那个数就视为原来的两数相等);浮点型数组nums[24][4]用于保存排列好的整数顺序;运算符字符数组operater[4]={’+’,’-’,’*’,’/’}用于描述运算符号;求解结果答案变量a(答案结构为

    /* 常量定义 */
    #define LENGTHARRAY 300						//数组长度
    #define LENGTHANSWER 20						//答案长度 
    #define MIN 1e-6							//绝对值接近0的代表数,相当于0.0000001 
    /* 数据结构定义 */
    typedef struct answer						//答案结构 
    {
    	char s[LENGTHARRAY][LENGTHANSWER];		//答案数组 
    	int length;								//答案数组长度 
    }Answer;
    

    )。
    2.明确程序流程(主函数结构):数据输入->数据排列->每种可能试探->可以计算出24点且未重复则添加进答案中->试探完毕,将结果输出。
    3.分别实现流程中的函数数据输入(略);数据排列,分别设计四个整形变量v,w,x,y用来表示输入数组number的下标,将它们分别从0到3进行嵌套遍历,当它们两两不等的时候,说明这是一个符合要求的排列,即此时的一个排列abcd为number[v],number[w],number[x],number[y],此时将其加入到排好的数据列表nums中去;第一种运算顺序试探,将三个整形变量分别进行0到3嵌套遍历,在其运算符号和运算顺序下是否可以计算出24点(注意要用运算结果减去24的差的绝对值和接近于0的值相比较:小于时视为结果符号要求,而不是直接将运算结果和24比较),将结果为24点的运算式子与已经存在的答案列表中的各个式子相比较,没有重复的话就添加进答案列表中;打印答案(略)。
    4.程序测试(略)

    展开全文
  • 游戏截图 源代码 #include<stdio.h> #include<stdlib.h> //棋局 char map[3][3]; //行列 int row=3,col=3; //棋子类型 char o='O',x='X',m=' '; //当前棋子类型 char nowType='O'; //已落子数量 int ...

    游戏截图

    在这里插入图片描述
    在这里插入图片描述

    源代码

    person.h

    //玩家对战 
    void person()
    {
    	int i,j;
    	initMap(map);
    	//打印棋局 
    	displayMap(map);
    	//未分出胜负且棋局未落满子前无限循环 
    	while(1)
    	{
    		//获取玩家下子位置 
    		getXY(&i,&j);
    		//玩家落子
    		setPiece(map,i,j);
    		//清屏 
    		system("cls");
    		//打印棋局 
    		displayMap(map);
    		//玩家落子后判断是否已经分出胜负
    		if(isWin(map)==1)
    		{
    			//输出获胜方 
    			displayWinner();
    			break;
    		}
    		//是否棋局已满 
    		else if(count==row*col)
    		{
    			printf("平局!\n");
    			break;	
    		} 
    		//交替到对手回合
    		exchangeTurn(); 
    	}
    }
    

    computer.h

    //局面价值 
    int getSum(char map[][col])
    {
    	int sumO=0,sumX=0;
    	int i,j;
    	for(i=0;i<row;i++)
    	{
    		for(j=0;j<col;j++)
    		{
    			if(map[i][j]=='O')
    			{
    				sumO+=score[i][j];
    			}
    			else if(map[i][j]=='X')
    			{
    				sumX+=score[i][j];
    			}
    		}
    	}
    	return sumX-sumO;
    }
    
    //思考
    void think(char map[][col])
    {
    	int canWin=0;
    	int i,j;
    	int x=-1,y=-1;
    	int sum;
    	int maxSum=-20;
    	count++;
    	for(i=0;i<row;i++)
    	{
    		for(j=0;j<col;j++)
    		{
    			if(map[i][j]==m)
    			{
    				map[i][j]='X';
    				
    				//能获胜,直接落子此处 
    				if(isWin(map))
    				{
    					return;
    				}
    				//不能获胜,落子在分数最多的地方 
    				else
    				{
    					map[i][j]='O';
    					if(isWin(map))
    					{
    						map[i][j]='X';
    						return;
    					}
    					map[i][j]='X';
    					sum=getSum(map);
    					if(sum>maxSum)
    					{
    						maxSum=sum;
    						x=i;
    						y=j;
    					}
    				}
    				
    				map[i][j]=m;	
    			} 
    		}
    	}
    	map[x][y]='X';	
    }
    
    void computer()
    {
    	int i,j;
    	char computerType='X';
    	initMap(map);
    	//打印棋局 
    	displayMap(map);
    	//未分出胜负且棋局未落满子前无限循环 
    	while(1)
    	{
    		//电脑落子 
    		if(nowType==computerType)
    		{
    			printf("电脑落子:");
    			think(map);
    		}
    		//玩家落子 
    		else
    		{
    			//获取玩家下子位置 
    			getXY(&i,&j);
    			//玩家落子
    			setPiece(map,i,j);
    		}
    	
    		//清屏 
    		system("cls");
    		//打印棋局 
    		displayMap(map);
    		//玩家落子后判断是否已经分出胜负
    		if(isWin(map)==1)
    		{
    			//输出获胜方 
    			displayWinner();
    			break;
    		}
    		//是否棋局已满 
    		else if(count==row*col)
    		{
    			printf("平局!\n");
    			break;	
    		} 
    		//交替到对手回合
    		exchangeTurn(); 
    	}
    }
    

    main.c

    #include<stdio.h>
    #include<stdlib.h>
    
    //棋局
    char map[3][3];
    //行列
    int row=3,col=3;
    //棋子类型
    char o='O',x='X',m=' ';
    //当前棋子类型
    char nowType='O'; 
    //已落子数量
    int count=0; 
    
    //初始化棋局 
    void initMap(char map[][col])
    {
    	int i,j;
    	for(i=0;i<row;i++)
    	{
    		for(j=0;j<col;j++)
    		{
    			map[i][j]=m;
    		}
    	}
    }
    
    //打印当前棋局 
    void displayMap(char map[][col])
    {
    	int i,j;
    	printf("   ");
    	for(i=0;i<col;i++)
    	{
    		printf("%d ",i);
    	}
    	printf("\n  ");
    	for(i=0;i<2*col+1;i++)
    	{
    		printf("*");
    	}
    	printf("\n");
    	for(i=0;i<row;i++)
    	{
    		printf("%d  ",i);
    		for(j=0;j<col;j++)
    		{
    			printf("%c ",map[i][j]);
    		}
    		printf("\n  ");
    		for(j=0;j<2*col+1;j++)
    		{
    			printf("*");
    		}
    		printf("\n");
    	}
    }
    
    //获取用户输入
    void getXY(int *i,int *j)
    {
    	while(1)
    	{
    		printf("落子方:%c\n",nowType);
    		printf("落子位置(x,y)=");
    		scanf("%d %d",i,j);
    		if(*i<0||*i>=row||*j<0||*j>=col||map[*i][*j]!=m)
    		{
    			printf("输入不合法!\n");	
    		}	
    		else 
    		{
    			return;
    		}	
    	}
    } 
    
    //交替下子
    void exchangeTurn()
    {
    	if(nowType==o)
    	{
    		nowType=x;
    	}
    	else
    	{
    		nowType=o;
    	}
    } 
    
    //下子
    void setPiece(char map[][col],int i,int j)
    {
    	map[i][j]=nowType;
    	count++;
    } 
    
    //判断是否分出胜负,分别从横竖斜三个方向数数 
    int isWin(char map[][col])
    {
    	int i,j;
    	int flagR,flagC;
    	for(i=0;i<row;i++)
    	{
    		flagR=0,flagC=0;
    		for(j=0;j<col;j++)
    		{
    			if(map[i][j]==o)
    			{
    				flagR++;	
    			}		
    			else if(map[i][j]==x)
    			{
    				flagR--;
    			}
    			if(map[j][i]==o)
    			{
    				flagC++;
    			}
    			else if(map[j][i]==x)
    			{
    				flagC--;
    			}
    		}	
    		if(flagR==col||flagC==col||flagR==(-col)||flagC==(-col))
    		{
    			return 1;
    		}
    	}	
    	flagR=0,flagC=0;
    	for(i=0,j=0;i<row&&j<col;i++,j++)
    	{
    		if(map[i][j]==o)
    		{
    			flagR++;
    		}
    		else if(map[i][j]==x)
    		{
    			flagR--;
    		}
    		if(map[i][col-j-1]==o)
    		{
    			flagC++;
    		}
    		else if(map[i][col-j-1]==x)
    		{
    			flagC--;
    		}
    	}
    	if(flagR==col||flagC==col||flagR==(-col)||flagC==(-col))
    	{
    		return 1;
    	}
    	else 
    	{
    		return 0;
    	}
    } 
    
    //输出胜方
    void displayWinner()
    {
    	printf("%c方获得胜利!\n",nowType);	
    } 
    
    //给局面打分的基础表(站位分) 
    int score[3][3]={
    	{4,2,4},
    	{2,8,2},
    	{4,2,4}
    };
    //引入自定义头文件 
    #include"person.h"
    #include"computer.h"
     
    int main()
    {
    	int gameType;
    	printf("1.人机对战\n其他.玩家对战\n");
    	scanf("%d",&gameType);
    	if(gameType==1)
    	{
    		computer();
    	}
    	else
    	{
    		person();
    	} 
    	return 0;
    }
    
    
    

    代码解析

    1、 其实棋类游戏设计最重要的就是模拟下棋的过程。
    2、 我们知道井字棋是双方交替下子,一方执O,一方执X。
    3、 比如O先下,玩家下完子后,我们判断一下此时他是否已经获胜(即是否出现横或竖或两斜线出现三子连珠的情况),没有获胜则判断是否已经将棋局下满子了,还是没有的话,轮到X的回合。再次执行此步骤。
    4、 了解了过程就自然好设计了。因为棋局比较简单,我们用一个二维字符数组即可存储。落子位置用坐标(x,y),通过玩家输入即可进行模拟。

    展开全文
  • C语言简单游戏编程入门之四子棋

    千次阅读 2019-12-27 04:00:03
    运行截图 源代码 #include<stdio.h> #include<stdlib.h> /* 四子棋 1.在一个6行7列的棋盘中 2.玩家1和玩家2依次交替下子 3.每次下子落于棋盘可能达到的最下方 4.... 5....#define COL 8...

    运行截图

    在这里插入图片描述

    源代码

    #include<stdio.h>
    #include<stdlib.h>
    /*
    	四子棋
    	1.在一个6行7列的棋盘中
    	2.玩家1和玩家2依次交替下子
    	3.每次下子落于棋盘可能达到的最下方
    	4.先四子相连为胜
    	5.棋盘已满且无四子相连为平局 
    */
    
    /*定义常量*/
    //行数 
    #define ROW 7
    //列数 
    #define COL 8
    //玩家1的棋子
    #define O 1
    //玩家2的棋子
    #define X 2
    //空白
    #define WHITE 0 
    //胜利需要的连字数
    #define COUNT 4 
    
    /*定义全局变量*/ 
    int map[ROW][COL]={0};
    
    //打印地图  
    void PrintMap(int map[][COL],int row,int col);
    //下子
    int PlayChess(int map[][COL],int col,int piece); 
    //是否已经赢了
    int IsWin(int map[][COL],int row,int col,int piece); 
    
    int main()
    { 
    	int piece=O;
    	int row;
    	int col;
    	int Winner=0;
    	int count_piece=0;
    	
    	while(1)
    	{
    		/*清屏*/
    		system("cls");
    		
    		PrintMap(map,ROW-1,COL-1);
    		if(Winner!=0||count_piece==(ROW-1)*(COL-1))
    		{
    			break;
    		}
    		printf("现在%d号玩家下子\n",piece);
    		printf("落子位置(1~%d):",COL-1);
    		scanf("%d",&col);
    		if(col<1||col>=COL)
    		{
    			printf("下子位置无效!\n");
    			continue;
    		}
    		row=PlayChess(map,col,piece);
    		if(row==0)
    		{
    			printf("该列已经满了!\n");
    		}
    		else
    		{
    			count_piece++;
    			Winner=IsWin(map,row,col,piece);
    			if(Winner!=0)
    			{
    				
    			}
    			else
    			{
    				if(piece==O)
    				{
    					piece=X;
    				}
    				else if(piece==X)
    				{
    					piece=O;
    				}
    			}
    		}
    	}
    	if(Winner!=0)
    	{
    		printf("%d号玩家获胜!\n",Winner);
    	}
    	else
    	{
    		printf("平局!\n");
    	}
    	return 0;
    }
    
    //打印地图  
    void PrintMap(int map[][COL],int row,int col)
    {
    	/*
    	int i=1;
    	while(i<=row)
    	{
    		int j=1;
    		while(j<=col)
    		{
    			if(map[i][j]==O)
    			{
    				printf("O");
    			}
    			else if(map[i][j]==X)
    			{
    				printf("X");
    			}
    			else if(map[i][j]==WHITE)
    			{
    				printf(" ");
    			}
    			j++;	
    		}	
    		printf("\n");
    		i++;
    	} 
    	*/
    	int number=1;
    	while(number<=2*COL-2)
    	{
    		if(number%2==0)
    		{
    			printf("%d",number/2);
    		}
    		else
    		{
    			printf(" ");
    		}
    		number++;
    	}
    	printf("\n");
    	
    	int i=1;
    	while(i<=2*ROW-1)
    	{
    		int j=1;
    		while(j<=2*COL-1)
    		{
    			if(i%2==1)
    			{
    				printf("-");
    			}
    			else if(j%2==1)
    			{
    				printf(" ");
    			}
    			else
    			{
    				int h=i/2;
    				int z=j/2;
    				if(map[h][z]==O)
    				{
    					printf("O");
    				}
    				else if(map[h][z]==X)
    				{
    					printf("X");
    				}
    				else
    				{
    					printf(" ");
    				}
    			}
    			j++;
    		}
    		printf("\n");
    		i++;
    	} 
    } 
    
    //下子
    int PlayChess(int map[][COL],int col,int piece)
    {
    	int i=ROW-1;
    	while(i>=1)
    	{
    		if(map[i][col]==WHITE)
    		{
    			map[i][col]=piece;
    			return i;
    		}
    		i--;
    	}
    	return 0;
    }
    
    //是否已经赢了
    int IsWin(int map[][COL],int row,int col,int piece)
    {
    	int countH=1,countS=1,countP=1,countN=1;
    	int i;
    	
    	/*计算countH*/
    	/*左边*/
    	i=col-1;
    	while(i>=1)
    	{
    		if(map[row][i]==piece)
    		{
    			countH++;
    		}
    		else
    		{
    			break;
    		}
    		i--;
    	}
    	/*右边*/
    	i=col+1;
    	while(i<=COL-1)
    	{
    		if(map[row][i]==piece)
    		{
    			countH++;
    		}
    		else
    		{
    			break;
    		}
    		i++;
    	}
    	
    	/*计算countS*/
    	/*上边*/
    	i=row-1;
    	while(i>=1)
    	{
    		if(map[i][col]==piece)
    		{
    			countS++;	
    		}	
    		else
    		{
    			break;
    		}
    		i--;
    	} 
    	/*下边*/
    	i=row+1;
    	while(i<=ROW-1)
    	{
    		if(map[i][col]==piece)
    		{
    			countS++;	
    		}	
    		else
    		{
    			break;
    		}
    		i++;
    	}
    	
    	int j;
    	/*计算countN*/
    	/*左上*/
    	i=row-1;
    	j=col-1;
    	while(i>=1&&j>=1)
    	{
    		if(map[i][j]==piece)
    		{
    			countN++;
    		}
    		else
    		{
    			break;
    		}
    		i--;
    		j--;
    	}
    	/*右下*/
    	i=row+1;
    	j=col+1;
    	while(i<=ROW-1&&j<=COL-1)
    	{
    		if(map[i][j]==piece)
    		{
    			countN++;
    		}
    		else
    		{
    			break;
    		}
    		i++;
    		j++;
    	}
    	
    	/*计算countP*/
    	/*右上*/
    	i=row-1;
    	j=col+1;
    	while(i>=1&&j<=COL-1)
    	{
    		if(map[i][j]==piece)
    		{
    			countP++;
    		}
    		else
    		{
    			break;
    		}
    		i--;
    		j++;
    	}
    	/*左下*/
    	i=row+1;
    	j=col-1;
    	while(i<=ROW-1&&j>=1)
    	{
    		if(map[i][j]==piece)
    		{
    			countP++;
    		}
    		else
    		{
    			break;
    		}
    		i++;
    		j--;
    	}
    	
    	if(countH>=COUNT||countS>=COUNT||countP>=COUNT||countN>=COUNT)
    	{
    		return piece;
    	}
    	else 
    	{
    		return 0;
    	}
    }
    

    实现思路

    整形二维数组存储棋盘
    其余的比较简单,在源码中描述的比较仔细,在此不多赘述。

    展开全文
  • 1、猜数字游戏: /*猜数字游戏GuessGame.C*/ #include #include void main(void) { int answer[4] = {1,3,5,2}; int i,j,guess,times = 0; int a,b; printf("Please guess game!\n"); while(a!=4) {

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 409
精华内容 163
关键字:

c语言游戏编程入门

c语言 订阅