Linux系統下用C語言編寫2D圖形游戲

在Linux系統下，不要以為C語言就只能寫那種只有字符的控制台程序，別忘了，Linux系統有FrameBuffer（幀緩沖），只要顯示器是彩色的，並且是linux系統的，就可以用C語言代碼通過讀寫FrameBuffer裡的數據在屏幕上繪制圖形；

圖形嘛，有png庫，用它的函數解碼圖片文件，得到圖片數組，共有red、green、blue、alpha四種數組，alpha用於圖片之間的組合，最終將RGB數組輸出到FrameBuffer就能顯示了；

想要動態圖形效果，自己用算法實現。

目前，我正在為自己的嵌入式設備開發一個游戲，圖形素材來源於互聯網，游戲截圖如下圖所示：

如上圖所示，主菜單中的紅色光標有閃爍效果，游戲畫面切換有淡入淡出效果。

下面有源碼，現在使用的按鍵控制方法的效果不理想。

linux系統環境，按鍵判斷，使用了getch()和kbhit()函數，函數是模擬實現的。

為了判斷按鍵是否為按住狀態，我使用一個變量count來計數，每循環一次自增，也就是按鍵檢測延遲的最大時間，超過了這段時間，如果getch()函數沒有再次返回接受到同樣的按鍵的鍵值，那麼就判斷為這個按鍵已經釋放，否則，該按鍵處於按住狀態，並繼續顯示之前的動作。

還有圖形顯示，目前沒掌握局部刷新的技術，游戲顯示的每一幀圖形都是全屏刷新的，效率低，每秒大概刷新4幀。

源碼只提供部分：

