[C語言]鏈表實現貪吃蛇及部分模塊優化

    在繼上篇[C語言]貪吃蛇_結構數組實現大半年后，鏈表實現的版本也終於出爐了。兩篇隔了這么久除了是懶癌晚期的原因外，對整個游戲流程的改進，模塊的精簡也花了一些時間（都是借口）。

 

_{優化模塊的前沿鏈接：}

        ·游戲流程結構的改進

        ·對輸入的甄別與判斷

        ·單鏈表元素移動

 

一、游戲流程

    貪吃蛇游戲的原理很簡單，即在一張地圖內，有一條蛇和隨機出現的食物，玩家操控蛇的移動，當蛇吃到了食物后，蛇長度增加。游戲過程中，蛇不能撞牆，也不能咬到自身。

    反映到程序中，就是這樣一張簡略的流程圖（結構數組實現）：

    

    在這個流程中，有許多的不足。當蛇已經存在並且接受了一個合法的輸入時，根據下一步是否吃到食物來判斷是否需要清除尾巴是合理的，但在控制台里，貪吃蛇每次循環移動其實都只需對兩個位置進行操作：一個是接受操作后的蛇頭，無論下一步在哪兒，這都是必須要打印的一個；另一個是蛇尾，這則需要根據蛇頭是否吃到食物來決定去留。所以每次循環都重新打印所有節點是很多余的，因此需要改進。

    我們可以這樣改：在接受輸入后，先把一定會移動的蛇頭打印出來，再判斷蛇尾的去留。最后在蛇（鏈表）各個節點中，依次賦得前一個節點的值。流程圖移動模塊如下：

    

    按照這個流程圖，蛇每次移動就只需要操作控制台上的兩個節點了。另外可以將在控制台某坐標打印一個特殊符號抽象成一個函數：

1. #define SPACE 0  
2. #define NODE 1  
3. #define FOOD 2  
4. #define WALL 3  
5.     
6. void PrintIn(int size,int x,int y);  
7.     
8.     
9. void PrintIn(int size,int x,int y)  
10. {  
11.     //size  
12.     //清除節點：0    打印蛇身：1        
13.     //打印食物：2    打印牆壁：3   
14.     char *arr[4] = {" ","⊙","●","■"};  
15.     Pos(x,y);  
16.     printf("%s",arr[size]);  
17. }  

     

二、初始化

    1.初始化地圖

        在[C語言]貪吃蛇_結構數組實現中我提到過，因為控制台一個字符的寬高所占像素點不同，所以再看控制台上想輸出一個規整的正方形，就得讓寬高之比為2:1。並且為了輸出的正方形更完整，就需要使用一些占兩個普通字符的特殊字符。

1. #define WIDTH 60  
2. #define HEIGHT 30  
3.     
4. void CreateMap(void);  
5.     
6. void CreateMap(void)  
7. {  
8.     int i;  
9.     for(i=0;i<WIDTH;i+=2)// 上下30 寬   
10.     {  
11.         PrintIn(WALL,i,0);  
12.         PrintIn(WALL,i,HEIGHT-1);  
13.     }  
14.     for(i=1;i<HEIGHT-1;i++)//左右 28+2 高   
15.     {  
16.         PrintIn(WALL,0,i);  
17.         PrintIn(WALL,WIDTH-2,i);  
18.     }  
19. }  

 

    2.初始化蛇

        在初始化蛇之前，我們得給蛇一個定義：蛇應該是一個鏈表，其中每個節點都包含了一個坐標。所以有如下定義：

1. typedef struct {  
2.     int x;  
3.     int y;  
4. }Place;     //坐標   
5.     
6. typedef struct node{  
7.     Place place;  
8.     struct node *next;  
9. }Node;      //節點   
10.     
11. typedef struct snake{  
12.     Node *head;  
13.     int size;   //長度   
14. }Snake;     //指向一條蛇   
15.      

    因此當我們聲明

