很早以前用turbo c 2.0写的第一个游戏，今天看了下allegro 5的介绍，

在ubuntu上的code::blocks上自己编译了allegro5，重新写了这个小游戏，代码很短，就不写注释了。放在这里做备忘吧。

1. /* 
2. allegro5+c 
3. 2012/11/1 
4. ymc 
5. */ 
6.  
7. #include <stdio.h> 
8. #include <allegro5/allegro.h> 
9. #include <allegro5/allegro_primitives.h> 
10. #include <allegro5/allegro_native_dialog.h> 
11. #include <allegro5/allegro_font.h> 
12. #include <allegro5/allegro_ttf.h> 
13.  
14. #define MAX 8 
15. #define B_SIZE 100 
16. #define B_BORDER 20 
17. int N=4; 
18. int width; 
19. int height; 
20. int x_border=100; 
21. int y_border=100; 
22. const char *helptxt[3]={
    "Move:up,down,left,right","Flip:space,enter","Exit:Esc"}; 
23. bool redraw; 
24. bool doexit; 
25. bool win; 
26. bool map[MAX][MAX]; 
27. ALLEGRO_DISPLAY * display = NULL; 
28. ALLEGRO_EVENT_QUEUE *event_queue = NULL; 
29. ALLEGRO_FONT *font = NULL; 
30. ALLEGRO_DISPLAY_MODE disp_data; 
31. ALLEGRO_COLOR fd_color,bk_color,bd_color,cur_color; 
32. int cur_x,cur_y; 
33. int dir[4][2]={
    {1,0},{-1,0},{0,1},{0,-1}}; 
