API tools faq
paste
Advertisement
Guest User

0.0

a guest
Apr 22nd, 2019
183
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
text 23.12 KB | None | 0 0
raw download clone embed print report
  1. /* ** 遊戲設計說明：
  2. 1. 踩地雷有9*9的格子，共10顆地雷
  3. 2. 顯示數字為那一格附近的八個地區共有幾顆地雷
  4. 未顯示數字則表示附近的八個地區沒地雷
  5.  
  6. ** 程式設計說明：
  7. 1. 將格子宣告成int cells[9][9]的陣列，存放資訊之用
  8. 0 代表安全的地區，且附近沒地雷
  9. 1~ 8 代表安全的地區，但附近有地雷，數字為地雷數
  10. -1 代表尚未被踩到的地雷區
  11. 10~18 代表已被選取的安全地區
  12. -2 代表已被踩到的地雷區，遊戲結束
  13.  
  14. 2. 在螢幕上印出格子
  15. 3. 請使用者輸入第一個要打開的位置(x, y)
  16. 2. 利用亂數放置地雷十顆，在不重複的位置且不是使用者輸入的位址
  17. 4. 在安全地區計算其資訊(附近幾顆地雷)
  18. 5. 將剛被選取到的安全地區值加10(代表已選取)
  19. 6. 清除螢幕
  20. 7. 顯示cells陣列中，值>10的資訊（>10代表已經選取）
  21. 8. 請使用者輸入接下來要打開的位置(x2, y2)
  22. 9. 計算(x2, y2)的值 (安全-> cells[x2][y2] += 10；地雷-> cells[x2][y2] = -2，遊戲結束)
  23. 10. 如果cells[x2, y2]的值為10，則打開附近的格子
  24. 10. 若未結束則重複step 6 ~ 9，直到贏(全部都>10 or ==-1 )就跳出
  25. 11. 詢問是否再玩一次，若再玩一次則重複2~10
  26. */
  27.  
  28. #include<stdio.h>
  29. #include<stdlib.h>
  30. #include<time.h>
  31.  
  32. void assign_initial(int cells[][11]); //將格子內資訊初始化為0
  33. void print_blanks(void); //印出遊戲初始的格子
  34. void open_cell(int *op_x, int *op_y); //請使用者輸入要打開的位置
  35. void put_mine(int cells[][11], int op_x, int op_y); //放置地雷
  36. void calculate_num_of_cells(int cells[][11]); //計算非地雷區附近有幾顆地雷
  37. void assign_inf_after_open(int cells[][11], int op_x, int op_y); //改變使用者打開的位置之資訊
  38. void open_surrounding(int cells[][11], int p_x, int op_y); //打開附近的區域（當格子附近無地雷時）
  39. void check_no_mine(int cells[][11], int op_x, int op_y); //檢查附近的區域有沒有地雷
  40. int check_over(int cells[][11], int op_x, int op_y); //檢查遊戲是否結束(輸或贏)
  41. void print_cells(int cells[][11], int op_x, int op_y, int over); //印出目前的狀況
  42. void print_condition_playing(int cells[][11]); //印出尚未結束的狀況
  43. void print_condition_over(int cells[][11], int over); //印出遊戲結束的狀況(每個格子之資訊)
  44. char play_again(void); //詢問是否再玩一次
  45.  
  46. int main(void) {
  47. int cells[11][11],
  48. open_x, open_y,
  49. over;
  50. char again;
  51.  
  52. do {
  53. system("cls");
  54. assign_initial(cells); //將格子內資訊初始化為0
  55. print_blanks(); //印出遊戲初始的格子
  56. open_cell(&open_x, &open_y); //請使用者輸入要打開的位置
  57. put_mine(cells, open_x, open_y); //放置地雷
  58. calculate_num_of_cells(cells); //計算非地雷區附近有幾彈地雷
  59. assign_inf_after_open(cells, open_x, open_y); //改變使用者打開的位置之資訊
  60. check_no_mine(cells, open_x, open_y); //檢查附近的區域有沒有地雷，並將無地雷的區域打開
  61. over = check_over(cells, open_x, open_y); //檢查遊戲是否結束(輸或贏)
  62. print_cells(cells, open_x, open_y, over); //印出目前的狀況
  63. while (over == 0) {
  64. open_cell(&open_x, &open_y);
  65. assign_inf_after_open(cells, open_x, open_y); //請使用者輸入要打開的位置
  66. check_no_mine(cells, open_x, open_y); //檢查附近的區域有沒有地雷，並將無地雷的區域打開
  67. over = check_over(cells, open_x, open_y); //檢查遊戲是否結束(輸或贏)
  68. print_cells(cells, open_x, open_y, over); //印出目前的狀況
  69. }
  70. again = play_again(); //詢問是否再玩一次
  71. } while (again == 'Y' || again == 'y');
  72.  
  73. return(0);
  74. }
  75.  
  76. void assign_initial(int cells[][11]) { //將格子內資訊初始化為0
  77. int i, j;
  78. for (i = 0; i < 11; i++)
  79. for (j = 0; j < 11; j++)
  80. cells[i][j] = 0;
  81. }
  82.  
  83. void print_blanks(void) { //印出遊戲初始的格子
  84. int i, j;
  85. printf(" 遊戲說明：\n");
  86. printf("---------------------------------------\n");
  87. printf("※ 要開啟最左上角那格請輸入1 1\n");
  88. printf(" 往下一格則左邊的值+1(輸入：2 1)\n");
  89. printf(" 往右一格則右邊的值+1(輸入：1 2)\n");
  90. printf(" 其餘以此類推，從1 1 ~ 9 9\n");
  91. printf(" 輸入格式為：數字空格數字，如：8 2\n\n");
  92. printf("※ 可一次輸入多格座標，\n");
  93. printf(" 座標間只需以非數字符號隔開就可以了！\n");
  94. printf(" 祝您遊戲愉快！:)\n");
  95. printf("---------------------------------------\n\n");
  96. printf(" ");
  97. for (i = 1; i <= 9; i++)
  98. printf("%2d", i);
  99. printf("\n");
  100. for (i = 1; i <= 9; i++) {
  101. for (j = 0; j <= 9; j++) {
  102. if (j == 0)
  103. printf("%4d", i);
  104. else
  105. printf("口");
  106. }
  107. printf("\n");
  108. }
  109. }
  110.  
  111. void open_cell(int *op_x, int *op_y) { //請使用者輸入要打開的位置
  112. int x, y;
  113. printf("\n輸入您要開啟的座標 >> ");
  114. scanf("%d%d", op_x, op_y);
  115. }
  116.  
  117. void put_mine(int cells[][11], int op_x, int op_y) { //放置地雷
  118. srand(time(NULL)); // 亂數種子
  119. int n = 0,
  120. rand_num,
  121. cell_x,
  122. cell_y;
  123.  
  124. do {
  125. rand_num = rand() % 81; // ( rand() % (最大值-最小值+1)) + 最小值
  126. cell_x = (rand_num % 9) + 1;
  127. cell_y = ((rand_num - cell_x) / 9) + 1;
  128. if (cells[cell_x][cell_y] != -1 && !(cell_x == op_x && cell_y == op_y)) {
  129. cells[cell_x][cell_y] = -1;
  130. n++;
  131. }
  132. } while (n < 10);
  133. }
  134.  
  135. void calculate_num_of_cells(int cells[][11]) { //計算非地雷區附近有幾彈地雷
  136. int i, j, u, v;
  137. for (i = 1; i <= 9; i++)
  138. for (j = 1; j <= 9; j++)
  139. if (cells[i][j] == 0)
  140. for (u = i - 1; u <= i + 1; u++)
  141. for (v = j - 1; v <= j + 1; v++)
  142. if (cells[u][v] == -1)
  143. cells[i][j]++;
  144. }
  145.  
  146. void assign_inf_after_open(int cells[][11], int op_x, int op_y) { //改變使用者打開的位置之資訊
  147. if (cells[op_x][op_y] == -1)
  148. cells[op_x][op_y] = -2;
  149. if (cells[op_x][op_y] >= 0 && cells[op_x][op_y] <= 8)
  150. cells[op_x][op_y] += 10;
  151. }
  152.  
  153. void open_surrounding(int cells[][11], int op_x, int op_y) { //打開附近的區域（當格子附近無地雷時）
  154. int i, j;
  155. for (i = op_x - 1; i <= op_x + 1; i++) {
  156. for (j = op_y - 1; j <= op_y + 1; j++) {
  157. if (cells[i][j] >= 0 && cells[i][j] <=8 && i % 10 != 0 && j %10 != 0) {
  158. cells[i][j] += 10;
  159. check_no_mine(cells, i, j);
  160. }
  161. }
  162. }
  163. }
  164.  
  165. void check_no_mine(int cells[][11], int op_x, int op_y) { //檢查附近的區域有沒有地雷
  166. if (cells[op_x][op_y] == 10) //附近沒地雷
  167. open_surrounding(cells, op_x, op_y);
  168. }
  169.  
  170. void print_condition_playing(int cells[][11]) { //印出尚未結束的狀況
  171. int i, j;
  172. printf(" ");
  173. for (i = 1; i <= 9; i++)
  174. printf("%2d", i);
  175. printf("\n ┌－－－－－－－－－┐\n");
  176. for (i = 1; i <= 9; i++) {
  177. for (j = 0; j <= 9; j++) {
  178. if (j == 0)
  179. printf("%4d｜", i);
  180. else if (cells[i][j] < 10)
  181. printf("口");
  182. else if (cells[i][j] == 10)
  183. printf(" 0");
  184. else if (cells[i][j] > 10 && cells[i][j] <= 18)
  185. printf(" %d", cells[i][j] - 10);
  186. if (j == 9)
  187. printf("｜%d", i);
  188. }
  189. printf("\n");
  190. }
  191. printf(" └－－－－－－－－－┘\n");
  192. printf(" ");
  193. for (i = 1; i <= 9; i++)
  194. printf("%2d", i);
  195. printf("\n");
  196. }
  197.  
  198.  
  199. void print_condition_over(int cells[][11], int over) { //印出遊戲結束的狀況(每個格子之資訊)
  200. int i, j;
  201. printf(" ┌－－－－－－－－－┐\n");
  202. for (i = 1; i <= 9; i++) {
  203. for (j = 0; j <= 10; j++) {
  204. if (j == 0)
  205. printf(" ｜");
  206. else if (j == 10)
  207. printf("｜");
  208. else if(cells[i][j] % 10 == 0)
  209. printf("．");
  210. else if (cells[i][j] == -1)
  211. printf(" *");
  212. else if (cells[i][j] == -2)
  213. printf("⊕");
  214. else
  215. printf("%2d", cells[i][j] % 10);
  216. }
  217. printf("\n");
  218. }
  219. printf(" └－－－－－－－－－┘\n");
  220. if (over == 1)
  221. printf("．ˇ．恭喜你～～贏了！\n\n");
  222. else
  223. printf("ˊ＿ˋ爆了…… \n\n");
  224. printf("數字代表周圍八格地雷總數量\n");
  225. printf("*代表地雷\n");
  226. printf("．代表周圍沒地雷\n");
  227. printf("⊕代表爆掉的地雷。\n");
  228. printf("感謝您的賞光～～～\n");
  229. }
  230.  
  231. void print_cells(int cells[][11], int op_x, int op_y, int over) { //印出目前的狀況
  232. system("cls");
  233. printf("\n");
  234. int i, j;
  235. if (over == 0) {
  236. print_condition_playing(cells);
  237. } else
  238. print_condition_over(cells, over);
  239. }
  240.  
  241. int check_over(int cells[][11], int op_x, int op_y) { //檢查遊戲是否結束(輸或贏)
  242. //result == 0 ->尚未結束，result == 1 ->贏，result == -1 ->輸
  243. int i, j, result = 1;
  244. if (cells[op_x][op_y] == -2) {
  245. result = -1;
  246. } else {
  247. for (i = 1; i <= 9 && result == 1; i++)
  248. for (j = 1; j <= 9 && result == 1; j++)
  249. if ((cells[i][j] >= 0 && cells[i][j] <= 8))
  250. result = 0;
  251. }
  252. return(result);
  253. }
  254. /* ** 遊戲設計說明：
  255. 1. 踩地雷有9*9的格子，共10顆地雷
  256. 2. 顯示數字為那一格附近的八個地區共有幾顆地雷
  257. 未顯示數字則表示附近的八個地區沒地雷
  258.  
  259. ** 程式設計說明：
  260. 1. 將格子宣告成int cells[9][9]的陣列，存放資訊之用
  261. 0 代表安全的地區，且附近沒地雷
  262. 1~ 8 代表安全的地區，但附近有地雷，數字為地雷數
  263. -1 代表尚未被踩到的地雷區
  264. 10~18 代表已被選取的安全地區
  265. -2 代表已被踩到的地雷區，遊戲結束
  266.  
  267. 2. 在螢幕上印出格子
  268. 3. 請使用者輸入第一個要打開的位置(x, y)
  269. 2. 利用亂數放置地雷十顆，在不重複的位置且不是使用者輸入的位址
  270. 4. 在安全地區計算其資訊(附近幾顆地雷)
  271. 5. 將剛被選取到的安全地區值加10(代表已選取)
  272. 6. 清除螢幕
  273. 7. 顯示cells陣列中，值>10的資訊（>10代表已經選取）
  274. 8. 請使用者輸入接下來要打開的位置(x2, y2)
  275. 9. 計算(x2, y2)的值 (安全-> cells[x2][y2] += 10；地雷-> cells[x2][y2] = -2，遊戲結束)
  276. 10. 如果cells[x2, y2]的值為10，則打開附近的格子
  277. 10. 若未結束則重複step 6 ~ 9，直到贏(全部都>10 or ==-1 )就跳出
  278. 11. 詢問是否再玩一次，若再玩一次則重複2~10
  279. */
  280.  
  281. #include<stdio.h>
  282. #include<stdlib.h>
  283. #include<time.h>
  284.  
  285. void assign_initial(int cells[][11]); //將格子內資訊初始化為0
  286. void print_blanks(void); //印出遊戲初始的格子
  287. void open_cell(int *op_x, int *op_y); //請使用者輸入要打開的位置
  288. void put_mine(int cells[][11], int op_x, int op_y); //放置地雷
  289. void calculate_num_of_cells(int cells[][11]); //計算非地雷區附近有幾顆地雷
  290. void assign_inf_after_open(int cells[][11], int op_x, int op_y); //改變使用者打開的位置之資訊
  291. void open_surrounding(int cells[][11], int p_x, int op_y); //打開附近的區域（當格子附近無地雷時）
  292. void check_no_mine(int cells[][11], int op_x, int op_y); //檢查附近的區域有沒有地雷
  293. int check_over(int cells[][11], int op_x, int op_y); //檢查遊戲是否結束(輸或贏)
  294. void print_cells(int cells[][11], int op_x, int op_y, int over); //印出目前的狀況
  295. void print_condition_playing(int cells[][11]); //印出尚未結束的狀況
  296. void print_condition_over(int cells[][11], int over); //印出遊戲結束的狀況(每個格子之資訊)
  297. char play_again(void); //詢問是否再玩一次
  298.  
  299. int main(void) {
  300. int cells[11][11],
  301. open_x, open_y,
  302. over;
  303. char again;
  304.  
  305. do {
  306. system("cls");
  307. assign_initial(cells); //將格子內資訊初始化為0
  308. print_blanks(); //印出遊戲初始的格子
  309. open_cell(&open_x, &open_y); //請使用者輸入要打開的位置
  310. put_mine(cells, open_x, open_y); //放置地雷
  311. calculate_num_of_cells(cells); //計算非地雷區附近有幾彈地雷
  312. assign_inf_after_open(cells, open_x, open_y); //改變使用者打開的位置之資訊
  313. check_no_mine(cells, open_x, open_y); //檢查附近的區域有沒有地雷，並將無地雷的區域打開
  314. over = check_over(cells, open_x, open_y); //檢查遊戲是否結束(輸或贏)
  315. print_cells(cells, open_x, open_y, over); //印出目前的狀況
  316. while (over == 0) {
  317. open_cell(&open_x, &open_y);
  318. assign_inf_after_open(cells, open_x, open_y); //請使用者輸入要打開的位置
  319. check_no_mine(cells, open_x, open_y); //檢查附近的區域有沒有地雷，並將無地雷的區域打開
  320. over = check_over(cells, open_x, open_y); //檢查遊戲是否結束(輸或贏)
  321. print_cells(cells, open_x, open_y, over); //印出目前的狀況
  322. }
  323. again = play_again(); //詢問是否再玩一次
  324. } while (again == 'Y' || again == 'y');
  325.  
  326. return(0);
  327. }
  328.  
  329. void assign_initial(int cells[][11]) { //將格子內資訊初始化為0
  330. int i, j;
  331. for (i = 0; i < 11; i++)
  332. for (j = 0; j < 11; j++)
  333. cells[i][j] = 0;
  334. }
  335.  
  336. void print_blanks(void) { //印出遊戲初始的格子
  337. int i, j;
  338. printf(" 遊戲說明：\n");
  339. printf("---------------------------------------\n");
  340. printf("※ 要開啟最左上角那格請輸入1 1\n");
  341. printf(" 往下一格則左邊的值+1(輸入：2 1)\n");
  342. printf(" 往右一格則右邊的值+1(輸入：1 2)\n");
  343. printf(" 其餘以此類推，從1 1 ~ 9 9\n");
  344. printf(" 輸入格式為：數字空格數字，如：8 2\n\n");
  345. printf("※ 可一次輸入多格座標，\n");
  346. printf(" 座標間只需以非數字符號隔開就可以了！\n");
  347. printf(" 祝您遊戲愉快！:)\n");
  348. printf("---------------------------------------\n\n");
  349. printf(" ");
  350. for (i = 1; i <= 9; i++)
  351. printf("%2d", i);
  352. printf("\n");
  353. for (i = 1; i <= 9; i++) {
  354. for (j = 0; j <= 9; j++) {
  355. if (j == 0)
  356. printf("%4d", i);
  357. else
  358. printf("口");
  359. }
  360. printf("\n");
  361. }
  362. }
  363.  
  364. void open_cell(int *op_x, int *op_y) { //請使用者輸入要打開的位置
  365. int x, y;
  366. printf("\n輸入您要開啟的座標 >> ");
  367. scanf("%d%d", op_x, op_y);
  368. }
  369.  
  370. void put_mine(int cells[][11], int op_x, int op_y) { //放置地雷
  371. srand(time(NULL)); // 亂數種子
  372. int n = 0,
  373. rand_num,
  374. cell_x,
  375. cell_y;
  376.  
  377. do {
  378. rand_num = rand() % 81; // ( rand() % (最大值-最小值+1)) + 最小值
  379. cell_x = (rand_num % 9) + 1;
  380. cell_y = ((rand_num - cell_x) / 9) + 1;
  381. if (cells[cell_x][cell_y] != -1 && !(cell_x == op_x && cell_y == op_y)) {
  382. cells[cell_x][cell_y] = -1;
  383. n++;
  384. }
  385. } while (n < 10);
  386. }
  387.  
  388. void calculate_num_of_cells(int cells[][11]) { //計算非地雷區附近有幾彈地雷
  389. int i, j, u, v;
  390. for (i = 1; i <= 9; i++)
  391. for (j = 1; j <= 9; j++)
  392. if (cells[i][j] == 0)
  393. for (u = i - 1; u <= i + 1; u++)
  394. for (v = j - 1; v <= j + 1; v++)
  395. if (cells[u][v] == -1)
  396. cells[i][j]++;
  397. }
  398.  
  399. void assign_inf_after_open(int cells[][11], int op_x, int op_y) { //改變使用者打開的位置之資訊
  400. if (cells[op_x][op_y] == -1)
  401. cells[op_x][op_y] = -2;
  402. if (cells[op_x][op_y] >= 0 && cells[op_x][op_y] <= 8)
  403. cells[op_x][op_y] += 10;
  404. }
  405.  
  406. void open_surrounding(int cells[][11], int op_x, int op_y) { //打開附近的區域（當格子附近無地雷時）
  407. int i, j;
  408. for (i = op_x - 1; i <= op_x + 1; i++) {
  409. for (j = op_y - 1; j <= op_y + 1; j++) {
  410. if (cells[i][j] >= 0 && cells[i][j] <=8 && i % 10 != 0 && j %10 != 0) {
  411. cells[i][j] += 10;
  412. check_no_mine(cells, i, j);
  413. }
  414. }
  415. }
  416. }
  417.  
  418. void check_no_mine(int cells[][11], int op_x, int op_y) { //檢查附近的區域有沒有地雷
  419. if (cells[op_x][op_y] == 10) //附近沒地雷
  420. open_surrounding(cells, op_x, op_y);
  421. }
  422.  
  423. void print_condition_playing(int cells[][11]) { //印出尚未結束的狀況
  424. int i, j;
  425. printf(" ");
  426. for (i = 1; i <= 9; i++)
  427. printf("%2d", i);
  428. printf("\n ┌－－－－－－－－－┐\n");
  429. for (i = 1; i <= 9; i++) {
  430. for (j = 0; j <= 9; j++) {
  431. if (j == 0)
  432. printf("%4d｜", i);
  433. else if (cells[i][j] < 10)
  434. printf("口");
  435. else if (cells[i][j] == 10)
  436. printf(" 0");
  437. else if (cells[i][j] > 10 && cells[i][j] <= 18)
  438. printf(" %d", cells[i][j] - 10);
  439. if (j == 9)
  440. printf("｜%d", i);
  441. }
  442. printf("\n");
  443. }
  444. printf(" └－－－－－－－－－┘\n");
  445. printf(" ");
  446. for (i = 1; i <= 9; i++)
  447. printf("%2d", i);
  448. printf("\n");
  449. }
  450.  
  451.  
  452. void print_condition_over(int cells[][11], int over) { //印出遊戲結束的狀況(每個格子之資訊)
  453. int i, j;
  454. printf(" ┌－－－－－－－－－┐\n");
  455. for (i = 1; i <= 9; i++) {
  456. for (j = 0; j <= 10; j++) {
  457. if (j == 0)
  458. printf(" ｜");
  459. else if (j == 10)
  460. printf("｜");
  461. else if(cells[i][j] % 10 == 0)
  462. printf("．");
  463. else if (cells[i][j] == -1)
  464. printf(" *");
  465. else if (cells[i][j] == -2)
  466. printf("⊕");
  467. else
  468. printf("%2d", cells[i][j] % 10);
  469. }
  470. printf("\n");
  471. }
  472. printf(" └－－－－－－－－－┘\n");
  473. if (over == 1)
  474. printf("．ˇ．恭喜你～～贏了！\n\n");
  475. else
  476. printf("ˊ＿ˋ爆了…… \n\n");
  477. printf("數字代表周圍八格地雷總數量\n");
  478. printf("*代表地雷\n");
  479. printf("．代表周圍沒地雷\n");
  480. printf("⊕代表爆掉的地雷。\n");
  481. printf("感謝您的賞光～～～\n");
  482. }
  483.  
  484. void print_cells(int cells[][11], int op_x, int op_y, int over) { //印出目前的狀況
  485. system("cls");
  486. printf("\n");
  487. int i, j;
  488. if (over == 0) {
  489. print_condition_playing(cells);
  490. } else
  491. print_condition_over(cells, over);
  492. }
  493.  
  494. int check_over(int cells[][11], int op_x, int op_y) { //檢查遊戲是否結束(輸或贏)
  495. //result == 0 ->尚未結束，result == 1 ->贏，result == -1 ->輸
  496. int i, j, result = 1;
  497. if (cells[op_x][op_y] == -2) {
  498. result = -1;
  499. } else {
  500. for (i = 1; i <= 9 && result == 1; i++)
  501. for (j = 1; j <= 9 && result == 1; j++)
  502. if ((cells[i][j] >= 0 && cells[i][j] <= 8))
  503. result = 0;
  504. }
  505. return(result);
  506. }
  507.  
  508. char play_again(void) { //詢問是否再玩一次
  509. char again;
  510. printf("\n還要再玩一次嗎？");
  511. do {
  512. printf("\n要再玩一次的話請輸入Y，\n");
  513. printf("或輸入N關閉程式。 >>");
  514. scanf(" %c", &again);
  515. } while (again != 'Y' && again != 'y' && again != 'N' && again != 'n');
  516. return(again);
  517. }
Advertisement
Add Comment
Please, Sign In to add comment
Advertisement
Public Pastes
Advertisement
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy.  OK, I Understand
Not a member of Pastebin yet?
Sign Up, it unlocks many cool features!