Windows 游戏编程大师技巧第四章第9个例子

1. // DEMO4_9.CPP - Starfield demo based on T3D console
3. // INCLUDES ///
4. #define WIN32_LEAN_AND_MEAN  // just say no to MFC
6. #include <windows.h>   // include important windows stuff
7. #include <windowsx.h> 
8. #include <mmsystem.h>
9. #include <iostream.h> // include important C/C++ stuff
10. #include <conio.h>
11. #include <stdlib.h>
12. #include <malloc.h>
13. #include <memory.h>
14. #include <string.h>
15. #include <stdarg.h>
16. #include <stdio.h> 
17. #include <math.h>
18. #include <io.h>
19. #include <fcntl.h>
21. // DEFINES 
23. // defines for windows 
24. #define WINDOW_CLASS_NAME "WINCLASS1"
25. #define WINDOW_WIDTH      400
26. #define WINDOW_HEIGHT     300
28. // starfield defines
29. #define NUM_STARS            256
31. // MACROS /
33. #define KEYDOWN(vk_code) ((GetAsyncKeyState(vk_code) & 0x8000) ? 1 : 0)
34. #define KEYUP(vk_code)   ((GetAsyncKeyState(vk_code) & 0x8000) ? 0 : 1)
36. // TYPES //
38. typedef struct STAR_TYP
39.         {
40.         int x,y;        // position of star
41.         int vel;        // horizontal velocity of star
42.         COLORREF col;   // color of star
43.         } STAR, *STAR_PTR;
45. // PROTOTYPES /
47. void Erase_Stars(void);
48. void Draw_Stars(void);
49. void Move_Stars(void);
50. void Init_Stars(void);
52. // GLOBALS 
54. HWND      main_window_handle = NULL; // globally track main window
55. HINSTANCE hinstance_app      = NULL; // globally track hinstance
57. HDC       global_dc          = NULL; // tracks a global dc
59. char buffer[80];                     // general printing buffer
61. STAR stars[256];                     // holds the starfield
63. // FUNCTIONS //
64. LRESULT CALLBACK WindowProc(HWND hwnd, 
65.                             UINT msg, 
66.                             WPARAM wparam, 
67.                             LPARAM lparam)
68. {
69. // this is the main message handler of the system
70. PAINTSTRUCT     ps;     // used in WM_PAINT
71. HDC             hdc;    // handle to a device context
72. char buffer[80];        // used to print strings
74. // what is the message 
75. switch(msg)
76.     {   
77.     case WM_CREATE: 
78.         {
79.         // do initialization stuff here
80.         // return success
81.         return(0);
82.         } break;
83.    
84.     case WM_PAINT: 
85.         {
86.         // simply validate the window 
87.         hdc = BeginPaint(hwnd,&ps);  
88.         
89.         // end painting
90.         EndPaint(hwnd,&ps);
92.         // return success
93.         return(0);
94.         } break;
96.     case WM_DESTROY: 
97.         {
99.         // kill the application, this sends a WM_QUIT message 
100.         PostQuitMessage(0);
102.         // return success
103.         return(0);
104.         } break;
106.     default:break;
108.     } // end switch
110. // process any messages that we didn't take care of 
111. return (DefWindowProc(hwnd, msg, wparam, lparam));
113. } // end WinProc
115. ///
117. void Init_Stars(void)
118. {
119. // this function initializes all the stars
121. for (int index=0; index < NUM_STARS; index++)
122.     {
123.     // select random position
124.     stars[index].x = rand()%WINDOW_WIDTH;
125.     stars[index].y = rand()%WINDOW_HEIGHT;
127.     // set random velocity   
128.     stars[index].vel = 1 + rand()%16;
130.     // set intensity which is inversely prop to velocity for 3D effect
131.     // note, I am mixing equal amounts of RGB to make black -> bright white    
132.     int intensity = 15*(17 - stars[index].vel);
133.     stars[index].col = RGB(intensity, intensity, intensity); 
135.     } // end for index
137. } // end Init_Stars
141. void Erase_Stars(void)
142. {
143. // this function erases all the stars
144. for (int index=0; index < NUM_STARS; index++)
145.     SetPixel(global_dc, stars[index].x, stars[index].y, RGB(0,0,0));
147. } // end Erase_Stars
151. void Draw_Stars()
152. {
153. // this function draws all the stars
154. for (int index=0; index < NUM_STARS; index++)
155.     SetPixel(global_dc, stars[index].x, stars[index].y, stars[index].col);
158. } // end Draw_Stars
162. void Move_Stars(void)
163. {
164. // this function moves all the stars and wraps them around the 
165. // screen boundaries
166. for (int index=0; index < NUM_STARS; index++)
167.     {
168.     // move the star and test for edge
169.     stars[index].x+=stars[index].vel;
171.     if (stars[index].x >= WINDOW_WIDTH)
172.         stars[index].x -= WINDOW_WIDTH;
173.     
174.     } // end for index
176. } // end Move_Stars
180. int Game_Main(void *parms = NULL, int num_parms = 0)
181. {
182. // this is the main loop of the game, do all your processing
183. // here
185. // get the time
186. DWORD start_time = GetTickCount();
188. // erase the stars
189. Erase_Stars();
191. // move the stars
192. Move_Stars();
194. // draw the stars
195. Draw_Stars();
197. // lock to 30 fps
198. while((start_time - GetTickCount() < 33));
200. // for now test if user is hitting ESC and send WM_CLOSE
201. if (KEYDOWN(VK_ESCAPE))
202.    SendMessage(main_window_handle,WM_CLOSE,0,0);
204. // return success or failure or your own return code here
205. return(1);
207. } // end Game_Main
211. int Game_Init(void *parms = NULL, int num_parms = 0)
212. {
213. // this is called once after the initial window is created and
214. // before the main event loop is entered, do all your initialization
215. // here
217. // first get the dc to the window
218. global_dc = GetDC(main_window_handle);
220. // initialize the star field here
221. Init_Stars();
223. // return success or failure or your own return code here
224. return(1);
226. } // end Game_Init
228. /
230. int Game_Shutdown(void *parms = NULL, int num_parms = 0)
231. {
232. // this is called after the game is exited and the main event
233. // loop while is exited, do all you cleanup and shutdown here
235. // release the global dc
236. ReleaseDC(main_window_handle, global_dc);
238. // return success or failure or your own return code here
239. return(1);
241. } // end Game_Shutdown
243. // WINMAIN 
244. int WINAPI WinMain( HINSTANCE hinstance,
245.                     HINSTANCE hprevinstance,
246.                     LPSTR lpcmdline,
247.                     int ncmdshow)
248. {
250. WNDCLASSEX winclass; // this will hold the class we create
251. HWND       hwnd;     // generic window handle
252. MSG        msg;      // generic message
253. HDC        hdc;      // graphics device context
255. // first fill in the window class stucture
256. winclass.cbSize         = sizeof(WNDCLASSEX);
257. winclass.style          = CS_DBLCLKS | CS_OWNDC | 
258.                           CS_HREDRAW | CS_VREDRAW;
259. winclass.lpfnWndProc    = WindowProc;
260. winclass.cbClsExtra     = 0;
261. winclass.cbWndExtra     = 0;
262. winclass.hInstance      = hinstance;
263. winclass.hIcon          = LoadIcon(NULL, IDI_APPLICATION);
264. winclass.hCursor        = LoadCursor(NULL, IDC_ARROW); 
265. winclass.hbrBackground  = (HBRUSH)GetStockObject(BLACK_BRUSH);
266. winclass.lpszMenuName   = NULL;
267. winclass.lpszClassName  = WINDOW_CLASS_NAME;
268. winclass.hIconSm        = LoadIcon(NULL, IDI_APPLICATION);
270. // save hinstance in global
271. hinstance_app = hinstance;
273. // register the window class
274. if (!RegisterClassEx(&winclass))
275.     return(0);
277. // create the window
278. if (!(hwnd = CreateWindowEx(NULL,                  // extended style
279.                             WINDOW_CLASS_NAME,     // class
280.                             "T3D Game Console Star Demo", // title
281.                             WS_OVERLAPPEDWINDOW | WS_VISIBLE,
282.                             0,0,      // initial x,y
283.                             400,300,  // initial width, height
284.                             NULL,     // handle to parent 
285.                             NULL,     // handle to menu
286.                             hinstance,// instance of this application
287.                             NULL))) // extra creation parms
288. return(0);
290. // save main window handle
291. main_window_handle = hwnd;
293. // initialize game here
294. Game_Init();
296. // enter main event loop
297. while(TRUE)
298.     {
299.     // test if there is a message in queue, if so get it
300.     if (PeekMessage(&msg,NULL,0,0,PM_REMOVE))
301.        { 
302.        // test if this is a quit
303.        if (msg.message == WM_QUIT)
304.            break;
305.     
306.        // translate any accelerator keys
307.        TranslateMessage(&msg);
309.        // send the message to the window proc
310.        DispatchMessage(&msg);
311.        } // end if
312.     
313.        // main game processing goes here
314.        Game_Main();
315.        
316.     } // end while
318. // closedown game here
319. Game_Shutdown();
321. // return to Windows like this
322. return(msg.wParam);
324. } // end WinMain
326. ///

 

 

终于看见,类似游戏的界面了.令我激动不已.