16. Snake snake;  

    時，我們其實就聲明了一條蛇。

    好了，現在可以給蛇賦予節點了。原理也很簡單，在鏈表尾部加三個節點就好。我們規定蛇頭在右，共有三個節點，位置居中，所以蛇頭的坐標應該為（28，14），后兩個節點依次為（26，14）、（24，14）。

17. bool InitializeSnake(Snake *psnake)  
18. {  
19.     Node *pnew;  
20.     Node *scan;  
21.          
22.     for(int i = 0;i<3;i++)  
23.     {  
24.         scan = (psnake->head);  
25.         pnew = (Node *)malloc(sizeof(Node));  
26.         if(pnew == NULL)  
27.         {  
28.             printf("pnew == NULL");  
29.             system("pause");  
30.             return false;   
31.         }  
32.         pnew->place.x = 28-2*i;  
33.         pnew->place.y = 14;  
34.         pnew->next = NULL;  
35.         psnake->size++;  
36.         PrintIn(NODE,pnew->place.x,pnew->place.y);  
37.         if(scan == NULL)  
38.              psnake->head = pnew;  
39.         else  
40.         {  
41.             while(scan->next != NULL)  
42.                 scan = scan->next;  
43.             scan->next = pnew;  
44.         }  
45.     }  
46.     return true;  
47. }  

3.初始化食物

        食物可用一個全局變量來表示，該變量存儲一個坐標值。因此可用上之前定義的Place結構。

1. typedef Place Food;  
2.     
3. Food food = {0,0};  

   而坐標值的范圍只要保證兩點就好：在地圖內；不與蛇身重合。

4. void CreateFood(void)  
5. {   
6.     int flag = 0;  
7.     srand((unsigned int)time(0));  
8.     while(1)  
9.     {  
10.         do{  
11.             food.x = rand()%(WIDTH-5)+2;  
12.         }while(food.x%2!=0);  
13.         food.y = rand()%(HEIGHT-2)+1;  
14.         Node *scan = snake.head;  
15.         while(scan !=NULL)  
16.         {  
17.             if(scan->place.x == food.x &&  
18.                 scan->place.y == food.y)  
19.                 {  
20.                     flag = -1;  
21.                     break;  
22.                 }  
23.             scan = scan->next;  
24.         }  
25.         if(flag>=0)  
26.         {  
27.             PrintIn(FOOD,food.x,food.y);  
28.             break;  
29.         }  
30.     }  
31. //    AfterEatFood();  
32. }  

 

二、蛇的移動——輸入的甄別

    蛇的移動本質很簡單，就是不斷更新蛇的位置，並打印。所以我們需要一個循環：

1. while(true)    
2. {    
3.  //。。。  
4. }   

   其次我們需要接收輸入，用來控制游戲進行

這里介紹一個函數

1. 1.  int kbhit(void);    
2. 2.  // 檢查當前是否有鍵盤輸入，若有則返回一個非0值，否則返回0  

這是一個非阻塞函數，有鍵按下時返回非0，但此時按鍵碼仍然在鍵盤緩沖隊列中。所以在確定鍵盤有響應之后，再用一個char變量將輸入從緩沖區中調出來。

1. 1.  if(kbhit())    
2. 2.      ch = getch();    

   現在我們規定游戲中'w' 's' 'a' 'd'控制方向，空格暫停，所以對於用戶的輸入，我們需要判斷是否合法。我用了一個數組+循環來代替一連串的if：

3. char ch,direction = ' ';  
4. char charr[5] = {'w','s','a','d',' '};  
5. int flag = 0;  
6. if(kbhit())  
7.     ch = getch();  
8. for(int i = 0;i<5;i++)   //判斷輸入是否為規定的五個字符   
9. {  
10.     if(ch == charr[i])  
11.     {  
12.         flag = 1;  
13.         break;  
14.     }  
15. }  

    當我們得到的輸入合法時，我們仍需判斷現在的輸入方向是否與之前的方向相反，畢竟在我設計的這個游戲里，蛇身可不能折疊往自己身上碾過去。

    在我用數組實現的那個版本里，我用了一大串if-else來避免相反的輸入，這雖然簡單，卻很無腦。所以我用一個更簡單的方法代替了它。在我們規定為正確輸入的五個字符中，ASCII碼分別為a:97,d:100,w:119,s:115,space:32，其中ad是沖突的一對，ws是沖突的一對。ad的差值為±3，ws的差值為±4，空格直接暫停，因此不予考慮。所以我們只需要判斷，如果輸入ch的值與方向direction的差值為±3或者±4，那么就可以斷定輸入不合法，丟棄。

