根据《算法谜题》一书中的捉鸡一题，改编成游戏并使用C语言编程实现，如下：
农场主捉鸡游戏玩法介绍： # # # # # # # #
# # # # # C # #
# # # # # # # #
# # # # # # # #
# # # # # # # #
# # # # # # # #
# # # # # # # #
F # # # # # # #
1）场地是8X8的，农场主初始位置在最左下角（F），鸡的位置在场地上的位置随机分配（C）
2）游戏开始后，玩家选择农场主先走还是鸡先走，玩家代表农场主去捉鸡，鸡自动移动；农场主和鸡交替走，农场主和鸡都可以移动到上下左右方向上邻近的一步，不能走对角，当农场主移动到鸡所在的位置，或者鸡自投罗网跑到农场主的位置时，农场主赢，游戏结束
3）如果选择正确的话（即选择农场主先走还是鸡先走），农场主最多14步可捉到鸡，如果14步还捉不到，宣布游戏失败！
4）W、S、A、D控制农场主（F）的上、下、左、右移动
辛苦了半天，终于把游戏完成，自己试玩了一下，还可以。本游戏如果选择错误（即鸡先走或人先走），游戏很可能会失败的哦，请大家讨论如何选择鸡先走还是人先走能百分之百捉住鸡？
代码：

1. #include <stdio.h>
   
2. #include <time.h>
   
3. #include <stdlib.h>
   
4. 
   
5. //定义变量
   
6. int count = 14;//倒计时，14步，14步贷不到鸡游戏失败
   
7. int famerX,famerY,//记录农场主的位置
   
8.     cockX,cockY;//记录公鸡的位置
   
9. char fORc;//记录谁先走,'F'农场主先走，‘C’公鸡先走
   
10. /**
    
11. *  打印地图功能
    
12. *
    
13. *  @param map 地图数组
    
14. */
    
15. void printMap(char map[8][8]){
    
16.     for (int i=0; i<8; i++) {
    
17.         for (int j = 0; j<8; j++) {
    
18.             printf(" %c",map[i][j]);
    
19.         }
    
20.         printf("\n");
    
21.     }
    
22.     printf("\n");
    
23. 
    
24. }
    
25. 
    
26. /**
    
27. 初始化地图
    
28. 
    
29. */
    
30. void initMap(char map[8][8]){
    
31.     //1）使用#填充地图
    
32.     for (int i=0; i<8; i++) {
    
33.         for (int j = 0; j<8; j++) {
    
34.             map[i][j] = '#';
    
35.         }
    
36.     }
    
37.    
    
38.     //2）初始化农场主位置左下角（7，0）
    
39.     famerX = 7,famerY = 0;
    
40.     //放入农场主
    
41.     map[famerX][famerY] = 'F';
    
42.    
    
43.     //3）随机初始化鸡的位置，鸡的位置不能和农场主的位置重合
    
44.     srand((unsigned)time(NULL));//用时间做种，每次产生随机数不一样
    
45.     //产生随机数
    
46.     cockX = rand()%8;
    
47.     cockY = rand()%8;
    
48.     while (cockX == famerX && cockY == famerY) {
    
49.         //如果公鸡和农场主的位置重合则重新分配公鸡的位置
    
50.         cockX = rand()%8;
    
51.         cockY = rand()%8;
    
52.     }
    
53.     map[cockX][cockY] = 'C';
    
54. 
    
55. }
    
56. 
    
57. 
    
58. int fEc(){
    
59.     if (famerX == cockX && famerY == cockY) {
    
60.         return 1;
    
61.     }
    
62.     return 0;
    
63. }
    
64. /**
    
65. *  移动函数
    
66. *
    
67. *  @param map       盘面数组
    
68. *  @param direction 移动方向
    
69. *  @param x         当前X坐标
    
70. *  @param y         当前Y坐标
    
71. */
    
72. void Move(char map[8][8],char direction,int *x,int *y)
    
73. {
    
74.     char temp;
    
75.     switch (direction) {
    
76.         case 'a':
    
77.         case 'A':
    
78.             //向左移动一格，y值减一
    
79.             if (*y>0) {
    
80.                 temp = map[*x][*y];
    
81.                 map[*x][*y] = map[*x][*y-1];
    
82.                 map[*x][*y-1] = temp;
    
83.                 (*y)--;
    
84.                 if (fEc()) {
    
85.                     map[*x][*y] = 'X';
    
86.                     map[*x][*y+1] = '#';
    
87.                 }
    
88.                
    
89.             }
    
90.             
    
91.             break;
    
92.         case 'd':
    
93.         case 'D':
    
94.             //向右移动一格，y值加一
    
95.             if (*y<7) {
    
96.                 temp = map[*x][*y];
    
97.                 map[*x][*y] = map[*x][*y+1];
    
98.                 map[*x][*y+1] = temp;
    
99.                 (*y)++;
    
100.                 if (fEc()) {
     
101.                     map[*x][*y] = 'X';
     
102.                     map[*x][*y-1] = '#';
     
103.                 }
     
104.             }
     
105.             break;
     
106.             
     
107.         case 'w':
     
108.         case 'W':
     
109.             //向上移动一格，x值减一
     
110.             if (*x>0) {
     
111.                 temp = map[*x][*y];
     
112.                 map[*x][*y] = map[*x-1][*y];
     
113.                 map[*x-1][*y] = temp;
     
114.                 (*x)--;
     
115.                 if (fEc()) {
     
116.                     map[*x][*y] = 'X';
     
117.                     map[*x+1][*y] = '#';
     
118. 
     
119.                 }
     
120.             }
     
121.             break;
     
122.             
     
123.         case 's':
     
124.         case 'S':
     
125.             //向下移动一格，x值加一
     
126.             if (*x<7) {
     
127.                 temp = map[*x][*y];
     
128.                 map[*x][*y] = map[*x+1][*y];
     
129.                 map[*x+1][*y] = temp;
     
130.                 (*x)++;
     
131.                 if (fEc()) {
     
132.                     map[*x][*y] = 'X';
     
133.                     map[*x-1][*y] = '#';
     
134.                 }
     
135.             }
     
136.             break;
     
137.         default:
     
138.             break;
     
139.     }
     
140. }
     
