C语言制作五子棋.doc

C语言制作五子棋
五子棋游戏是一个深受人们喜爱的游戏，通常是人机对弈，本程序设计为人与人对弈，一方执黑棋，一方执白棋，轮流走棋，每方都试图在游戏结束前让自己的棋子五子相连。按键盘上的方向键可以移动光标，回车键可以摆放棋子。
一、 设计目的
这个程序是对编程基本功的一个训练，将分支、循环、数组、函数综合应用，而不仅限于编制独立的小程序，通过游戏过程增加编程的兴趣，提高编程水平。编制该程序我对以下的知识点进行的巩固和掌握：1.数组元素为结构体的数组应用。2.全局变量应用。3.按键的处理。4.数组元素与蛇、食物的对应关系。5.图形方式等等。虽然该程序是一个普通而又简单的程序，但是对于一C语言初级阶段的学生来说，是一个很好的锻炼甚至可以说是一个很好的提高。
二、 设计思路
棋盘设计为19×19格，初始状态光标在棋盘的中央，白棋先走，轮流落子，当一方连成五子或下满棋盘时，游戏结束（连成五子的一方获胜，下满棋盘为和棋）。当游戏一方胜利后显示胜利信息，提示信息利用汉字点阵输出。
从程序表面看，这是一个二维平面图，所以数据用二维数组来表示，数组两个下标可以表示棋盘上的位置，数组元素的值代表棋格上的状态，共有三种情况，分别是0代表空格，1代表白棋，2代表黑棋。这样程序的主要工作是接收棋手按键操作，棋手1用Up、Down、Left、Right控制光标移动，回车键表示落子。棋手2用W、S、A、D控制光标移动，空格键表示落子。一旦接收到回车键或空格键，说明棋手落子，先判断是否是有效位置，也就是说已经有棋子的位置不能重叠落子。落子成功后，马上判断以该位置为中心的八个方向：上、下、左、右、左上、左下、右上、右下是否有相同颜色的棋子连成五子，如果连成五子，则游戏结束，输出相应的信息。如果想退出游戏，可以按Esc键。
三、程序设计
1．定义全局变量
1. int gamespeed=5000;  
2. int i,j,key;  
3. struct Sor  
4. {  
5.      int x;  
6.      int y;/*x,y表示当前光标的位置*/ 
7.      int yes[N][N];/* 0表示无棋子，1表示白色棋子，2表示黑色棋子*/ 
8.      int kao;/* 1表示白棋准备落子，2表示黑棋落子*/ 
9.      int ok;/*1表示白棋胜出，2表示黑棋胜出*/ 
10. }sor; 
2．Main()主函数
按照语法规则，首先定义使用到的常数、全局变量、函数原型说明。棋盘状态用数组yes[20][20],初值为0，表示空格。函数的实体比较简单，调用图形驱动、画棋盘、人人对弈等自定义函数，一旦游戏结束后，关闭图形驱动，程序结束。
3．drawqp()画棋盘函数
背景颜色设为黑色，从坐标(100，100)开始每隔20个单位用绿色画一条水平直线，一条垂直线，构成棋盘，用循环语句实现。画线函数line()的参数为线的起点和终点坐标，注意要计算正确。函数setfillstyle()可以设置填充模式和填充颜色，fillellipse(int x,int xradius,int yradius)以x和y为圆心，xradius和yradius为水平和垂直轴画一填充椭圆，当xradius和yradius相等时，则画出的是圆，用它表示棋子。
4．win()判断是否胜出函数
本函数根据每次落子的位置，分别向上、下、左、右、左上、左下、右上、右下八个方向判断是否有相同颜色的棋子连成五子，如果成立，游戏就结束，并显示提示信息(如:红方获胜)，否则继续落子。
5．Gameplay()双人对战函数
这是游戏进行的函数，主要是接收棋手的按键消息，其处理过程如下：
(1) 按Esc键程序可以随时结束。
(2) 按上下左右光标键，则改变棋子移动的坐标值。
(3) 按回车键后判断:
1) 如落子的位置已经有棋则无效，继续按键。
2) 如落子位置是空格，可以将棋子落入格内，调用win()函数。
3) 如果棋子变化后，棋盘已下满了棋子，则游戏结束。显示平局信息。
(4) 重复上述步骤，直到游戏结束。
6．Xandy()显示光标纵横坐标函数
该函数的作用是在每次移动光标后，在屏幕左下角显示出光标的纵横坐标。
7．图形功能函数
以下函数原形都在graphics.h中。
(1)registerbgidriver():
(2)initgraph(int *driver, int *mode, char *path):用于初始化图形系统，并装入相应的图形驱动器。该函数把由driver所指向的图形驱动器代码装入内存。如果图形驱动器未装入内存，图形函数将不能操作。图形函数所用的屏显模式由mode所指向的整数值确定。最后，图形驱动器的路径是由path所指向的字符串给出。如果没有指定路径，就在当前工作路径上寻找。
(3)rectangle(int left,int top,int right,int bottom):函数rectangle()用当前画出由坐标left,top及right,bottom所定义的矩形。
(4)setcolor(int color):把当前画线颜色设置为color所指定的颜色。每个图形显示卡的有效颜色由setpalette()提供。
(5)closegraph():该函数使图形状态失效，并且释放用于保存图形驱动器和字体的系统内存。当你的程序既用到图形输出又用到非图形输出时，应该用此函数。该函数还把系统屏显模式返回到调用initgragh()前的状态。
通过编制该程序我对以下的知识点进行的巩固和掌握：1.数组元素为结构体的数组应用。2.全局变量应用。3.按键的处理。4.图形方式等等。虽然该程序是一个普通而又简单的程序，但是对于一C语言初级阶段的学生来说，是一个很好的锻炼甚至可以说是一个很好的提高。由于个人能力的限制该程序还有许多的缺陷，若要进一步的完善还需要对C语言更深一步的学习。
程序运行部分截图：