16. if(flag == 1)   //確認輸入正常   
17. {  
18.     if(!(direction-ch==4||direction-ch==-4||direction-ch==3||direction-ch==-3))  
19.     {   //排除與方向相反的輸入   
20.         direction = ch;  
21.     }  
22.     else if(ch == ' ')  
23.         continue;  
24. }  

    之前版本10行的事情，現在有意義的代碼只有5行。

 

三、蛇的移動

    為了方便對移動的坐標進行操作，我們聲明一個數組，用來存儲不同方向下坐標的變化：

1. int dir_value[2][4] = {  
2.     {0,0,-2,2},  
3.     {-1,1,0,0}  
4. };  

   不同下標分別對於w s a d，因為長度60的WIDTH其實只有30個單位，所以x值一次加2。

    1、畫面上的移動

        由於蛇身每個節點都一個樣，所以沒有必要每次循環都把所有的節點重新輸出一遍，只需要更新頭節點和尾節點就好。在游戲中，無論是撞牆、還是其他情況，蛇只要移動了，那么他頭節點的坐標一定會改變，因此我們可以在移動后先把新的蛇頭打印出來。至於蛇尾，如果蛇移動后並沒有吃到食物，蛇尾則刪除，吃到了的話蛇尾則保留。所以在打印了頭部之后再判斷頭部是否吃到食物，再對蛇尾進行處理。

1. switch(direction)  
2.         {  
3.             case 'w':  
4.                 PrintIn(NODE,snake.head->place.x+dir_value[0][0],snake.head->place.y+dir_value[1][0]);    //打印頭部  
5.                 if(snake.head->place.x+dir_value[0][0] == food.x && snake.head->place.y+dir_value[1][0] == food.y)  
6.                 {  
7.                     //AddNode(&snake);  //尾插法  
8.                     //CreateFood();  
9.                 }  
10.                 else     //沒有吃到  
11.                 {  
12.                     Node *tail = GetTail(&snake);  
13.                     PrintIn(SPACE,tail->place.x,tail->place.y);     //畫面上消除尾部節點  
14.                 }  
15. //...  
16. }  

    2、畫面外的移動

        在內存中，我們則需要更新各個節點的坐標。如果吃到了食物，則加入一個節點（我用的尾插法），並將前一節點的值賦給后一節點。先前的頭節點坐標值賦給第二節點，頭節點則根據輸入，更新新的坐標值。沒有吃到的話，也直接賦值，尾節點坐標值因為下一步就要更新，所以可丟棄不管，只需得到前一節點坐標就好。

1. case 'w':  
2.                 PrintIn(NODE,snake.head->place.x+dir_value[0][0],snake.head->place.y+dir_value[1][0]);  
3.                 if(snake.head->place.x+dir_value[0][0] == food.x && snake.head->place.y+dir_value[1][0] == food.y)  
4.                 {  
5.                     AddNode(&snake);    //尾插法  
6.                     CreateFood();  
7.                 }  
8.                 else  
9.                 {  
10.                     Node *tail = GetTail(&snake);   //得到尾節點  
11.                     PrintIn(SPACE,tail->place.x,tail->place.y);  
12.                 }  
13.                 RenewSnake(&snake);   //鏈表各節點值的跟新  
14.                 snake.head->place.x += dir_value[0][0];  //蛇頭更新  
15.                 snake.head->place.y += dir_value[1][0];  
16.                 break;  

    其中RenewSnake()函數用來更新一個鏈表（蛇），使前一個節點的值賦給后一個節點，對這個只需要兩個臨時變量就可以。

        從這簡單的流程圖可看出一點端倪，現在我們把步驟完善一下。

        因此我們得到了一些普適性的方法，代碼如下：

