游戏编程入门之Bomb Catcher游戏

首先是代码:

MyDirectX.h:

 #pragma once
 //header file
 #define WIN32_EXTRA_LEAN
 #define DIRECTINPUT_VERSION 0x0800
 #include<Windows.h>
 #include<d3d9.h>
 #include<d3dx9.h>
 #include<dinput.h>
 #include<xinput.h>
 #include<time.h>
 #include<iostream>
 #include<iomanip>
 #include<sstream>
 using namespace std;
 //libraries
 #pragma comment(lib,"winmm.lib")
 #pragma comment(lib,"user32.lib")
 #pragma comment(lib,"gdi32.lib")
 #pragma comment(lib,"dxguid.lib")
 #pragma comment(lib,"d3d9.lib")
 #pragma comment(lib,"d3dx9.lib")
 #pragma comment(lib,"dinput8.lib")
 #pragma comment(lib,"xinput.lib")
 //program values
 extern const string APPTITLE;
 extern const int SCREENW;
 extern const int SCREENH;
 extern bool gameover;
 //Direct3D objects
 extern LPDIRECT3D9 d3d;
 extern LPDIRECT3DDEVICE9 d3ddev;
 extern LPDIRECT3DSURFACE9 backbuffer;
 //Direct3D functions
 bool Direct3D_Init(HWND hwnd, int width, int height, bool fullscreen);
 void Direct3D_Shutdown();
 LPDIRECT3DSURFACE9 LoadSurface(string filename);
 void DrawSurface(LPDIRECT3DSURFACE9 dest, float x, float y, LPDIRECT3DSURFACE9 source);
 //DirectInput objects,devices,and states
 extern LPDIRECTINPUT8 dinput;
 extern LPDIRECTINPUTDEVICE8 dimouse;
 extern LPDIRECTINPUTDEVICE8 dikeyboard;
 extern DIMOUSESTATE mouse_state;
 extern XINPUT_GAMEPAD controllers[];
 //DirectInput functions
 bool DirectInput_Init(HWND);
 void DirectInput_Update();
 void DirectInput_Shutdown();
 int Key_Down(int);
 int Mouse_Button(int);
 int Mouse_X();
 int Mouse_Y();
 void XInput_Vibrate(int contNum = , int amount = );
 bool XInput_Controller_Found();
 //game functions
 bool Game_Init(HWND window);
 void Game_Run(HWND window);
 void Game_End();