34. void data_init() 
35. { 
36.     if(N<MAX) 
37.         N++; 
38.     else 
39.         N=5; 
40.     for(int i=0;i<N;i++) 
41.         for(int j=0;j<N;j++) 
42.             map[i][j]=false; 
43. //    map[0][0]=map[1][0]=map[0][1]=false; 
44.  
45.     cur_x=cur_y=0; 
46.     redraw = false; 
47.     doexit = false; 
48.     win = false; 
49.     width = disp_data.width; 
50.     height = disp_data.height; 
51.     x_border = (width-N*B_SIZE-(N-1)*(B_BORDER))/2; 
52.     y_border = (height-N*B_SIZE-(N-1)*(B_BORDER))/2; 
53. } 
54. void game_init() 
55. { 
56.     al_init(); 
57.     al_init_primitives_addon(); 
58.     al_install_keyboard(); 
59.     al_init_font_addon(); 
60.     al_init_ttf_addon(); 
61.     //al_get_display_mode(al_get_num_display_modes() - 1, &disp_data); 
62.     font = al_load_ttf_font("FreeSerif.ttf",36,0 ); 
63.     al_get_display_mode(0, &disp_data); 
64.     al_set_new_display_flags(ALLEGRO_FULLSCREEN); 
65.     display = al_create_display(disp_data.width, disp_data.height); 
66.  
67.     event_queue = al_create_event_queue(); 
68.     al_register_event_source(event_queue, al_get_display_event_source(display)); 
69.     al_register_event_source(event_queue, al_get_keyboard_event_source()); 
70.  
71.     bk_color = al_map_rgb(220,220,220); 
72.     fd_color = al_map_rgb(255,255,255); 
73.     bd_color = al_map_rgb(100,100,100); 
74.     cur_color = al_map_rgb(0,0,255); 
75.     al_clear_to_color(bk_color); 
76.     data_init(); 
77. } 
78. void game_destroy() 
79. { 
80.     al_shutdown_primitives_addon(); 
81.     al_destroy_display(display); 
82.     al_destroy_event_queue(event_queue); 
83. } 
84. void drawblock(int i,int j,ALLEGRO_COLOR color,ALLEGRO_COLOR bdcolor) 
85. { 
86.     int x=x_border+i*(B_SIZE+B_BORDER); 
87.     int y=y_border+j*(B_SIZE+B_BORDER); 
88.     al_draw_filled_rectangle(x,y,x+B_SIZE,y+B_SIZE,color); 
89.     al_draw_rectangle(x,y,x+B_SIZE,y+B_SIZE, bdcolor,3); 
90. } 
91. void draw_block(int i,int j) 
92. { 
93.     ALLEGRO_COLOR color,bdcolor; 
94.     if(map[i][j]) 
95.         color=fd_color; 
96.     else 
97.         color=bk_color; 
98.     if(i == cur_x && j == cur_y) 
99.         bdcolor = cur_color; 
100.     else 
101.         bdcolor = bd_color; 
102.     drawblock(i,j,color,bdcolor); 
103. } 
104. void draw_screen() 
105. { 
106.     al_clear_to_color(bk_color); 
107.     for(int i=0;i<N;i++) 
108.         for(int j=0;j<N;j++) 
109.             draw_block(i,j); 
110.     al_draw_text(font, fd_color, x_border,y_border-8*B_BORDER,ALLEGRO_ALIGN_LEFT, helptxt[0]); 
111.     al_draw_text(font, fd_color, x_border,y_border-6*B_BORDER,ALLEGRO_ALIGN_LEFT, helptxt[1]); 
112.     al_draw_text(font, fd_color, x_border,y_border-4*B_BORDER,ALLEGRO_ALIGN_LEFT, helptxt[2]); 
113.     al_flip_display(); 
114. } 
115. void flip(int x,int y) 
116. { 
117.     int x1,y1; 
118.     map[x][y]=!map[x][y]; 
119.     for(int k=0;k<4;k++) 
120.     { 
121.         x1=x+dir[k][0]; 
122.         y1=y+dir[k][1]; 
123.         if(x1>=0 && x1<N && y1>=0 && y1<N) 
124.             map[x1][y1]=!map[x1][y1]; 
125.     } 
126. } 
127.  
128. bool check_game() 
129. { 
130.     for(int i=0;i<N;i++) 
131.         for(int j=0;j<N;j++) 
132.             if(map[i][j]==false) 
133.                 return false; 
134.     return true; 
135. } 
136.  
137. short m_box(const char* message       = "Well Done!Play game again?", 
138.             const char* content_title = "Congratulate", 
139.             const char* title         = "Win") 
140. { 
141.  
142.     switch(al_show_native_message_box(al_get_current_display(), 
143.                                      title, 
144.                                      content_title, 
145.                                      message, NULL, 
146.                                      ALLEGRO_MESSAGEBOX_YES_NO)) 
147.     { 
148.         case 0: return 0; // 
149.         case 1: return 1; //  ok or yes 
150.         case 2: return 2; // no or cancel 
151.     } 
152.     return 0; 
153. } 
154. int main() 
155. { 
156.     ALLEGRO_EVENT ev; 
157.     game_init(); 
158.     draw_screen(); 
159.     while(!doexit) 
160.     { 
161.          al_wait_for_event(event_queue,&ev); 
162.          if(ev.type == ALLEGRO_EVENT_KEY_DOWN) 
163.          { 
164.              switch(ev.keyboard.keycode) 
165.              { 
166.                  case ALLEGRO_KEY_UP: 
167.                     if(cur_y>0) 
168.                     { 
169.                         cur_y--; 
170.                         redraw=true; 
171.                     } 
172.                     break; 
173.                  case ALLEGRO_KEY_DOWN: 
174.                     if(cur_y<N-1) 
175.                     { 
176.                         cur_y++; 
177.                         redraw=true; 
178.                     } 
179.                     break; 
180.                  case ALLEGRO_KEY_LEFT: 
181.                     if(cur_x>0) 
182.                     { 
183.                         cur_x--; 
184.                          redraw=true; 
185.                     } 
186.                     break; 
187.                  case ALLEGRO_KEY_RIGHT: 
188.                     if(cur_x<N-1) 
189.                     { 
190.                         cur_x++; 
191.                          redraw=true; 
192.                     } 
193.                     break; 
194.                  case ALLEGRO_KEY_SPACE: 
195.                  case ALLEGRO_KEY_ENTER: 
196.                     flip(cur_x,cur_y); 
197.                     win = check_game(); 
198.                     redraw=true; 
199.                     break; 
200.                  case ALLEGRO_KEY_ESCAPE: 
201.                     doexit=true; 
202.                     break; 
203.              } 
204.          } 
205.         if(!doexit && redraw && al_is_event_queue_empty(event_queue)) 
206.         { 
207.              redraw = false; 
208.              draw_screen(); 
209.         } 
210.         if(win) 
211.         { 
212.             win=false; 
213.             switch(m_box()) 
214.             { 
215.                 case 2://no ,exit game 
216.                     doexit=true; 
217.                     break; 
218.                 case 1://yes,continue to play game 
219.                     data_init(); 
220.                     redraw=true; 
221.                     break; 
222.             } 
223.         } 
224.     } 
225.     game_destroy(); 
226.  
227.     return 0; 
228. }