1. void RenewSnake(Snake *psnake)  
2. {  
3.     int x_index[2] = {0,0},y_index[2] = {0,0};  
4.     Node *scan = psnake->head;  
5.         
6.     int i = 1;  
7.     x_index[i%2] = scan->place.x;  
8.     y_index[i%2] = scan->place.y;  
9.         
10.     for(i = 1;i<psnake->size;i++)  
11.     {     
12.         x_index[(i+1)%2] = scan->next->place.x;  
13.         y_index[(i+1)%2] = scan->next->place.y;  
14.             
15.         scan->next->place.x = x_index[i%2];  
16.         scan->next->place.y = y_index[i%2];  
17.             
18.         scan = scan->next;  
19.     }  
20. }  

    同理，其余三個方向也是如此。

 

四、移動后的操作

    在這個游戲中，我們需要這么幾個變量：

1. int length = -1;  
2. int score = -10;  
3. int speed = 250;  

其中，length其實可以不需要。我們需要在吃到食物后進行一系列的操作，如加分，重新生成食物等等。所以在移動時的判斷里加入一些函數。

1. if(snake.head->place.x+dir_value[0][0] == food.x && snake.head->place.y+dir_value[1][0] == food.y)  
2. {  
3.     AddNode(&snake);    //尾插法  
4.     CreateFood();  
5. }  

   生成食物還需要加分等操作，所以我們可以把加分等操作的函數（AfterEatFood();）放到該函數末尾。不過這樣的話，游戲開始生成的第一個食物就需要注意了，因此我們的兩個全局變量都是負值。

6. void AfterEatFood()  
7. {  
8.     Pos(WIDTH+20,HEIGHT-20);  
9.     printf("%d = %d",++length,snake.size);  
10.     Pos(WIDTH+16,HEIGHT-18);  
11.     if(speed>150)  
12.         score += 10;  
13.     else  
14.         score += 20;  
15.     printf("%d",score);  
16.     if(speed>100)  
17.         speed-=5;  
18.     Pos(WIDTH+16,HEIGHT-16);  
19.     printf("%d",speed);  
20. }  

    在蛇移動后，我們還需判斷蛇是否撞牆或者咬到自身。撞牆是蛇頭與邊界坐標的比較，咬到自身則可以用一個循環。

21. if(ThroughWall(&snake) == true)  
22. {  
23.     Pos(0,30);  
24.     system("pause");  
25.     exit(0);   
26. }  
27. if(BiteItself(&snake)==true)  
28. {  
29.     Pos(0,30);  
30.     system("pause");  
31.     exit(0);   
32. }         

 

1. bool ThroughWall(Snake *psnake)  
2. {  
3.     if(psnake->head->place.x == 0 || psnake->head->place.x == WIDTH-2 ||  
4.         psnake->head->place.y == 0 || psnake->head->place.y == HEIGHT-1)  
5.         {  
6.             Pos(25,15);  
7.             printf("撞牆，游戲結束！");  
8.             return true;  
9.         }  
10.     else  
11.     {  
12.         Pos(0,HEIGHT);  
13.         printf(" ");    //將閃爍不停的光變放到地圖外面---迷之操作=。=   
14.         return false;  
15.     }  
16. }  
17.     
18. bool BiteItself(Snake *psnake)  
19. {  
20.     Node *scan = psnake->head;  
21.         
22.     while(scan->next != NULL)  
23.     {  
24.         scan = scan->next;  
25.         if(scan->place.x == psnake->head->place.x &&  
26.             scan->place.y == psnake->head->place.y)  
27.         {  
28.             Pos(25,15);  
29.             printf("咬到自身，游戲結束！");  
30.             return true;  
31.         }  
32.     }  
33.     return false;  
34. }  

    最后在循環末尾加入Sleep，控制游戲的節奏。

35. Sleep(speed);  

 

五、附注

    1、源代碼地址：貪吃蛇鏈表實現源碼

    2、主函數截圖：

    3、運行截圖：