MyDirectX.cpp:

 #include "MyDirectX.h"
 #include<iostream>
 using namespace std;
 //Direct3D variables
 LPDIRECT3D9 d3d = NULL;
 LPDIRECT3DDEVICE9 d3ddev = NULL;
 LPDIRECT3DSURFACE9 backbuffer = NULL;
 //DirectInput variables
 LPDIRECTINPUT8 dinput = NULL;
 LPDIRECTINPUTDEVICE8 dimouse = NULL;
 LPDIRECTINPUTDEVICE8 dikeyboard = NULL;
 DIMOUSESTATE mouse_state;
 char keys[];
 XINPUT_GAMEPAD controllers[];
 //Direct3D initiallization
 bool Direct3D_Init(HWND window, int width, int height, bool fullscreen)
 {
     //initialize Direct3D
     d3d = Direct3DCreate9(D3D_SDK_VERSION);
     if (!d3d) return false;
     //set Direct3D presentation parameters
     D3DPRESENT_PARAMETERS d3dpp;
     ZeroMemory(&d3dpp, sizeof(d3dpp));
     d3dpp.Windowed = (!fullscreen);
     d3dpp.SwapEffect = D3DSWAPEFFECT_COPY;
     d3dpp.BackBufferFormat = D3DFMT_X8R8G8B8;
     d3dpp.BackBufferCount = ;
     d3dpp.BackBufferWidth = width;
     d3dpp.BackBufferHeight = height;
     d3dpp.hDeviceWindow = window;
     //create Direct3D device
     d3d->CreateDevice(D3DADAPTER_DEFAULT, D3DDEVTYPE_HAL,window, D3DCREATE_SOFTWARE_VERTEXPROCESSING, &d3dpp, &d3ddev);
     if (!d3ddev) return false;
     //get a pointer to the back buffer surface
     d3ddev->GetBackBuffer(, , D3DBACKBUFFER_TYPE_MONO, &backbuffer);
     return true;
 }
 //Direct3D shutdown
 void Direct3D_Shutdown()
 {
     if (d3ddev) d3ddev->Release();
     if (d3d) d3d->Release();
 }
 //Draw a surface to the screen using StretchRect
 void DrawSurface(LPDIRECT3DSURFACE9 dest, float x, float y, LPDIRECT3DSURFACE9 source)
 {
     //get width/height from source surface
     D3DSURFACE_DESC desc;
     source->GetDesc(&desc);
     //create rects for drawing
     RECT source_rect = { ,,(long)desc.Width,(long)desc.Height };
     RECT dest_rect = { (long)x,(long)y,(long)x + desc.Width,(long)y + desc.Height };
     //draw the source surface onto the dest
     d3ddev->StretchRect(source, &source_rect, dest, &dest_rect, D3DTEXF_NONE);
 }
 //Loads a bitmap file into a surface
 LPDIRECT3DSURFACE9 LoadSurface(string filename)
 {
     LPDIRECT3DSURFACE9 image = NULL;
     //get width and height from bitmap file
     D3DXIMAGE_INFO info;
     HRESULT result = D3DXGetImageInfoFromFile(filename.c_str(), &info);
     if (result != D3D_OK) return NULL;
     //create surface
     result = d3ddev->CreateOffscreenPlainSurface(
         info.Width,                 //width of the surface
         info.Height,                //height of the surface
         D3DFMT_X8R8G8B8,            //surface format
         D3DPOOL_DEFAULT,            //memorypool to use
         & image,                    //pointer to the surface
         NULL);                      //reserved(always NULL)
     if (result != D3D_OK) return NULL;
     //Load surface from file into newly created surface
     result = D3DXLoadSurfaceFromFile(
         image,                      //destination surface
         NULL,                       //destination palette
         NULL,                       //destination rectangle
         filename.c_str(),           //source filename
         NULL,                       //source rectangle
         D3DX_DEFAULT,               //controls how image is filtered
         D3DCOLOR_XRGB(, , ),     //for transparency(0 for none)
         NULL);                      //source image info(usually NULL)
     //make sure file was loaded okay
     if (result != D3D_OK) return NULL;
     return image;
 }
 //DIrectInput initlization
 bool DirectInput_Init(HWND hwnd)
 {
     //initialize DirectInput object
     HRESULT result = DirectInput8Create(
         GetModuleHandle(NULL),
         DIRECTINPUT_VERSION,
         IID_IDirectInput8,
         (void**)&dinput,
         NULL);
     //initialize the keyboard
     dinput->CreateDevice(GUID_SysKeyboard, &dikeyboard, NULL);
     dikeyboard->SetDataFormat(&c_dfDIKeyboard);
     dikeyboard->SetCooperativeLevel(hwnd, DISCL_NONEXCLUSIVE | DISCL_FOREGROUND);
     dikeyboard->Acquire();
     //initialize the mouse
     dinput->CreateDevice(GUID_SysMouse, &dimouse, NULL);
     dimouse->SetDataFormat(&c_dfDIMouse);
     dimouse->SetCooperativeLevel(hwnd, DISCL_NONEXCLUSIVE | DISCL_FOREGROUND);
     dimouse->Acquire();
     d3ddev->ShowCursor(false);
     return true;
 }
 //DirectInput update
 void DirectInput_Update()
 {
     //update mouse
     dimouse->GetDeviceState(sizeof(mouse_state), (LPVOID)&mouse_state);
     //update keyboard
     dikeyboard->GetDeviceState(sizeof(keys), (LPVOID)&keys);
     //update controllers
     for (int i = ; i < ; i++)
     {
         ZeroMemory(&controllers[i], sizeof(XINPUT_STATE));
         //get the state of the controller
         XINPUT_STATE state;
         DWORD result = XInputGetState(i, &state);
         //store state in global controllers array
         if (result == ) controllers[i] = state.Gamepad;
     }
 }
 //Return mouse x movement
 int Mouse_X()
 {
     return mouse_state.lX;
 }
 //Return mouse y movement
 int Mouse_Y()
 {
     return mouse_state.lY;
 }
 //Return mouse button state
 int Mouse_Button(int button)
 {
     return mouse_state.rgbButtons[button] & 0x80;
 }
 //Return key press state
 int Key_Down(int key)
 {
     return (keys[key] & 0x80);
 }
 //DirectInput shutdown
 void DirectInput_Shutdown()
 {
     if (dikeyboard)
     {
         dikeyboard->Unacquire();
         dikeyboard->Release();
         dikeyboard = NULL;
     }
     if (dimouse)
     {
         dimouse->Unacquire();
         dimouse->Release();
         dimouse = NULL;
     }
 }
 //Return true if controller is plugged in
 bool XInput_Controller_Found()
 {
     XINPUT_CAPABILITIES caps;
     ZeroMemory(&caps, sizeof(XINPUT_CAPABILITIES));
     XInputGetCapabilities(, XINPUT_FLAG_GAMEPAD, &caps);
     if (caps.Type != ) return FALSE;

     return TRUE;
 }
 //Vibrates the controller
 void XInput_Vibrate(int contNum, int amount)
 {
     XINPUT_VIBRATION vibration;
     ZeroMemory(&vibration, sizeof(XINPUT_VIBRATION));
     vibration.wLeftMotorSpeed = amount;
     vibration.wRightMotorSpeed = amount;
     XInputSetState(contNum, &vibration);
 }

