1. //
   
2. //  main.c
   
3. //  数字九宫格
   
4. //
   
5. //  Created by apple apple on 15/7/6.
   
6. //  Copyright (c) 2015年 shuangxing. All rights reserved.
   
7. //
   
8. /*游戏玩法介绍：
   
9. 1）#只能上下左右移动一步，移动到那个位置的数字与#交换位置
   
10.     1  #    3
    
11.     8  2    5
    
12.     4  7   6
    
13. 2）直到#移动到最右下角时，并且盘面行程如下次序，才算游戏胜利
    
14.     1        2        3
    
15.     4        5        6
    
16.     7        8        #
    
17. 3）胜利后把#替换成9，盘面再次打印
    
18.     1        2        3
    
19.     4        5        6
    
20.     7        8        9
    
21.     胜利！
    
22. 
    
23. 编程要求：
    
24. 1）盘面要按一定的逻辑打乱次序（因为随机打乱存在一定的完不成能游戏的概率）
    
25. 2）键盘控制#的移动，w/W:上移；s/S:下移；a/A:左移；d/D:右移。
    
26. 
    
27. 
    
28. 游戏界面：
    
29. 
    
30. 开始界面
    
31. 1.开始游戏
    
32. 2.退出游戏
    
33. 提示用户选择1开始游戏，2退出游戏
    
34. 
    
35. 玩游戏界面
    
36. 打印盘面
    
37. 提示移动规则
    
38. 
    
39. 胜利界面
    
40. 打印完整盘面
    
41. 提示胜利并结束游戏！
    
42. 
    
43. */
    
44. #include <stdio.h>
    
45. #include <time.h>
    
46. #include <stdlib.h>
    
47. //记录#的位置，初始位置为2，2
    
48. int x = 2,y = 2;
    
49. 
    
50. /**
    
51. *  打印盘面
    
52. *
    
53. *  @param map 盘面数组
    
54. */
    
55. void printMap(char map[3][3])
    
56. {
    
57.     for (int i=0; i<3; i++) {
    
58.         for (int j =0; j<3; j++) {
    
59.             printf("%c\t",map[i][j]);
    
60.         }
    
61.         printf("\n");
    
62.     }
    
63. }
    
64. /**
    
65. *  移动函数
    
66. *
    
67. *  @param map       盘面数组
    
68. *  @param direction 移动方向
    
69. */
    
70. void Move(char map[3][3],char direction)
    
71. {
    
72.     char temp;
    
73.     switch (direction) {
    
74.         case 'a':
    
75.         case 'A':
    
76.             //向左移动一格，y值减一
    
77.             if (y>0) {
    
78.                 temp = map[x][y];
    
79.                 map[x][y] = map[x][y-1];
    
80.                 map[x][y-1] = temp;
    
81.                 y--;
    
82.             }
    
83.             
    
84.             break;
    
85.         case 'd':
    
86.         case 'D':
    
87.             //向右移动一格，y值加一
    
88.             if (y<2) {
    
89.                 temp = map[x][y];
    
90.                 map[x][y] = map[x][y+1];
    
91.                 map[x][y+1] = temp;
    
92.                 y++;
    
93.             }
    
94.             break;
    
95. 
    
96.         case 'w':
    
97.         case 'W':
    
98.             //向上移动一格，x值减一
    
99.             if (x>0) {
    
100.                 temp = map[x][y];
     
101.                 map[x][y] = map[x-1][y];
     
102.                 map[x-1][y] = temp;
     
103.                 x--;
     
104.             }
     
105.             break;
     
106. 
     
107.         case 's':
     
108.         case 'S':
     
109.             //向下移动一格，x值加一
     
110.             if (x<2) {
     
111.                 temp = map[x][y];
     
112.                 map[x][y] = map[x+1][y];
     
113.                 map[x+1][y] = temp;
     
114.                 x++;
     
115.             }
     
116.             break;
     
117.         default:
     
118.             break;
     
119.     }
     
120. }
     
121. /**
     
122. *  按照一定的逻辑打乱盘面次序
     
123. *
     
124. *  @param map 盘面数组
     
125. */
     
126. void sortMap(char map[3][3])
     
