jQuery火箭图标返回顶部代码

在进行以下内容前我们需先做好准备，明白都要做什么

(1)编写碰撞函数(此时的函数不是完整的下面会对其修改):

   我们首先需要创建两个矩形并且调用IntersetRect函数来检查他们是否碰撞的函数。这个函数名为Collision，可重用性很好哦。

int  Collision(SPRITE sprite1, SPRITE sprite2)
{
    RECT rect1;
    rect1.left = sprite1.x;
    rect1.top = sprite1.y;
    rect1.right = sprite1.x + sprite1.width;
    rect1.bottom = sprite1.y + sprite1.height;

    RECT rect2;
    rect2.left = sprite2.x;
    rect2.top = sprite2.y;
    rect2.right = sprite2.x + sprite2.width;
    rect2.bottom = sprite2.y + sprite2.height;

    RECT dest;  //ignored
    return IntersectRect(&dest, &rect1, &rect2);
}

建议:你将注意到在collision函数上有编译器警告信息，因为SPRITE.x和SPRITE.y属性是浮点数，而RECT属性是长整型。要想去除这些警告，可将精灵属性轻质住阿奴按成

long。

(2)新的精灵结构:

struct SPRITE {
    float x, y;
    int frame, columns;
    int width, height;
    float scaling, rotation;
    int startframe, endframe;
    int starttime, delay;
    int direction;
    float velx, vely;
    D3DCOLOR color;
    SPRITE()
    {
        frame = 0;
        columns = 1;
        width = height = 0;
        scaling = 1.0f;
        rotation = 0.0f;
        startframe = endframe = 0;
        direction = 1;
        starttime = delay = 0;
        velx = vely = 0.0f;
        color = D3DCOLOR_XRGB(255, 255, 255);
    }
};

(3)为精灵的缩放进行调整:

int  Collision(SPRITE sprite1, SPRITE sprite2)
{
    RECT rect1;
    rect1.left = (long)sprite1.x;
    rect1.top = (long)sprite1.y;
    rect1.right = (long)sprite1.x + sprite1.width + sprite1.scaling;
    rect1.bottom = (long)sprite1.y + sprite1.height + sprite1.scaling;

    RECT rect2;
    rect2.left = (long)sprite2.x;
    rect2.top = (long)sprite2.y;
    rect2.right = (long)sprite2.x + sprite2.width + sprite2.scaling;
    rect2.bottom = (long)sprite2.y + sprite2.height + sprite2.scaling;

    RECT dest;  //ignored
    return IntersectRect(&dest, &rect1, &rect2);
}

OK,到这里准备工作已完成(其实只是对MyDirectX.h和MyDirectX.cpp两个代码块进行了添加操作，其他的无变化哦)，示例代码如下:

MyDirectX.h:

#pragma once
//header files
#define WIN32_EXTRA_LEAN
#define DIRECTINPUT_VERSION 0x0800
#include <windows.h>
#include <d3d9.h>
#include <d3dx9.h>
#include <dinput.h>
#include <xinput.h>
#include <ctime>
#include <iostream>
#include <iomanip>
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;

//macro to detect key presses
#define KEY_DOWN(vk_code) ((GetAsyncKeyState(vk_code) & 0x8000) ? 1 : 0)

//Direct3D objects
extern LPDIRECT3D9 d3d;
extern LPDIRECT3DDEVICE9 d3ddev;
extern LPDIRECT3DSURFACE9 backbuffer;
extern LPD3DXSPRITE spriteobj;

//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);
D3DXVECTOR2 GetBitmapSize(string filename);
LPDIRECT3DTEXTURE9 LoadTexture(string filename, D3DCOLOR transcolor = D3DCOLOR_XRGB(0, 0, 0));
void Sprite_Draw_Frame(LPDIRECT3DTEXTURE9 texture, int destx, int desty, int framenum, int framew, int frameh, int columns);
void Sprite_Animate(int &frame, int startframe, int endframe, int direction, int &starttime, int delay);
void Sprite_Transform_Draw(LPDIRECT3DTEXTURE9 image, int x, int y, int width, int height, int frame = 0, int columns = 1,
                            float rotation = 0.0f, float scaling = 1.0f, D3DCOLOR color = D3DCOLOR_XRGB(255, 255, 255));

//DirectInput objects, devices, and states
extern LPDIRECTINPUT8 dinput;
extern LPDIRECTINPUTDEVICE8 dimouse;
extern LPDIRECTINPUTDEVICE8 dikeyboard;
extern DIMOUSESTATE mouse_state;
extern XINPUT_GAMEPAD controllers[4];

//DirectInput functions
bool DirectInput_Init(HWND);
void DirectInput_Update();
void DirectInput_Shutdown();
bool Key_Down(int);
int Mouse_Button(int);
int Mouse_X();
int Mouse_Y();
void XInput_Vibrate(int contNum = 0, int amount = 65535);
bool XInput_Controller_Found();

//game functions
bool Game_Init(HWND window);
void Game_Run(HWND window);
void Game_End();

//sprite structure
struct SPRITE {
    float x, y;
    int frame, columns;
    int width, height;
    float scaling, rotation;
    int startframe, endframe;
    int starttime, delay;
    int direction;
    float velx, vely;
    D3DCOLOR color;
    SPRITE()
    {
        frame = 0;
        columns = 1;
        width = height = 0;
        scaling = 1.0f;
        rotation = 0.0f;
        startframe = endframe = 0;
        direction = 1;
        starttime = delay = 0;
        velx = vely = 0.0f;
        color = D3DCOLOR_XRGB(255, 255, 255);
    }
};
//bouding box collision detection
int  Collision(SPRITE sprite1, SPRITE sprite2);

MyDirectX.cpp:

#include "MyDirectX.h"
#include <iostream>
using namespace std;

//Direct3D variables
LPDIRECT3D9 d3d = NULL;
LPDIRECT3DDEVICE9 d3ddev = NULL;
LPDIRECT3DSURFACE9 backbuffer = NULL;
LPD3DXSPRITE spriteobj;

//DirectInput variables
LPDIRECTINPUT8 dinput = NULL;
LPDIRECTINPUTDEVICE8 dimouse = NULL;
LPDIRECTINPUTDEVICE8 dikeyboard = NULL;
DIMOUSESTATE mouse_state;
char keys[256];
XINPUT_GAMEPAD controllers[4];


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.hDeviceWindow = window;
    d3dpp.Windowed = (!fullscreen);
    d3dpp.SwapEffect = D3DSWAPEFFECT_DISCARD;
    d3dpp.EnableAutoDepthStencil = 1;
    d3dpp.AutoDepthStencilFormat = D3DFMT_D24S8;
    d3dpp.Flags = D3DPRESENTFLAG_DISCARD_DEPTHSTENCIL;
    d3dpp.PresentationInterval = D3DPRESENT_INTERVAL_IMMEDIATE;
    d3dpp.BackBufferFormat = D3DFMT_X8R8G8B8;
    d3dpp.BackBufferCount = 1;
    d3dpp.BackBufferWidth = width;
    d3dpp.BackBufferHeight = height;

    //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(0, 0, D3DBACKBUFFER_TYPE_MONO, &backbuffer);

    //create sprite object
    D3DXCreateSprite(d3ddev, &spriteobj);

    return 1;
}

void Direct3D_Shutdown()
{
    if (spriteobj) spriteobj->Release();

    if (d3ddev) d3ddev->Release();
    if (d3d) d3d->Release();
}

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 = { 0, 0, (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);

}

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,    //memory pool 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(0, 0, 0),   //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;
}


D3DXVECTOR2 GetBitmapSize(string filename)
{
    D3DXIMAGE_INFO info;
    D3DXVECTOR2 size = D3DXVECTOR2(0.0f, 0.0f);

    HRESULT result = D3DXGetImageInfoFromFile(filename.c_str(), &info);

    if (result == D3D_OK)
        size = D3DXVECTOR2((float)info.Width, (float)info.Height);
    else
        size = D3DXVECTOR2((float)info.Width, (float)info.Height);

    return size;
}

LPDIRECT3DTEXTURE9 LoadTexture(std::string filename, D3DCOLOR transcolor)
{
    LPDIRECT3DTEXTURE9 texture = 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 the new texture by loading a bitmap image file
    D3DXCreateTextureFromFileEx(
        d3ddev,                //Direct3D device object
        filename.c_str(),      //bitmap filename
        info.Width,            //bitmap image width
        info.Height,           //bitmap image height
        1,                     //mip-map levels (1 for no chain)
        D3DPOOL_DEFAULT,       //the type of surface (standard)
        D3DFMT_UNKNOWN,        //surface format (default)
        D3DPOOL_DEFAULT,       //memory class for the texture
        D3DX_DEFAULT,          //image filter
        D3DX_DEFAULT,          //mip filter
        transcolor,            //color key for transparency
        &info,                 //bitmap file info (from loaded file)
        NULL,                  //color palette
        &texture);            //destination texture

                              //make sure the bitmap textre was loaded correctly
    if (result != D3D_OK) return NULL;

    return texture;
}


bool DirectInput_Init(HWND hwnd)
{
    //initialize DirectInput object
    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;
}

void DirectInput_Update()
{
    //update mouse
    dimouse->Poll();
    if (!SUCCEEDED(dimouse->GetDeviceState(sizeof(DIMOUSESTATE), &mouse_state)))
    {
        //mouse device lose, try to re-acquire
        dimouse->Acquire();
    }

    //update keyboard
    dikeyboard->Poll();
    if (!SUCCEEDED(dikeyboard->GetDeviceState(256, (LPVOID)&keys)))
    {
        //keyboard device lost, try to re-acquire
        dikeyboard->Acquire();
    }

    //update controllers
    for (int i = 0; i< 4; 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 == 0) controllers[i] = state.Gamepad;
    }
}


int Mouse_X()
{
    return mouse_state.lX;
}

int Mouse_Y()
{
    return mouse_state.lY;
}

int Mouse_Button(int button)
{
    return mouse_state.rgbButtons[button] & 0x80;
}

bool Key_Down(int key)
{
    return (bool)(keys[key] & 0x80);
}


void DirectInput_Shutdown()
{
    if (dikeyboard)
    {
        dikeyboard->Unacquire();
        dikeyboard->Release();
        dikeyboard = NULL;
    }
    if (dimouse)
    {
        dimouse->Unacquire();
        dimouse->Release();
        dimouse = NULL;
    }
}

bool XInput_Controller_Found()
{
    XINPUT_CAPABILITIES caps;
    ZeroMemory(&caps, sizeof(XINPUT_CAPABILITIES));
    XInputGetCapabilities(0, XINPUT_FLAG_GAMEPAD, &caps);
    if (caps.Type != 0) return false;

    return true;
}

void XInput_Vibrate(int contNum, int amount)
{
    XINPUT_VIBRATION vibration;
    ZeroMemory(&vibration, sizeof(XINPUT_VIBRATION));
    vibration.wLeftMotorSpeed = amount;
    vibration.wRightMotorSpeed = amount;
    XInputSetState(contNum, &vibration);
}
void Sprite_Draw_Frame(LPDIRECT3DTEXTURE9 texture, int destx, int desty, int framenum, int framew, int frameh, int columns)
{
    D3DXVECTOR3 position((float)destx, (float)desty, 0);
    D3DCOLOR white = D3DCOLOR_XRGB(255, 255, 255);

    RECT rect;
    rect.left = (framenum % columns) * framew;
    rect.top = (framenum / columns) * frameh;
    rect.right = rect.left + framew;
    rect.bottom = rect.top + frameh;

    spriteobj->Draw(texture, &rect, NULL, &position, white);
}

void Sprite_Animate(int &frame, int startframe, int endframe, int direction, int &starttime, int delay)
{
    if ((int)GetTickCount() > starttime + delay)
    {
        starttime = GetTickCount();

        frame += direction;
        if (frame > endframe) frame = startframe;
        if (frame < startframe) frame = endframe;
    }
}
void Sprite_Transform_Draw(LPDIRECT3DTEXTURE9 image, int x, int y, int width, int height, int frame, int columns, float rotation, float scaling, D3DCOLOR color)
{
    //create a scale vector
    D3DXVECTOR2 scale(scaling, scaling);
    //create a translate vector
    D3DXVECTOR2 trans(x, y);
    //set center by dividing width and height by two
    D3DXVECTOR2 center((float)(width * scaling) / 2, (float)(height * scaling) / 2);
    //create 2D transformation matrix
    D3DXMATRIX mat;
    D3DXMatrixTransformation2D(&mat, NULL, 0, &scale, &center, rotation, &trans);

    //tell sprite object to use the transform
    spriteobj->SetTransform(&mat);
    //calculate frame location in source image
    int fx = (frame % columns) * width;
    int fy = (frame / columns) * height;
    RECT srcRect = { fx, fy, fx + width, fy + height };
    //draw the sprite frame
    spriteobj->Draw(image, &srcRect, NULL, NULL, color);
}

//bouding box collision detection
int  Collision(SPRITE sprite1, SPRITE sprite2)
{
    RECT rect1;
    rect1.left = (long)sprite1.x;
    rect1.top = (long)sprite1.y;
    rect1.right = (long)sprite1.x + sprite1.width + sprite1.scaling;
    rect1.bottom = (long)sprite1.y + sprite1.height + sprite1.scaling;

    RECT rect2;
    rect2.left = (long)sprite2.x;
    rect2.top = (long)sprite2.y;
    rect2.right = (long)sprite2.x + sprite2.width + sprite2.scaling;
    rect2.bottom = (long)sprite2.y + sprite2.height + sprite2.scaling;

    RECT dest;  //ignored
    return IntersectRect(&dest, &rect1, &rect2);
}

MyGame.cpp:

#include "MyDirectX.h"

const string APPTITLE = "Bounding Box Demo";
const int SCREENW = 1024;
const int SCREENH = 768;
SPRITE ship, asteroid1, asteroid2;
LPDIRECT3DTEXTURE9 imgShip = NULL;
LPDIRECT3DTEXTURE9 imgAsteroid = NULL;

bool Game_Init(HWND window)
{
    //initialize Direct3D
    if (!Direct3D_Init(window, SCREENW, SCREENH, false))
    {
        MessageBox(0, "Error initializing Direct3D", "ERROR", 0);
        return false;
    }

    //initialize DirectInput
    if (!DirectInput_Init(window))
    {
        MessageBox(0, "Error initializing DirectInput", "ERROR", 0);
        return false;
    }
    //load the sprite texture
    imgShip = LoadTexture("fatship.tga");
    if (!imgShip) return false;
    imgAsteroid = LoadTexture("asteroid.tga");
    if (!imgAsteroid) return false;

    //set properties for sprites
    ship.x = 450;
    ship.y = 300;
    ship.width = ship.height = 128;

    asteroid1.x = 50;
    asteroid1.y = 200;
    asteroid1.width = asteroid1.height = 60;
    asteroid1.columns = 8;
    asteroid1.startframe = 0;
    asteroid1.endframe = 63;
    asteroid1.velx = -2.0f;

    asteroid2.x = 900;
    asteroid2.y = 500;
    asteroid2.width = asteroid2.height = 60;
    asteroid2.columns = 8;
    asteroid2.startframe = 0;
    asteroid2.endframe = 63;
    asteroid2.velx = 2.0f;
    
    return true;
}

void Game_Run(HWND window)
{
    //make sure the Direct3D device is valid
    if (!d3ddev) return;

    //update input devices
    DirectInput_Update();

    //clear the scene
    d3ddev->Clear(0, NULL, D3DCLEAR_TARGET | D3DCLEAR_ZBUFFER, D3DCOLOR_XRGB(0, 0, 100), 1.0f, 0);

    //move the ship up/down with arrow keys
    if (Key_Down(DIK_UP))
    {
        ship.y -= 1.0f;
        if (ship.y < 0)
            ship.y = 0;
    }
    if (Key_Down(DIK_DOWN))
    {
        ship.y += 1.0f;
        if (ship.y > SCREENH - ship.height)
            ship.y = SCREENH - ship.height;
    }
    
    //move and animate the asteroids
    asteroid1.x += asteroid1.velx;
    if (asteroid1.x<0 || asteroid1.x>SCREENW - asteroid1.width)
        asteroid1.velx *= -1;
    Sprite_Animate(asteroid1.frame, asteroid1.startframe, asteroid1.endframe, asteroid1.direction, asteroid1.starttime, asteroid1.delay);

    asteroid2.x += asteroid2.velx;
    if (asteroid2.x<0 || asteroid2.x>SCREENW - asteroid2.width)
        asteroid2.velx *= -1;
    Sprite_Animate(asteroid2.frame, asteroid2.startframe, asteroid2.endframe, asteroid2.direction, asteroid2.starttime, asteroid2.delay);

    //test for collisions
    if (Collision(ship, asteroid1))
        asteroid1.velx *= -1;
    if (Collision(ship, asteroid2))
        asteroid2.velx *= -1;

    //start rendering
    if (d3ddev->BeginScene())
    {
        //begin sprite rendering
        spriteobj->Begin(D3DXSPRITE_ALPHABLEND);
        Sprite_Transform_Draw(imgShip, ship.x, ship.y, ship.width, ship.height, ship.frame, ship.columns);
        Sprite_Transform_Draw(imgAsteroid, asteroid1.x, asteroid1.y, asteroid1.width, asteroid1.height, asteroid1.frame, asteroid1.columns);
        Sprite_Transform_Draw(imgAsteroid, asteroid2.x, asteroid2.y, asteroid2.width, asteroid2.height, asteroid2.frame, asteroid2.columns);

        //stop sprite rendering
        spriteobj->End();
        //stop rendering
        d3ddev->EndScene();
        d3ddev->Present(NULL, NULL, NULL, NULL);
    }

    //Escape key ends program
    if (KEY_DOWN(VK_ESCAPE)) gameover = true;

    //controller Back button also ends
    if (controllers[0].wButtons & XINPUT_GAMEPAD_BACK)
        gameover = true;
}

void Game_End()
{
    //free memory and shut down
    if (imgShip) imgShip->Release();
    if (imgAsteroid) imgAsteroid->Release();

    DirectInput_Shutdown();
    Direct3D_Shutdown();
}

MyWindows.cpp:

#include "MyDirectX.h"
using namespace std;
bool gameover = false;


LRESULT WINAPI WinProc(HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam)
{
    switch (msg)
    {
    case WM_DESTROY:
        gameover = true;
        PostQuitMessage(0);
        return 0;
    }
    return DefWindowProc(hWnd, msg, wParam, lParam);
}


int WINAPI WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance, LPSTR lpCmdLine, int nCmdShow)
{
    //initialize window settings
    WNDCLASSEX wc;
    wc.cbSize = sizeof(WNDCLASSEX);
    wc.style = CS_HREDRAW | CS_VREDRAW;
    wc.lpfnWndProc = (WNDPROC)WinProc;
    wc.cbClsExtra = 0;
    wc.cbWndExtra = 0;
    wc.hInstance = hInstance;
    wc.hIcon = NULL;
    wc.hCursor = LoadCursor(NULL, IDC_ARROW);
    wc.hbrBackground = (HBRUSH)GetStockObject(WHITE_BRUSH);
    wc.lpszMenuName = NULL;
    wc.lpszClassName = APPTITLE.c_str();
    wc.hIconSm = NULL;
    RegisterClassEx(&wc);

    //create a new window
    HWND window = CreateWindow(APPTITLE.c_str(), APPTITLE.c_str(),
        WS_OVERLAPPEDWINDOW, CW_USEDEFAULT, CW_USEDEFAULT,
        SCREENW, SCREENH, NULL, NULL, hInstance, NULL);
    if (window == 0) return 0;

    //display the window
    ShowWindow(window, nCmdShow);
    UpdateWindow(window);

    //initialize the game
    if (!Game_Init(window)) return 0;

    // main message loop
    MSG message;
    while (!gameover)
    {
        if (PeekMessage(&message, NULL, 0, 0, PM_REMOVE))
        {
            TranslateMessage(&message);
            DispatchMessage(&message);
        }

        //process game loop 
        Game_Run(window);
    }

    //shutdown
    Game_End();
    return message.wParam;
}

结果:

       当然了，边界碰撞检测产生相当精确的碰撞结果，而且非常快速。但是有些情况下这种方法不能很好的适应，比如使用带有圆角的美工作品或非常复杂的形状(比如带有突出机翼的飞机)。

在非常情况下，具有另外一种检测碰撞的方法僵尸有好处的，而在这种情况下我们可以使用级与距离的碰撞算法。

       在使用距离确定两个精灵是否碰撞时，我们必须要做的是计算每个精灵中心点，计算精灵的半径(从中心点到边缘)，然后检查两个中心点之间的距离。如果这个距离少于两个半径的

和，那么就可以确定两个精灵有重叠。为什么呢？每个精灵的半径加起来必须小于两个精灵之间的距离。

(1)计算距离:

  要计算任意两点之间的距离，我们只需参考经典的数学距离公式即可。通过将两点作为直角三角形两条边的顶点，任意两点都可转换成直角三角形。取得每个点的X和

Y的delta值(差值)，将每个delta值平方然后相加，然后求其平方根，就是两点间的距离。如下图：

delta_x = x1 - x2

delta_y = y1 - y2

distance = square root ((delta_x * delta_x) + (delta_y * delta_y))

(2)编写距离计算的代码:

  我们可以把这些内容编写到函数中，它使用两个精灵作为参数并从精灵的属性计算出delta值和距离。缩放因子也必须考虑在内，就如在边界框碰撞检测中所作的一样。

此外，精灵的最大尺寸(不是宽度就是高度)将用于计算半径。我们首先计算第一个精灵的半径。

 if (sprite1.width > sprite1.height)
    radius1 = (sprite1.width * sprite1.scaling) / 2.0;
 else
    radius1 = (sprite1.height * sprite1.scaling) / 2.0;

       有了半径之后，在计算第一个精灵的中心点。我将把中心值存储存在的向量中。

double x1 = sprite1.x + radius1;
double y1 = sprite1.y + radius1;
D3DXVECTOR2 vector1(x1, y1);

   这个名为vector1的向量包含了第一个精灵的中心点，无论他是否为与屏幕上。经相同的代码复制给第二个精灵，我们就会得到两个精灵的中心点和半径。一旦有了这

些值，就可以开始进行距离计算了。首先涉及的是计算X和Y的delta值。

 double deltax = vector1.x - vector2.x;
 double deltay = vector2.y - vector1.y;

   有了这些delta值之后计算距离那就是非常容易的事情了。

double dist = sqrt((deltax * deltax) + (deltay * deltay));

   我们将此编写到一个可重用的函数中。我将这个命名为CollisionD以便与边界框(Collision)区分开

bool CollisionD(SPRITE sprite1, SPRITE sprite2)
{
    double radius1, radius2;

    //calculate radius 1
    if (sprite1.width > sprite1.height)
        radius1 = (sprite1.width * sprite1.scaling) / 2.0;
    else
        radius1 = (sprite1.height * sprite1.scaling) / 2.0;

    //center point 1
    double x1 = sprite1.x + radius1;
    double y1 = sprite1.y + radius1;
    D3DXVECTOR2 vector1(x1, y1);

    //calculate radius 2
    if (sprite2.width > sprite2.height)
        radius2 = (sprite2.width * sprite2.scaling) / 2.0;
    else
        radius2 = (sprite2.height * sprite2.scaling) / 2.0;

    //center point 2
    double x2 = sprite2.x + radius2;
    double y2 = sprite2.y + radius2;
    D3DXVECTOR2 vector2(x2, y2);

    //calculate distance
    double deltax = vector1.x - vector2.x;
    double deltay = vector2.y - vector1.y;
    double dist = sqrt((deltax * deltax) + (deltay * deltay));

    //return distance comparison
    return (dist < radius1 + radius2);
}

   现在正是将这个函数复制到框架中的时候，我们这就来做，将这个函数添加到MyDirectX.cpp中，将原形添加到MyDirectX.h中。

bool CollisionD(SPRITE sprite1, SPRITE sprite2);

和上面个那个函数效果是一致的