MyGame.cpp:

 #include "MyDirectX.h"
 const string APPTITLE = "Bomb Catcher Game";
 const int SCREENW = ;
 const int SCREENH = ;
 LPDIRECT3DSURFACE9 bomb_surf = NULL;
 LPDIRECT3DSURFACE9 bucket_surf = NULL;
 struct BOMB
 {
     float x, y;
     void reset()
     {
         x = (float)(rand() % (SCREENW - ));
         y = ;
     }
 };
 BOMB bomb;

 struct BUCKET
 {
     float x, y;
 };
 BUCKET bucket;
 int score = ;
 int vibrating = ;
 bool Game_Init(HWND window)
 {
     Direct3D_Init(window, SCREENW, SCREENH, false);
     DirectInput_Init(window);
     bomb_surf = LoadSurface("images/bomb.bmp");
     if (!bomb_surf) {
         MessageBox(window, "Error loadng bomb", "Error", );
         return false;
     }
     bucket_surf = LoadSurface("images/bucket.bmp");
     if (!bucket_surf) {
         MessageBox(window, "Error loadng bucket", "Error", );
         return false;
     }
     //get the back buffer surface
     d3ddev->GetBackBuffer(, , D3DBACKBUFFER_TYPE_MONO, &backbuffer);
     //position the bomb
     srand((unsigned int)time(NULL));
     bomb.reset();
     //psition the bucket
     bucket.x = ;
     bucket.y = ;
     return true;
 }
 void Game_Run(HWND window)
 {
     //make sure the Direct3D device is valid
     if (!d3ddev)return;
     //update input device
     DirectInput_Update();
     //move the bomb down the screen
     bomb.y += 2.0f;
     //see if bomb hit the floor
     if (bomb.y > SCREENH)
     {
         MessageBox(, "Oh,no, the bomb exploded!!", "YOU STINK", );
         gameover = true;
     }
     //move the bucket with the mouse
     int mx = Mouse_X();
     if (mx < )
         bucket.x -= 6.0f;
     else if (mx > )
         bucket.x += 6.0f;
     //move the bucket with the keyboard
     if (Key_Down(DIK_LEFT)) bucket.x -= 6.0f;
     else if (Key_Down(DIK_RIGHT)) bucket.x += 6.0f;
     //move the bucket with the controller
     if (XInput_Controller_Found())
     {
         //left analog thumb stick
         if (controllers[].sThumbLX < -)
             bucket.x -= 6.0f;
         else if (controllers[].sThumbLX > )
             bucket.x += 6.0f;
         //left and right triggers
         if (controllers[].bLeftTrigger > )
             bucket.x -= 6.0f;
         else if (controllers[].bRightTrigger > )
             bucket.x += 6.0f;
         //left and right D-PAD
         if (controllers[].wButtons&XINPUT_GAMEPAD_LEFT_SHOULDER)
             bucket.x -= 6.0f;
         else if (controllers[].wButtons&XINPUT_GAMEPAD_RIGHT_SHOULDER)
             bucket.x += 6.0f;
         //left and right shoulders
         if(controllers[].wButtons&XINPUT_GAMEPAD_DPAD_LEFT)
             bucket.x -= 6.0f;
         if (controllers[].wButtons&XINPUT_GAMEPAD_DPAD_RIGHT)
             bucket.x += 6.0f;
     }
     //update vibration
     if (vibrating > )
     {
         vibrating++;
         if (vibrating > )
         {
             XInput_Vibrate(, );
             vibrating = ;
         }
     }
     //keep bucket inside the screen
     if (bucket.x < ) bucket.x = ;
     if (bucket.x > SCREENW - ) bucket.x = SCREENW - ;
     //see if bucket caugth the bomb
     int cx = bomb.x + ;
     int cy = bomb.y + ;
     if (cx > bucket.x&&cx<bucket.x +  && cy>bucket.y&&cy < bucket.y + )
     {
         //update and display score
         score++;
         std::ostringstream os;
         os << APPTITLE << " [SCORE " << score << "]";
         string scoreStr = os.str();
         SetWindowText(window, scoreStr.c_str());
         //vibrate the controller
         XInput_Vibrate(, );
         vibrating = ;
         //restart bomb
         bomb.reset();
     }
     //clear the backbuffer
     d3ddev->ColorFill(backbuffer, NULL, D3DCOLOR_XRGB(, , ));
     //start rendering
     if (d3ddev->BeginScene())
     {
         //draw the bomb
         DrawSurface(backbuffer, bomb.x, bomb.y, bomb_surf);
         //draw the bucket
         DrawSurface(backbuffer, bucket.x, bucket.y, bucket_surf);
         //stop rendering
         d3ddev->EndScene();
         d3ddev->Present(NULL, NULL, NULL, NULL);
     }
     //escape key exits
     if (Key_Down(DIK_SPACE) || Key_Down(DIK_ESCAPE))
         gameover = true;
     //controller Back button also exits
     if (controllers[].wButtons&XINPUT_GAMEPAD_BACK)
         gameover = true;
 }
 void Game_End()
 {
     if (bomb_surf) bomb_surf->Release();
     if (bucket_surf) bucket_surf->Release();
     DirectInput_Shutdown();
     Direct3D_Shutdown();
 }