127. {
     
128.     //1.令map[2][2]='#'
     
129.     map[2][2]='#';
     
130.     srand((unsigned)time(NULL));//用时间做种，每次产生随机数不一样
     
131.     //产生随机数
     
132.     int suiji = rand()%4;
     
133.     for (int i=0; i<100;i++ ) {
     
134.        // printf("%d",suiji);
     
135.         switch (suiji) {
     
136.             case 0:
     
137.                 Move(map, 'w');
     
138.                 break;
     
139.             case 1:
     
140.                 Move(map, 's');
     
141.                 break;
     
142.             case 2:
     
143.                 Move(map, 'a');
     
144.                 break;
     
145.             case 3:
     
146.                 Move(map, 'd');
     
147.                 break;
     
148.                
     
149.             default:
     
150.                 break;
     
151.         }
     
152.         suiji = rand()%4;
     
153.         
     
154.     }
     
155.    
     
156.    
     
157. }
     
158. /**
     
159. *  判断是否正确完成游戏
     
160. *
     
161. *  @param map 盘面数组
     
162. *
     
163. *  @return 成功返回1，不成功返回0
     
164. */
     
165. int isOK(char map[3][3])
     
166. {
     
167.     if (map[0][0] == '1' &&
     
168.         map[0][1] == '2' &&
     
169.         map[0][2] == '3' &&
     
170.         map[1][0] == '4' &&
     
171.         map[1][1] == '5' &&
     
172.         map[1][2] == '6' &&
     
173.         map[2][0] == '7' &&
     
174.         map[2][1] == '8' &&
     
175.         map[2][2] == '#' ) {
     
176.         return 1;
     
177.     }else return 0;
     
178. }
     
179. 
     
180. 
     
181. int main(int argc, const char * argv[]) {
     
182.     //初始化盘面数组
     
183.     char  map[3][3] = {'1','2','3','4','5','6','7','8','9'};
     
184.     //打印盘面
     
185.     printMap(map);
     
186.    
     
187. 
     
188. 
     
189.     //打印游戏开始界面
     
190.     printf("***1.开始游戏***\n");
     
191.     printf("***2.退出游戏***\n");
     
192.     printf("请输入1开始游戏，或者2退出游戏。\n");
     
193.     //建立界面选择逻辑
     
194.     char flag;
     
195.     flag = getc(stdin);
     
196.     if (flag =='1') {//开始游戏
     
197.         //打乱次序
     
198.         sortMap(map);
     
199.         //打印盘面
     
200.         printMap(map);
     
201.         //提示玩家控制游戏
     
202.         printf("请开始游戏，输入w“#”向上移动，输入s“#”向下移动，输入a“#”向左移动，输入d“#”向右移动。\n");
     
203.         //创建游戏循环
     
204.         while (1) {
     
205.             char ch = getc(stdin);
     
206.             if (ch == 'w' || ch == 'W'
     
207.                 || ch == 's' || ch == 'S'
     
208.                 || ch == 'a' || ch == 'A'
     
209.                 || ch == 'd' || ch == 'D' ) {
     
210.                 Move(map, ch);
     
211.                 printMap(map);
     
212.                 if (isOK(map)) {
     
213.                     map[2][2] = '9';
     
214.                     printf("\n\n");
     
215.                     printMap(map);
     
216.                     printf("胜利了！游戏结束！");
     
217.                     break;
     
218.                 }
     
219.             }
     
220.         }
     
221.     }else if(flag == '2')
     
222.     {
     
223.         printf("游戏已退出！\n");
     
224.         return 0;
     
225.     }else{
     
226.         printf("输入错误！游戏退出！请重新运行！\n");
     
227.     }
     
228.     return 0;
     
229. }
     

复制代码

写得不错！

好腻害啊～～

学习了,顶顶顶

没找模版自己写的话感觉挺nb了

dev-c跑不起来，第一个循环嵌套有问题

pacio 发表于 2015-7-7 17:54
dev-c跑不起来，第一个循环嵌套有问题

程序没问题，我的编译器没设置好，现在OK

慕名黑马生 发表于 2015-7-7 15:16
没找模版自己写的话感觉挺nb了

原创哦，看完基础视频中的迷宫游戏后自己就想了一个题目，自己练习的

厉害，膜拜中。。

拷贝下来 学习  感谢分享~~~

有点厉害啊