1. void next_frames(void)  
2. {//更新到下一幀   
3.     frames[0] += speed[0];//玩家1的   
4.     frames[1] += speed[1];//AI的   
5. }  
6.   
7. void init_player_data(void)  
8. //初始化各個玩家的數據   
9. {  
10.     direction[0] = IS_RIGHT;//玩家朝向右邊   
11.     direction[1] = IS_LEFT;//AI角色朝向左邊   
12.   
13.     //各個角色的初始位置   
14.     map_site_x[0] = 100;  
15.     map_site_x[1] = 300;  
16.     map_site_y[1] = map_hight - 20;  
17.     map_site_y[0] = map_hight - 20;//在地圖上的坐標   
18.       
19.     speed[0] = 1;//每次循環幀frames自增的的值，之前是想做能設置游戲刷新速度的功能，現在已拋棄，這個變量貌似沒用了。   
20.     speed[1] = 1;  
21.     need_move[0] = 0;//玩家是否需要移動   
22.     need_move[1] = 0;//AI是否需要移動   
23.       
24.     can_use_next[0] = 0;//可以使用下一個動作   
25.     can_use_next[1] = 0;//AI可以使用下一個動作   
26.     status[0] = STANCE;//玩家為站立狀態   
27.     status[1] = STANCE;//AI為站立狀態   
28.       
29.     shock_wave_num = 0;//沖擊波的總數為0   
30.     need_view_shock_wave = 0;//不需要顯示沖擊波   
31. }  
32. int play_game(void)  
33. {  
34.     unsigned char **game_map;//游戲地圖   
35.     int map_id,temp_key = 0,count = 0,key = 0,man_id;//人物代號   
36.     //分配內存   
37.     man_id = ICHIGO;//人物動畫選擇黑崎一護   
38.     init_player_data();//初始化玩家數據   
39.     map_id = 1;  
40.     if(map_id == 1) {  
41.         game_map = load_map_1();//載入地圖數據   
42.     }  
43.     while(1){  
44.         update_graph();//規定鏡頭，顯示玩家所在的區域的圖形   
45.         view_map_area(game_map[0],game_map[1],game_map[2]);//根據主角的位置，顯示地圖中的某個區域   
46.         if(kbhit()){//調用kbhit()函數檢測是否有按鍵輸入   
47.             key = getch();//有按鍵輸入就用getch()函數獲取鍵值並賦給key，下面開始判斷key的值   
48.             if(key == KEY_BACK) break;  
49.             if(key == 'w' || key == 'W' || key == KEY_UP) {  
50.                 temp_key = key;  
51.             }  
52.             else if((key == 'd' || key == 'D' || key == KEY_RIGHT) && status[0] != JUMP_ATTACK){//如果按的是a鍵或者左鍵   
53.                 if((temp_key == 'd' || temp_key == 'D' || temp_key == KEY_RIGHT)&& count < 5) {  
54.   
55.                     next_action[0] = WALK;//下一個動作還是行走   
56.                 }  
57.                 else if(can_use_next[0] == 0){//如果之前沒有按過a鍵或者左鍵,並且，可以使用下一個動作   
58.                     if(temp_status[0] != JUMP) {//如果之前不是跳躍狀態   
59.                         status[0] = WALK;  
60.                         if(temp_status[0] != WALK) frames[0] = 0;//如果之前不是行走狀態   
61.                         else if(temp_status[0] == WALK){//如果之前是行走狀態   
62.                             next_action[0] = WALK;//下一個動作還是行走   
63.                         }  
64.                     }  
65.                     else need_move[0] = 1;//否則，需要移動   
66.                 }  
67.                 direction[0] = IS_RIGHT;  
68.                 need_move[0] = 1;  
69.                 temp_key = key;  
70.                 count = 0;//計數清零   
71.             }  
72.             else if((key == 'a' || key == 'A' || key == KEY_LEFT) && status[0] != JUMP_ATTACK){//如果按的是a鍵或者左鍵   
73.                 if((temp_key == 'a' || temp_key == 'A' || temp_key == KEY_LEFT)&& count < 5) {  
74.                     next_action[0] = WALK;//下一個動作還是行走   
75.                 }  
76.                 else if(can_use_next[0] == 0){//如果之前沒有按過a鍵或者左鍵,並且，可以使用下一個動作   
77.                     if(temp_status[0] != JUMP) {//如果之前不是跳躍狀態   
78.                         status[0] = WALK;  
79.                         if(temp_status[0] != WALK) frames[0] = 0;//如果之前不是行走狀態   
80.                         else if(temp_status[0] == WALK){//如果之前是行走狀態   
81.                             next_action[0] = WALK;//下一個動作還是行走   
82.                         }  
83.                     }  
84.                     else need_move[0] = 1;//否則，需要移動   
85.                 }  
86.                 direction[0] = IS_LEFT;  
87.                 need_move[0] = 1;  
88.                 temp_key = key;  
89.                 count = 0;//計數清零   
90.             }  
91.             else if(key == 's' || key == 'S' || key == KEY_DOWN){//如果按的是s鍵或者是下鍵   
92.                 if(can_use_next[0] == 0){  
93.                     status[0] = BLOCK;  
94.                     if((temp_key == 's' || temp_key == 'S' || temp_key == KEY_DOWN) && count <10){  
95.                         //如果之前按過s鍵或者是下鍵,並且在最大延遲時間內   
96.                         if(temp_status[0] == BLOCK && status[0] == BLOCK)//如果之前的動作是防御   
97.                         {  
98.                             frames[0] = 2;speed[0] = 0;  
99.                         }  
100.                     }  
101.                     else {  
102.                         frames[0] = 0;//幀數歸零www.linuxidc.com   
103.                         speed[0] = 1;  
104.                     }  
105.                 }  
106.                 temp_key = key;//保存按鍵的鍵值   
107.                 count = 0;//計數歸零   
108.             }  
109.             else if(key == 'j' || key == 'J'){//如果按的是j鍵   
110.                 if(temp_status[0] == JUMP || temp_status[0] == JUMP_ATTACK)//如果之前還處於跳躍狀態   
111.                 {  
112.                     if(jump_attack_num == 0) {  
113.                         status[0] = JUMP_ATTACK;//跳躍攻擊   
114.                         jump_attack_num = 1;  
115.                     }  
116.                 }  
117.                 else if(status[0] == DOWN_ATTACK || status[0] == BLOCK || temp_key == KEY_DOWN || temp_key == 's' || temp_key == 'S'){  
118.                     status[0] = DOWN_ATTACK;  
119.                     if(temp_status[0] != DOWN_ATTACK) frames[0] = 0;//幀數歸零   
120.                 }  
121.                 else if(temp_key == KEY_UP || temp_key == 'w' || temp_key == 'W'){  
122.                     if(can_use_next[0] == 0){//如果可以使用下一個動作   
123.                         status[0] = UP_ATTACK;  
124.                         frames[0] = 0;//幀數歸零   
125.                     }  
126.                 }  
127.                 else if((temp_key == 'j' || temp_key == 'J') && count <5){//如果之前按過j鍵,並且在最大延遲時間內   
128.                     if(temp_status[0] == FIRST_ATTACK && status[0] == FIRST_ATTACK)//如果之前處於第一段攻擊狀態下   
129.                     {  
130.                         status[0] = FIRST_ATTACK;  
131.                         if(can_use_next[0] == 0 && first_attack_complete[0] == 0){//如果可以使用下一個動作   
132.                             status[0] = SECOND_ATTACK;//開始進行第二段攻擊   
133.                             frames[0] = 0;//幀數歸零www.linuxidc.com   
134.                         }  
135.                         else{  
136.                             next_action[0] = SECOND_ATTACK;//保存下一個動作，等待之前的動作完成   
137.                         }  
138.                     }  
139.                     else if(temp_status[0] == SECOND_ATTACK || status[0] == SECOND_ATTACK)//如果之前處於第二段攻擊狀態下   
140.                     {  
141.                         status[0] = SECOND_ATTACK;  
142.                         if(can_use_next[0] == 0 && second_attack_complete[0] == 0){//如果可以使用下一個動作   
143.                             status[0] = THIRD_ATTACK;//開始進行第二段攻擊   
144.                             frames[0] = 0;//幀數歸零   
145.                         }  
146.                         else{  
147.                             next_action[0] = THIRD_ATTACK;//保存下一個動作，等待之前的動作完成   
148.                         }  
149.                     }  
150.                     else if(temp_status[0] == THIRD_ATTACK || status[0] == THIRD_ATTACK)//如果之前處於第二段攻擊狀態下   
151.                     {  
152.                         status[0] = THIRD_ATTACK;  
153.                         if(can_use_next[0] == 0 && third_attack_complete[0] == 0){//如果可以使用下一個動作   
154.                             status[0] = FIRST_ATTACK;//開始進行第一段攻擊   
155.                             frames[0] = 0;//幀數歸零   
156.                         }  
157.                         else{  
158.                             //next_action = FIRST_ATTACK;//保存下一個動作，等待之前的動作完成   
159.                         }  
160.                     }  
161.                     else{  
162.                         status[0] = FIRST_ATTACK;  
163.                         frames[0] = 0;  
164.                     }  
165.                 }  
166.   
167.                 else {  
168.                     status[0] = FIRST_ATTACK;  
169.                     if(temp_status[0] != FIRST_ATTACK) frames[0] = 0;  
170.                 }  
171.                 speed[0] = 1;  
172.                 count = 0;  
173.                 temp_key = key;//保存按鍵的鍵值   
174.             }  
175.             else if((key == 'k' || key == 'K') && can_use_next[0] == 0){//如果按的是k鍵，並且能使用下一個動作   
176.                 status[0] = JUMP;  
177.                 count = 0;  
178.                 jump_attack_num = 0;  
179.                 frames[0] = 0;  
180.             }  
181.             else if(key == 'U' || key == 'u'){  
182.                 if(status[0] == DOWN_Y_ATTACK || status[0] == BLOCK || temp_key == KEY_DOWN || temp_key == 's' || temp_key == 'S'){  
183.                     speed[0] = 1;  
184.                     status[0] = DOWN_Y_ATTACK;  
185.                     if(temp_status[0] != DOWN_Y_ATTACK) frames[0] = 0;//幀數歸零   
186.                 }  
187.                 else if(can_use_next[0] == 0){//如果可以使用下一個動作   
188.                     status[0] = Y_ATTACK;//開始進行第二段攻擊   
189.                     frames[0] = 0;//幀數歸零   
190.                 }  
191.                 else{  
192.                     next_action[0] = Y_ATTACK;//保存下一個動作，等待之前的動作完成   
193.                 }  
194.                 count = 0;  
195.                 temp_key = key;  
196.             }  
197.             else if(key == 'L' || key == 'l'){   
198.                 if(can_use_next[0] == 0){//如果可以使用下一個動作   
199.                     status[0] = DASH;  
200.                     frames[0] = 0;//幀數歸零   
201.                 }  
202.                 else{  
203.                     next_action[0] = DASH;//保存下一個動作，等待之前的動作完成   
204.                 }  
205.                 need_move[0] = 1;//需要移動   
206.             }  
207.         }  
208.         else if(count > 5 && can_use_next[0] == 0) {//如果在計數大於5時還沒有接收到按鍵輸入，並且可以使用下一個動作   
209.             status[0] = STANCE;//狀態改為站立   
210.             speed[0] = 1;  
211.             temp_key = 0;  
212.             count = 0;//計數清零www.linuxidc.com   
213.         }  
214.         if_need_move(0,count);//判斷是否需要移動   
215.         if(man_id == ICHIGO) ichigo(0);//使用黑崎一護的動作圖形   
216.         ichigo(1);  
217.         next_frames();//更新到下一個幀   
218.         write_to_fb(screen[0],screen[1],screen[2]);//顯示圖形   
219.         //usleep(10000);//之前用過usleep(30000)，犧牲幀的刷新速度，獲得按鍵響應效果的提升，我認為這不值   
220.         count++;//計數自增   
221.     }  
222.     //釋放背景圖占用的內存   
223.     free(game_map[0]);  
224.     free(game_map[1]);  
225.     free(game_map[2]);  
226.     free(game_map);  
227.     return 0;  
228. }  
229. int main()  
230. {  
231.     init_game();//初始化游戲，獲取屏幕尺寸，分配內存   
232.     game_boot();//顯示游戲啟動畫面   
233.     main_menu();//顯示游戲主菜單   
234.     system("stty echo");  
235.     return 0;  
236. }