1. #include<graphics.h>  
2. #define N 20  
3. /*定义键盘*/ 
4. #define up 0x4800  
5. #define down 0x5000  
6. #define left 0x4b00  
7. #define right 0x4d00  
8. #define esc 0x011b  
9. #define enter 0x1c0d  
10. #define A 0x1e61  
11. #define S 0x1f73  
12. #define D 0x2064  
13. #define W 0x1177  
14. #define space 0x3920  
15. #define Y 0x1579  
16. #define n 0x316e  
17. int gamespeed=5000;  
18. int i,j,key;  
19. struct Sor  
20. {  
21.      int x;  
22.      int y;/*x,y表示当前光标的位置*/ 
23.      int yes[N][N];/* 0表示无棋子，1表示白色棋子，2表示黑色棋子*/ 
24.      int kao;/* 1表示白棋准备落子，2表示黑棋落子*/ 
25.      int ok;/*1表示白棋胜出，2表示黑棋胜出*/ 
26. }sor;  
27.  
28. void init(void)       /*graph drive*/ 
29. {  
30.      int driver=DETECT,mode=0;  
31.      registerbgidriver(EGAVGA_driver);  
32.      initgraph(&driver,&mode,"");  
33. }  
34.  
35. void drawmat(char *mat,int matsize,int x,int y,int color)  
36. {  
37.      int i,j,k,m;  
38.      m=(matsize-1)/8+1;  
39.      for(j=0;j<matsize;j++)  
40.      for(i=0;i<m;i++)  
41.           for(k=0;k<8;k++)  
42.                if(mat[j*m+i]&(0x80>>k))  
43.                     putpixel(x+i*8+k,y+j,color);  
44. }  
45.  
46. void show(void)/*input word*/ 
47. {  
48.      drawmat(wu64H,64,438,49,0);  
49.      drawmat(zi64H,64,488,49,0);  
50.      drawmat(qi64H,64,538,49,0);  
51.  
52.      drawmat(wu64H,64,440,50,13);  
53.      drawmat(zi64H,64,490,50,13);  
54.      drawmat(qi64H,64,540,50,13);  
55.  
56.      drawmat(zuo16H,16,480,450,8);  
57.      drawmat(zhe16H,16,498,450,8);  
58.      drawmat(tian16H,16,518,450,8);  
59.      drawmat(xue16H,16,536,450,8);  
60.      drawmat(ke16H,16,554,450,8);  
61. }  
62.  
63. void drawqp(void)/*draw qi pan*/ 
64. {  
65.      setcolor(3);  
66.      for(i=50;i<=(N-1)*20+30;i+=20)  
67.      {  
68.           line(50,i,(N-1)*20+30,i);  
69.           line(i,50,i,(N-1)*20+30);  
70.      }  
71.      setcolor(11);  
72.      for(i=1;i<3;i++)  
73.      {  
74.           circle((N-1)*10+40,(N-1)*10+40,i);  
75.           circle(130,130,i);  
76.           circle(130,330,i);  
77.           circle(330,130,i);  
78.           circle(330,330,i);  
79.      }  
80. }  
81.  
82. void clew(void)  /*input message*/ 
83. {  
84.      setcolor(15);  
85.      settextstyle(0,0,1);  
86.      outtextxy(50,20,"1P: Up Down Left Right Enter       2P: W S A D Space");  
87. }  
88.  
89. void place(void)/*画出光标的位置*/ 
90. {  
91.      line(sor.x-10,sor.y-10,sor.x-7,sor.y-10);  
92.      line(sor.x-10,sor.y-10,sor.x-10,sor.y-7);  
93.  
94.      line(sor.x-10,sor.y+10,sor.x-10,sor.y+7);  
95.      line(sor.x-10,sor.y+10,sor.x-7,sor.y+10);  
96.  
97.      line(sor.x+10,sor.y-10,sor.x+10,sor.y-7);  
98.      line(sor.x+10,sor.y-10,sor.x+7,sor.y-10);  
99.  
100.      line(sor.x+10,sor.y+10,sor.x+7,sor.y+10);  
101.      line(sor.x+10,sor.y+10,sor.x+10,sor.y+7);  
102.  
103.  }  
104.  
105. void win(void)/*判断是否胜出*/ 
106. {  
107.      for(i=1;i<N;i++)  
108.      {  
109.           for(j=1;j<N;j++)  
110.           {  
111.                if(((j+4)<N&&sor.yes[i][j]!=0&&  
112.                     sor.yes[i][j]==sor.yes[i][j+1]&&  
113.                     sor.yes[i][j+1]==sor.yes[i][j+2]&&  
114.                     sor.yes[i][j+2]==sor.yes[i][j+3]&&  
115.                     sor.yes[i][j+3]==sor.yes[i][j+4])||  
116.  
117.                     ((i+4)<N&&sor.yes[i][j]!=0&&  
118.                     sor.yes[i][j]==sor.yes[i+1][j]&&  
119.                     sor.yes[i+1][j]==sor.yes[i+2][j]&&  
120.                     sor.yes[i+2][j]==sor.yes[i+3][j]&&  
121.                     sor.yes[i+3][j]==sor.yes[i+4][j])||  
122.  
123.                     ((i+4)<N&&(j+4)<N&&sor.yes[i][j]!=0&&  
124.                     sor.yes[i][j]==sor.yes[i+1][j+1]&&  
125.                     sor.yes[i+1][j+1]==sor.yes[i+2][j+2]&&  
126.                     sor.yes[i+2][j+2]==sor.yes[i+3][j+3]&&  
127.                     sor.yes[i+3][j+3]==sor.yes[i+4][j+4])||  
128.  
129.                     ((i+4)<N&&j>4&&sor.yes[i][j]!=0&&  
130.                     sor.yes[i][j]==sor.yes[i+1][j-1]&&  
131.                     sor.yes[i+1][j-1]==sor.yes[i+2][j-2]&&  
132.                     sor.yes[i+2][j-2]==sor.yes[i+3][j-3]&&  
133.                     sor.yes[i+3][j-3]==sor.yes[i+4][j-4]))  
134.                {  
135.                     if(sor.yes[i][j]==1)  
136.                          sor.ok=1;  
137.                     else 
138.                          sor.ok=2;  
139.                          break;  
140.                }  
141.           }  
142.           if(sor.ok!=0)  
143.                break;  
144.      }  
145. }  
146.  
147. void gameover(void)  
148. {  
149.      if(sor.ok==1)  
150.      {  
151.           drawmat(bai64H,64,488,119,0);  
152.           drawmat(bai64H,64,490,120,4);  
153.      }  
154.      else 
155.      {  
156.           drawmat(hong64H,64,488,119,0);  
157.           drawmat(hong64H,64,490,120,4);  
158.      }  
159.  
160.      drawmat(fang64H,64,488,189,0);  
161.      drawmat(huo64H,64,488,259,0);  
162.      drawmat(sheng64H,64,488,329,0);  
163.  
164.      drawmat(fang64H,64,490,190,4);  
165.      drawmat(huo64H,64,490,260,4);  
166.      drawmat(sheng64H,64,490,330,4);  
167. }  
168.  
169. void xandy(void)/*显示光标的横纵坐标*/ 
170. {  
171.      char str1[10],str2[10];  
172.      setfillstyle(SOLID_FILL,7);  
173.      bar(50,440,205,470);  
174.      setcolor(14);  
175.      settextstyle(0,0,2);  
176.      sprintf(str1,"X:%d",(sor.x-30)/20);  
177.      sprintf(str2,"Y:%d",(sor.y-30)/20);  
178.      outtextxy(60,450,str1);  
179.      outtextxy(135,450,str2);  
180. }  
181.  
182. void gameplay(void)  
183. {  
184.      for(i=1;i<N;i++)/*棋盘初始化*/ 
185.           for(j=1;j<N;j++)  
186.                sor.yes[i][j]=0;  
187.      sor.kao=1; /*白棋先走*/ 
188.      sor.ok=0;/*双方胜负未分*/ 
189.      sor.x=(N-1)*10+40;  
190.      sor.y=(N-1)*10+40;/*初始化光标,将光标定位在棋盘的中心*/ 
191.      setcolor(15);  
192.      place();  
193.  
194.      while(1)  
195.      {  
196.           xandy();  
197.           key=bioskey(0);  
198.           if(key==esc)  
199.                break;  
200.  
201.           /*白棋键盘移动*/ 
202.           else if(key==up&&sor.y>50&&sor.kao==1)  
203.           {  
204.                setcolor(0);place();  
205.                sor.y-=20;  
206.           }  
207.           else if(key==down&&sor.y<(N-1)*20+30&&sor.kao==1)  
208.           {  
209.                setcolor(0);place();  
210.                sor.y+=20;  
211.           }  
212.           else if(key==left&&sor.x>50&&sor.kao==1)  
213.           {  
214.                setcolor(0);place();  
215.                sor.x-=20;  
216.           }  
217.           else if(key==right&&sor.x<(N-1)*20+30&&sor.kao==1)  
218.           {  
219.                setcolor(0);place();  
220.                sor.x+=20;  
221.           }  
222.  
223.           /*红方键盘移动*/ 
224.           else if(key==W&&sor.y>50&&sor.kao==2)  
225.           {  
226.                setcolor(0);place();  
227.                sor.y-=20;  
228.           }  
229.           else if(key==S&&sor.y<(N-1)*20+30&&sor.kao==2)  
230.           {  
231.                setcolor(0);place();  
232.                sor.y+=20;  
233.           }  
234.           else if(key==A&&sor.x>50&&sor.kao==2)  
235.           {  
236.                setcolor(0);place();  
237.                sor.x-=20;  
238.           }  
239.           else if(key==D&&sor.x<(N-1)*20+30&&sor.kao==2)  
240.           {  
241.                setcolor(0);place();  
242.                sor.x+=20;  
243.           }  
244.           else if(key==space&&sor.yes[(sor.x-30)/20][(sor.y-30)/20]==0&&sor.kao==2)  
245.           {  
246.                setcolor(13);  
247.                for(i=1;i<=9;i++)  
248.                {  
249.                     circle(sor.x,sor.y,i);  
250.                     delay(10000);  
251.                }  
252.                sor.yes[(sor.x-30)/20][(sor.y-30)/20]=2;  
253.                sor.kao=1;  
254.                win();  
255.                if(sor.ok!=0)  
256.                {  
257.                     gameover();  
258.                     break;  
259.                }  
260.           }  
261.           else if(key==enter&&sor.yes[(sor.x-30)/20][(sor.y-30)/20]==0&&sor.kao==1)  
262.           {  
263.                setcolor(15);  
264.                for(i=1;i<=9;i++)  
265.                {  
266.                     circle(sor.x,sor.y,i);  
267.                     delay(10000);  
268.                }  
269.                sor.yes[(sor.x-30)/20][(sor.y-30)/20]=1;  
270.  &

贪食蛇（1）
1. /* * * * * * * * * * * * * * * * *  
2. // Project: RedSnake(贪吃蛇)  
3. // Author:  RedOC  
4. // Email:   RedOC@  
5. // Date:    2009.06.27 23.42.02  
6. * * * * * * * * * * * * * * * * */ 
7.  
8. #include <stdio.h>  
9. #include <stdlib.h>  
10. #include <time.h>  
11. #include "pcc32.h"  
12.  
13. // 定义地图的尺寸及坐标(均使用双字符长度)  
14. #define MAP_WIDTH    24  
15. #define MAP_HEIGHT   16  
16. #define MAP_BASE_X   1  
17. #define MAP_BASE_Y   1  
18.  
19. // 定义蛇的相关参数  
20. #define SNAKE_MIN_LEN   5  
21.  
22. // 定义地图块的状态,分别为[空格|蛇头|蛇身|食物]  
23. #define BS_SPACE     0  
24. #define BS_SHEAD     1  
25. #define BS_SBODY     2  
26. #define BS_STAIL     3  
27. #define BS_FOOD      4  
28.  
29. // 定义各对象的颜色,颜色定义详见[pcc32.h],顺序同上.  
30. PCCOLOR myColors[] = {ORANGE, RED_ORANGE, RED, LIGHT_GREEN, YELLOW};  
31.  
32. // 定义各对象的形状,注意是宽字符[◆◇□●★¤~◎＋],顺序同上.  
33. char mySharps[][3] = {"□", "◆", "■", "＋", "★"};  
34.  
35. // 定义蛇的运动方向[上|下|左|右]  
36. #define DIR_UP    1  
37. #define DIR_DOWN  2  
38. #define DIR_LEFT  3  
39. #define DIR_RIGHT 4  
40.  
41. typedef struct _SnakeBody  
42. {  
43.    uint8 x, y;  
44. }POINT2D, *PPOINT2D;  
45.  
46. POINT2D mySnake[MAP_WIDTH*MAP_HEIGHT] = {{0}};  
47. POINT2D myFood = {0};  
48. int snakeLength = 0;  
49. int snakeDir = DIR_RIGHT;  
50. int isFood = 0;  
51. int isOver = 0;  
52.  
53. void drawMap(void);  
54. void initSnake(int len);  
55. void drawSnake(void);  
56. void moveSnake(void);  
57. void drawBlock(int x, int y, int bs);  
58. int isInSnake(int x, int y);  
59. void drawFood(void);  
60.  
61. int main()  
62. {  
63.    int isPause = 1;  
64.    fixConsoleSize((MAP_WIDTH + 2) * 2, MAP_HEIGHT + 2);  
65.    setCursorVisible(0);  
66.    setConsoleTitle("Snake by RedOC. 2009.06.27");  
67.    initSnake(SNAKE_MIN_LEN);  
68.    drawMap();  
69.    drawSnake();  
70.    while (!isOver)  
71.    {  
72.       if (!isPause)  
73.       {  
74.          moveSnake();  
75.          if (!isFood)  
76.             drawFood();  
77.       }  
78.       delayMS(200 - snakeLength*2);  
79.       if (jkHasKey())  
80.       {  
81.          switch (jkGetKey())  
82.          {  
83.             case JK_UP:  
84.                if (snakeDir != DIR_DOWN)  
85.                   snakeDir = DIR_UP;  
86.                break;  
87.             case JK_DOWN:  
88.                if (snakeDir != DIR_UP)  
89.                   snakeDir = DIR_DOWN;  
90.                break;  
91.             case JK_LEFT:  
92.                if (snakeDir != DIR_RIGHT)  
93.                   snakeDir = DIR_LEFT;  
94.                break;  
95.             case JK_RIGHT:  
96.                if (snakeDir != DIR_LEFT)  
97.                   snakeDir = DIR_RIGHT;  
98.                break;  
99.             case JK_ESC:  
100.             case JK_ENTER:  
101.             case JK_SPACE:  
102.                isPause = !isPause;  
103.                break;  
104.             default:  
105.                break;  
106.          }  
107.       }  
108.    }  
109.    gotoTextPos(MAP_BASE_X + MAP_WIDTH / 2 + 2, MAP_BASE_Y + MAP_HEIGHT / 2);  
110.    printf("Game Over! Score: %d.", snakeLength - SNAKE_MIN_LEN);  
111.    getch();  
112.    return 0;  
113. }  
114.  
115. void drawMap(void)  
116. {  
117.    int i, j;  
118.    setTextColor(myColors[BS_SPACE]);  
119.    for (i = 0; i < MAP_HEIGHT; i++)  
120.