141. 
     
142. 
     
143. /**
     
144. *  公鸡自动移动
     
145. *
     
146. *  @param map 地图
     
147. */
     
148. void cockMove(char map[8][8]){
     
149.     srand((unsigned)time(NULL));//用时间做种，每次产生随机数不一样
     
150.     //产生随机数
     
151.     int suiji = rand()%4;
     
152.    
     
153.         // printf("%d",suiji);
     
154.         switch (suiji) {
     
155.             case 0:
     
156.                 Move(map, 'w',&cockX,&cockY);
     
157.                 break;
     
158.             case 1:
     
159.                 Move(map, 's',&cockX,&cockY);
     
160.                 break;
     
161.             case 2:
     
162.                 Move(map, 'a',&cockX,&cockY);
     
163.                 break;
     
164.             case 3:
     
165.                 Move(map, 'd',&cockX,&cockY);
     
166.                 break;
     
167.                
     
168.             default:
     
169.                 break;
     
170.         }
     
171. }
     
172. /**
     
173. *  判断是否赢了，以及用户输入提醒
     
174. */
     
175. int isOK(char map[8][8]){
     
176.     if (fEc()) {//赢了
     
177.         printMap(map);
     
178.         printf("你走了%d步捉住了公鸡，你赢了！\n",14-count);
     
179.         return 1;
     
180.     }else{
     
181.         return 0;
     
182.     }
     
183.    
     
184. }
     
185. 
     
186. /**
     
187. *  农场主移动
     
188. *
     
189. *  @param map 地图
     
190. */
     
191. void famerMove(char map[8][8]){
     
192.     char move = getc(stdin);
     
193.     while (1) {
     
194.         
     
195.         if (move == 'w' || move == 'W' ||
     
196.             move == 's' || move == 'S' ||
     
197.             move == 'a' || move == 'A' ||
     
198.             move == 'd' || move == 'D' ) {
     
199.              Move(map, move, &famerX, &famerY);
     
200.             count --;
     
201.             
     
202.             break;
     
203.         }else{
     
204.             move = getc(stdin);
     
205.         }
     
206.     }
     
207.    
     
208.    
     
209. }
     
210. 
     
211. int main(int argc, const char * argv[]) {
     
212.    
     
213.    
     
214.     char map[8][8];//定义数组存放地图
     
215.     //初始化地图
     
216.     initMap(map);
     
217.     printMap(map);
     
218.     //打印控制游戏选择提示
     
219.     printf("请选择：‘F’代表农场主先走还是‘C’代表公鸡先走？\n");
     
220.     fORc=getc(stdin);
     
221.     while (1) {
     
222.         if (fORc == 'f' ||
     
223.             fORc == 'F' ||
     
224.             fORc == 'c' ||
     
225.             fORc == 'C') {
     
226.             if (fORc == 'f' || fORc == 'F') {
     
227.                 printf("你选择了农场主先走，游戏开始！\n");
     
228.                
     
229.             }else{
     
230.                 printf("你选择了公鸡先走，游戏开始！\n\n");
     
231.                
     
232.             }
     
233.             break;
     
234.             
     
235.         }else{
     
236.             printf("输入不合法，游戏推出，请重新运行！\n");
     
237.             return 0;
     
238.             
     
239.             
     
240.         }
     
241.     }
     
242.    
     
243. 
     
244.    
     
245.     //创建游戏循环
     
246.     while (1) {
     
247.       
     
248.         if (fORc =='C' || fORc == 'c') {
     
249.             //公鸡自动移动
     
250.             cockMove(map);
     
251.             if (isOK(map)) {
     
252.                 printf("公鸡自投罗网！\n");
     
253.                 return 0;
     
254.             }
     
255.             //打印地图
     
256.             printf("公鸡已走完：\n");
     
257.             printMap(map);
     
258.             fORc = 'f';
     
259.             //判断是否胜利
     
260.             //打印用户控制提示
     
261.             
     
262.         }else if(fORc == 'f'||fORc =='F'){
     
263.             printf("\n请移动农场主（F）：输入w（上）、s（下）、a（左）、d（右）后回车开始移动！你还剩%d步！\n",count);
     
264.             //用户移动
     
265.             famerMove(map);
     
266.             
     
267.             //判断是否胜利
     
268.             if (isOK(map)) {
     
269.                 return 0;
     
270.             }
     
271.             
     
272.             //打印地图
     
273.             printf("农场主已走完：\n");
     
274.             printMap(map);
     
275.             //当农场主走了14步还捉不到公鸡则推出游戏
     
276.             if (count == 0) {
     
277.                 printf("14步已用完，你还没捉住公鸡，太失败了！请重新开始吧\n");
     
278.                 return 0;
     
279.             }
     
280.             
     
281.             fORc = 'c';
     
282.             
     
283.         }
     
284.     }
     
285.     return 0;
     
286. }

复制代码

感觉好厉害

看着就好高端的样子 好好学习  

这个比小人推箱子复杂啊，小人可以控制箱子，但是这个游戏农场主不能控制小鸡，不过感觉不是很难