MyWindows.cpp:

 #include "MyDirectX.h"
 using namespace std;
 bool gameover = false;
 //Windows event handler
 LRESULT WINAPI WinProc(HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam)
 {
     switch (msg)
     {
     case WM_DESTROY:
         gameover = true;
         break;
     }
     return DefWindowProc(hWnd, msg, wParam, lParam);
 }
 //Windows entry point
 int WINAPI WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance, LPSTR lpCmdLine, int nCmdShow)
 {
     WNDCLASSEX wc;
     MSG msg;
     wc.cbSize = sizeof(WNDCLASSEX);
     wc.lpfnWndProc = (WNDPROC)WinProc;
     wc.style = ;
     wc.cbClsExtra = ;
     wc.cbWndExtra = ;
     wc.hIcon = NULL;
     wc.hIconSm = NULL;
     wc.hInstance = hInstance;
     wc.lpszMenuName = NULL;
     wc.hCursor = LoadCursor(NULL, IDC_ARROW);
     wc.hbrBackground = (HBRUSH)GetStockObject(WHITE_BRUSH);
     wc.lpszClassName = "MainWindowClass";
     if (!RegisterClassEx(&wc))
         return FALSE;
     HWND window = CreateWindow("MainWindowClass", APPTITLE.c_str(), WS_OVERLAPPEDWINDOW, CW_USEDEFAULT, CW_USEDEFAULT, SCREENW, SCREENH, (HWND)NULL, (HMENU)NULL,
         hInstance, (LPVOID)NULL);
     if (window == )
         return ;
     ShowWindow(window, nCmdShow);
     UpdateWindow(window);
     if (!Game_Init(window))
         return ;
     while (!gameover)
     {
         if (PeekMessage(&msg, NULL, , , PM_REMOVE))
         {
             TranslateMessage(&msg);
             DispatchMessage(&msg);
         }
         Game_Run(window);
     }
     Game_End();
     return msg.wParam;
 }

结果: