Арканоид. Вернуться в исходное состояние.

//------------------------------------------------------------
// К проекту необходимо добавить следующие библиотечные файлы:
// d3d9.lib dinput8.lib dxguid.lib winmm.lib
//------------------------------------------------------------
#include <windows.h>
#include <d3d9.h>
#include <dinput.h>
#include <mmsystem.h>
 
HWND hWnd;
IDirect3D9* d3d = NULL;
IDirect3DDevice9* videocard = NULL;
IDirectInput8* di = NULL;
IDirectInputDevice8* keyboard = NULL;
IDirect3DSurface9* backBuffer = NULL;
 
LRESULT __stdcall WndProc(HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam);
HRESULT hr = NULL;
MSG msg;
 
// Константы
const int WINDOW_HEIGHT = 500;
const int WINDOW_WIDTH = 500;
 
enum GameState {GAME_STATE_INIT,
                GAME_STATE_START_LEVEL,
                GAME_STATE_RUN};
 
GameState gameState = GAME_STATE_INIT;
 
const int NUM_BRICK_ROWS = 8;
const int NUM_BRICK_COLUMNS = 5;
 
const int BRICK_WIDTH = 82;
const int BRICK_HEIGHT = 20;
const int BRICK_ORIGIN_X = 15;
const int BRICK_ORIGIN_Y = 15;
const int BRICK_X_GAP = 15;
const int BRICK_Y_GAP = 7;
 
const int PADDLE_START_X = WINDOW_WIDTH/2 - 16;
const int PADDLE_START_Y = WINDOW_HEIGHT - 32;
const int PADDLE_WIDTH = 32;
const int PADDLE_HEIGHT = 8;
 
const int BALL_START_Y = WINDOW_HEIGHT/2;
const int BALL_SIZE = 8;
const int BALL_WIDTH = 8;
const int BALL_HEIGHT = 8;
 
// Глобальные переменные
int paddle_x=0, paddle_y=0;
int ball_x = 0, ball_y = 0;
/*Перемещение мяча по оси x за один кадр. Достаточно изменить знак одной из этих переменных, поменяется направле-ние движения. 
Если менять значение переменных, то будет меняться скорость.*/
int ball_dx = 0, ball_dy = 0; 
 
D3DLOCKED_RECT lockedBrick;
RECT brickRect;
D3DLOCKED_RECT lockedPaddle;
RECT paddleRect;
D3DLOCKED_RECT lockedBall;
RECT ballRect;
 
unsigned char brick[BRICK_WIDTH*BRICK_HEIGHT*4];
unsigned char paddle[PADDLE_WIDTH*PADDLE_HEIGHT*4];
unsigned char ball[BALL_WIDTH*BALL_HEIGHT*4];
 
unsigned char bricks[NUM_BRICK_ROWS][NUM_BRICK_COLUMNS];
 
char buffer[256]; // Буфер. хранит состояние клваиатуры.
 
 
void InitBricks()
{
    for(int row=0; row < NUM_BRICK_ROWS; ++row)
        for (int col=0; col < NUM_BRICK_COLUMNS; ++col)
            bricks[row][col] = 1; //блок рисуется и нужно просчитывать с ним столкновение
}
 
//Рисуем кирпичики
/*Для каждого отдельного блока сначала считается отступ, затем замыкается прямоугольник в фоновом буфере и в него копируется картинка. 
Блок рисуется только если его значение не равно нулю. В противном случае он не существует и его не нужно рисовать.*/
void DrawBricks()
{
    for (int row = 0; row < NUM_BRICK_ROWS; ++row)
    {
        for (int col = 0; col < NUM_BRICK_COLUMNS; ++col)
        {
            if (bricks[row][col]!=0)
            {
                brickRect.top = BRICK_ORIGIN_Y + BRICK_HEIGHT * row + BRICK_Y_GAP*row;
                brickRect.left = BRICK_ORIGIN_X + BRICK_WIDTH * col + BRICK_X_GAP*col;
                brickRect.bottom = brickRect.top + BRICK_HEIGHT;
                brickRect.right = brickRect.left + BRICK_WIDTH;
 
                backBuffer->LockRect(&lockedBrick,&brickRect,0); //замкнем прямоугольник
                for (int i = 0; i < BRICK_HEIGHT; ++i)
                    memcpy(static_cast<char*>(lockedBrick.pBits)+lockedBrick.Pitch*i,
                                 brick+BRICK_WIDTH*i*4,
                                 BRICK_WIDTH*4);
                backBuffer->UnlockRect();
            }
        }
    }
}
 
/*Функция состоит из двух частей. В первой части проверяется столкновение с платформой, во второй - с блоками.
В обоих случаях мяч представляется точкой. Т.е. проверяется столкновение точки и прямоугольника. */
void ProcessBall()
{
    //Чтобы столкновения просчитывались более точно, лучше брать центр мяча
    int x = ball_x + (BALL_SIZE/2);
    int y = ball_y + (BALL_SIZE/2);
 
    //проверяем столкновение центра мяча с платформой
    if ((x >= paddle_x && x <= paddle_x+PADDLE_WIDTH) &&
        (y >= paddle_y && y <= paddle_y+PADDLE_HEIGHT))
    {
        /*Если произошло столкновение с платформой, то меняем значение dy. 
        Для dx немного иначе. Чтобы движение мяча выглядело более естественно, 
        dxменяет свое значение от -2 до 2. Благодаря этому корректируется «рикошет» мяча.*/
        ball_dy = -ball_dy;
        ball_y += ball_dy;
 
        ball_dx += -2+rand()%4;
    }
 
 
    int top,left,bottom,right;
 
    /*проверяется столкновение с каждым блоком. Если столкновение произошло, 
    то dy и dx меняются также как в коде выше, помимо этого значение для блока 
    меняется на ноль - блок перестаёт существовать.*/
    for (int row = 0; row < NUM_BRICK_ROWS; ++row)
    {
        for (int col = 0; col < NUM_BRICK_COLUMNS; ++col)
        {
            if (bricks[row][col] > 0)
            {
                top = BRICK_ORIGIN_Y + BRICK_HEIGHT * row + BRICK_Y_GAP*row;
                left = BRICK_ORIGIN_X + BRICK_WIDTH * col + BRICK_X_GAP*col;
                bottom = top + BRICK_HEIGHT;
                right = left + BRICK_WIDTH;
                if ((x >= left && x <= right) &&
                    (y >= top && y <= bottom))
                {
                    bricks[row][col] = 0;
                    ball_dy  = -ball_dy;
                    ball_dx += -2+rand()%4;
                }
            }
        }
    }
}
 
void GameMain()
{
    if (gameState == GAME_STATE_INIT)
    {
        paddle_x = PADDLE_START_X;
        paddle_y = PADDLE_START_Y;
        ball_x = paddle_x+PADDLE_WIDTH/2-4;
        ball_y = paddle_y-BALL_SIZE;
        ball_dx = 0; //Задают скорость мяча
        ball_dy = 0;//Задают скорость мяча
        gameState = GAME_STATE_START_LEVEL;
    }
    if (gameState == GAME_STATE_START_LEVEL)
    {
        InitBricks();
        gameState = GAME_STATE_RUN;
    }
    if ( gameState == GAME_STATE_RUN)
    {
        keyboard->GetDeviceState(sizeof(buffer),buffer); //Здесь начинается код движения платформы
        if (buffer[DIK_SPACE] & 0x80)
        {
            ball_dx = -4 + rand()%8;
            ball_dy = -8 + rand()%2;
        }
 
        if (buffer[DIK_RIGHT] & 0x80)
        {
            paddle_x+=8;
            /*Координатами объекта (мяч, платформа, блок) считается левый верхний угол. 
            Чтобы проверить, находится ли объект за правой границей окна, нужно, так или иначе, использовать ширину объекта.
            В данном случае ширина объекта вычитается от правой границы окна, и это значение сравнивается с левой границей объекта.*/
            if (paddle_x > WINDOW_WIDTH-PADDLE_WIDTH) 
                paddle_x -= 8;
        }
        else if (buffer[DIK_LEFT] & 0x80)
        {
            paddle_x-=8;
            if (paddle_x < 0)
                paddle_x += 8;
        }
 
        DrawBricks(); //рисование блоков
 
        //Меняется местоположение мяча (к координатам мяча прибавляется dx и dy)
        ball_x+=ball_dx;
        ball_y+=ball_dy;
 
        //проверяем столкновение мяча со стенками окна
        if (ball_x > (WINDOW_WIDTH - BALL_SIZE) || ball_x < 0)
        {
            ball_dx = -ball_dx; //При касании левой или правой стенки окна, нужно поменять знак dx - мяч полетит в противоположную сторону
            ball_x += ball_dx;
        }
        //При касании верхней стенки (ведь ось y идёт сверху вниз) меняется знак dy.
        if (ball_y < 0)
        {
            ball_dy = -ball_dy;
            ball_y += ball_dy;
        }
        /*проверить вылет мяча за нижний край окна. 
        Не долетая 15 пикселей до нижней границы окна произойдёт 
        смена состояния на GAME_STATE_INIT и игра начнётся заново*/
        if (ball_y > WINDOW_HEIGHT-15)
            gameState = GAME_STATE_INIT;
 
        ProcessBall();
 
        paddleRect.top = paddle_y;
        paddleRect.left= paddle_x;
        paddleRect.right = paddle_x + PADDLE_WIDTH;
        paddleRect.bottom = paddle_y + PADDLE_HEIGHT;
 
        ballRect.top = ball_y;
        ballRect.left = ball_x;
        ballRect.right = ball_x + BALL_WIDTH;
        ballRect.bottom = ball_y + BALL_HEIGHT;
 
        backBuffer->LockRect(&lockedPaddle,&paddleRect,0);
        for (int i = 0; i < PADDLE_HEIGHT; ++i)
        memcpy(static_cast<char*>(lockedPaddle.pBits)+lockedPaddle.Pitch*i,
               paddle+PADDLE_WIDTH*i*4,
               PADDLE_WIDTH*4);
        backBuffer->UnlockRect();
 
        backBuffer->LockRect(&lockedBall,&ballRect,0);
        for (int i = 0; i < BALL_HEIGHT; ++i)
        memcpy(static_cast<char*>(lockedBall.pBits)+lockedBall.Pitch*i,
               ball+BALL_WIDTH*i*4,
               BALL_WIDTH*4);
        backBuffer->UnlockRect();
    }
}
 
int __stdcall WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance,
                      LPSTR lpCmdLine, int nCmdShow)
{
    WNDCLASS wc;
    wc.style = CS_OWNDC;
    wc.lpfnWndProc = WndProc;
    wc.cbClsExtra = 0;
    wc.cbWndExtra = 0;
    wc.hbrBackground = (HBRUSH)(6);
    wc.hCursor = LoadCursor(NULL, IDC_ARROW);
    wc.hIcon = LoadIcon(NULL, IDI_APPLICATION);
    wc.hInstance = hInstance;
    wc.lpszClassName = L"class";
    wc.lpszMenuName = NULL;
    RegisterClass(&wc);
    hWnd = CreateWindow(L"class",L"Арканоид. Авторы: Рыбалка В., Миначев А.",
                        WS_OVERLAPPEDWINDOW,10,10,
                        500,500,NULL,NULL,hInstance,NULL);
    ShowWindow(hWnd,nCmdShow);
    UpdateWindow(hWnd);
 
    d3d = Direct3DCreate9(D3D_SDK_VERSION);
    D3DPRESENT_PARAMETERS pp;
    ZeroMemory(&pp,sizeof(pp));
    pp.BackBufferWidth = 500;
    pp.BackBufferHeight = 500;
    pp.BackBufferFormat = D3DFMT_X8R8G8B8;
    pp.BackBufferCount = 1;
    pp.MultiSampleType = D3DMULTISAMPLE_NONE;
    pp.SwapEffect = D3DSWAPEFFECT_DISCARD;
    pp.hDeviceWindow = hWnd;
    pp.Windowed = true;
    pp.Flags = D3DPRESENTFLAG_LOCKABLE_BACKBUFFER;
    d3d->CreateDevice(D3DADAPTER_DEFAULT, D3DDEVTYPE_HAL,hWnd,
                      D3DCREATE_HARDWARE_VERTEXPROCESSING,
                      &pp, &videocard);
 
    DirectInput8Create(hInstance,DIRECTINPUT_VERSION,
                       IID_IDirectInput8,(void**)&di,
                       NULL);
    di->CreateDevice(GUID_SysKeyboard,&keyboard,NULL);
    keyboard->SetDataFormat(&c_dfDIKeyboard);
    keyboard->SetCooperativeLevel(hWnd, DISCL_FOREGROUND | DISCL_NONEXCLUSIVE);
    keyboard->Acquire(); //Проверяем доступность клавиатуры
 
    ZeroMemory(&msg,sizeof(MSG));
    char buffer[256];
    ZeroMemory(buffer,sizeof(buffer));
 
    videocard->GetBackBuffer(0,0,D3DBACKBUFFER_TYPE_MONO,&backBuffer);
 
    /*Фоновый буфер хранит байты пикселей в обратном порядке (littile-endian). 
    Поэтому, несмотря на то, что формат называется D3DFMT_X8R8G8B8, 
    фактически каналы хранятся так: BGRX. Точно так же пиксели хранятся и в BMP, 
    поэтому не нужно преобразовывать формат пикселей при копировании BMP в фоновый буфер*/
    
    //Задаем цыет кирпичей
    for (int i = 0; i < BRICK_HEIGHT*BRICK_WIDTH*4; i+=4)
    {
        brick[i] = 0;
        brick[i+1] = 0;
        brick[i+2] = 0;
        brick[i+3] = 0;
    }
 
    //Задаем цвет платформы
    for (int i = 0; i < PADDLE_HEIGHT*PADDLE_WIDTH*4; i+=4)
    {
        paddle[i] = 0;
        paddle[i+1] = 0;
        paddle[i+2] = 0;
        paddle[i+3] = 0;
    }
 
    //Задаем цвет шара
    for (int i = 0; i < BALL_HEIGHT*BALL_WIDTH*4; i+=4)
    {
        ball[i] = 255;
        ball[i+1] = 255;
        ball[i+2] = 255;
        ball[i+3] = 255;
    }
    ZeroMemory(buffer,sizeof(buffer));
 
    while (1)
    {
        if (PeekMessage(&msg,NULL,0,0,PM_REMOVE))
        {
            if (msg.message == WM_QUIT)
                break;
            TranslateMessage(&msg);
            DispatchMessage(&msg);
        }
 
    videocard->Clear(0,NULL,D3DCLEAR_TARGET,
                     D3DCOLOR_XRGB(202,153,51),1.0f,0);
    GameMain();
    videocard->Present(NULL,NULL,NULL,NULL);
    Sleep(25);
    }
 
    if (keyboard != NULL)
    {
        keyboard->Unacquire();
        keyboard->Release();
    }
    if (di != NULL)
        di->Release();
    if (videocard != NULL)
        videocard->Release();
    if (d3d != NULL)
        d3d->Release();
    UnregisterClass(L"class",hInstance);
    return 0;
}
 
LRESULT __stdcall WndProc (HWND hWnd, UINT msg,
                           WPARAM wParam, LPARAM lParam)
{
    switch (msg)
    {
    case WM_DESTROY:
        PostQuitMessage(0);
        return 0;
    }
    return DefWindowProc(hWnd,msg,wParam,lParam);
}