[PIU] Strzelanie do kurczakow

#include <windows.h>
#include <deque>
#include <time.h>

#define SCREEN_WIDTH 1000
#define SCREEN_HEIGHT 800
#define TIMER_ID1 1
#define TIMER_ID2 2
#define TIMER_ID3 3
#define MAX_AMMO 4

TCHAR className[] = TEXT("Class");
TCHAR appName[] = TEXT("[PIU] Strzelanie do kurczakow");

HWND hwnd;
MSG msg;

enum DIRECTION { LEFT, RIGHT };

struct Container {
    DIRECTION dir;
    float x, y;
    UINT sizeX, sizeY;
    float xVel, yVel;
};

std::deque<Container> enemy;

HBITMAP CreateBitmapMask(HBITMAP hbmColour, COLORREF crTransparent)
{
    HDC hdcMem, hdcMem2;
    HBITMAP hbmMask, hbmOld, hbmOld2;
    BITMAP bm;

    GetObject(hbmColour, sizeof(BITMAP), &bm);
    hbmMask = CreateBitmap(bm.bmWidth, bm.bmHeight, 1, 1, NULL);

    hdcMem = CreateCompatibleDC(NULL);
    hdcMem2 = CreateCompatibleDC(NULL);

    hbmOld = (HBITMAP)SelectObject(hdcMem, hbmColour);
    hbmOld2 = (HBITMAP)SelectObject(hdcMem2, hbmMask);

    SetBkColor(hdcMem, crTransparent);

    BitBlt(hdcMem2, 0, 0, bm.bmWidth, bm.bmHeight, hdcMem, 0, 0, SRCCOPY);
    BitBlt(hdcMem, 0, 0, bm.bmWidth, bm.bmHeight, hdcMem2, 0, 0, SRCINVERT);

    SelectObject(hdcMem, hbmOld);
    SelectObject(hdcMem2, hbmOld2);
    DeleteDC(hdcMem);
    DeleteDC(hdcMem2);

    return hbmMask;
}

bool checkCollision(Container A, Container B)
{
    RECT objectA, objectB;

    objectA.left = A.x;
    objectA.right = A.x + A.sizeX;
    objectA.top = A.y;
    objectA.bottom = A.y + A.sizeY;

    objectB.left = B.x;
    objectB.right = B.x + B.sizeX;
    objectB.top = B.y;
    objectB.bottom = B.y + B.sizeY;

    if (objectA.bottom <= objectB.top)
    {
        return false;
    }

    if (objectA.top >= objectB.bottom)
    {
        return false;
    }

    if (objectA.right <= objectB.left)
    {
        return false;
    }

    if (objectA.left >= objectB.right)
    {
        return false;
    }

    return true;
}

void initEnemy(const RECT clientRect, const BITMAP enemyInfo) {
    Container cont;

    (rand() % 2 == 1) ? cont.dir = RIGHT : cont.dir = LEFT;

    if (cont.dir == LEFT) { cont.x = clientRect.right; cont.xVel = -1 * (5 + rand() % 10); }
    else if (cont.dir == RIGHT) { cont.x = -enemyInfo.bmWidth; cont.xVel = 5 + rand() % 10; }

    cont.y = rand() % (clientRect.bottom - enemyInfo.bmHeight);
    cont.sizeX = enemyInfo.bmWidth;
    cont.sizeY = enemyInfo.bmHeight;
    cont.yVel = 0;

    enemy.push_back(cont);
}

LRESULT CALLBACK WndProc(HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam) {
    static RECT clientRect;
    static HBITMAP backgroundBitMap, enemyLeftBitmap, enemyLeftMask, enemyRightBitmap, enemyRightMask, bulletBitmap, bulletMask;
    static PAINTSTRUCT ps;
    static BITMAP bgInfo, enemyInfo, bulletInfo;
    static SYSTEMTIME startRelead, currentReloadTime;
    static UINT ammo = MAX_AMMO;

    switch (msg) {
    case WM_CREATE: {
        srand(time(NULL));
        GetClientRect(hwnd, &clientRect);
        SetTimer(hwnd, TIMER_ID1, 20, NULL);
        SetTimer(hwnd, TIMER_ID2, 100, NULL);
        SetTimer(hwnd, TIMER_ID3, 500, NULL);

        backgroundBitMap = (HBITMAP)LoadImage(NULL, TEXT("background.bmp"), IMAGE_BITMAP, 0, 0, LR_LOADFROMFILE);
        enemyRightBitmap = (HBITMAP)LoadImage(NULL, TEXT("right.bmp"), IMAGE_BITMAP, 0, 0, LR_LOADFROMFILE);
        enemyRightMask = CreateBitmapMask(enemyRightBitmap, RGB(0, 0, 0));
        enemyLeftBitmap = (HBITMAP)LoadImage(NULL, TEXT("left.bmp"), IMAGE_BITMAP, 0, 0, LR_LOADFROMFILE);
        enemyLeftMask = CreateBitmapMask(enemyLeftBitmap, RGB(0, 0, 0));
        bulletBitmap = (HBITMAP)LoadImage(NULL, TEXT("bullet.bmp"), IMAGE_BITMAP, 0, 0, LR_LOADFROMFILE);
        bulletMask = CreateBitmapMask(bulletBitmap, RGB(0, 0, 0));

        GetObject(backgroundBitMap, sizeof(BITMAP), &bgInfo);
        GetObject(enemyRightBitmap, sizeof(BITMAP), &enemyInfo);
        GetObject(bulletBitmap, sizeof(BITMAP), &bulletInfo);

        initEnemy(clientRect, enemyInfo);
    }break;

    case WM_PAINT: {
        HDC hdc = BeginPaint(hwnd, &ps);

        /////////////////////////////////////////////////////////////////////

        HDC hdcNowy = CreateCompatibleDC(hdc);
        HBITMAP hbmOld = (HBITMAP)SelectObject(hdcNowy, backgroundBitMap);
        BitBlt(hdc, 0, 0, bgInfo.bmWidth, bgInfo.bmHeight, hdcNowy, 0, 0, SRCCOPY);

        SelectObject(hdcNowy, hbmOld);

        /////////////////////////////////////////////////////////////////////

        for (std::deque<Container>::iterator it = enemy.begin(); it != enemy.end(); ++it) {
            if (it->dir == LEFT) {
                hbmOld = (HBITMAP)SelectObject(hdcNowy, enemyLeftMask);

                BitBlt(hdc, it->x, it->y, it->sizeX, it->sizeY, hdcNowy, 0, 0, SRCAND);
                SelectObject(hdcNowy, enemyLeftBitmap);
                BitBlt(hdc, it->x, it->y, it->sizeX, it->sizeY, hdcNowy, 0, 0, SRCPAINT);

                SelectObject(hdcNowy, hbmOld);
            }
            else {
                hbmOld = (HBITMAP)SelectObject(hdcNowy, enemyRightMask);

                BitBlt(hdc, it->x, it->y, it->sizeX, it->sizeY, hdcNowy, 0, 0, SRCAND);
                SelectObject(hdcNowy, enemyRightBitmap);
                BitBlt(hdc, it->x, it->y, it->sizeX, it->sizeY, hdcNowy, 0, 0, SRCPAINT);

                SelectObject(hdcNowy, hbmOld);
            }
        }

        /////////////////////////////////////////////////////////////////////

        for (size_t i = 0; i < ammo; i++) {
            hbmOld = (HBITMAP)SelectObject(hdcNowy, bulletMask);

            BitBlt(hdc, 5 + (bulletInfo.bmWidth * i), clientRect.bottom - bulletInfo.bmHeight, bulletInfo.bmWidth, bulletInfo.bmHeight, hdcNowy, 0, 0, SRCAND);
            SelectObject(hdcNowy, bulletBitmap);
            BitBlt(hdc, 5 + (bulletInfo.bmWidth * i), clientRect.bottom - bulletInfo.bmHeight, bulletInfo.bmWidth, bulletInfo.bmHeight, hdcNowy, 0, 0, SRCPAINT);

            SelectObject(hdcNowy, hbmOld);
        }

        DeleteDC(hdcNowy);
        EndPaint(hwnd, &ps);
    }break;

    case WM_TIMER: {
        switch (wParam) {
        case TIMER_ID1: {
            for (std::deque<Container>::iterator it = enemy.begin(); it != enemy.end(); ++it) {
                it->x += it->xVel;
                it->y += it->yVel;

                if (it->dir == LEFT && it->x < -1.1f * it->sizeX) {
                    enemy.erase(it);
                    break;
                }

                if (it->dir == RIGHT && it->x > clientRect.right + it->sizeX) {
                    enemy.erase(it);
                    break;
                }
            }

            if (ammo <= 0) {
                GetLocalTime(&currentReloadTime);

                UINT seconds = (currentReloadTime.wMinute - startRelead.wMinute) * 60 + (currentReloadTime.wSecond - startRelead.wSecond);
                if (seconds >= 4) {
                    ammo = MAX_AMMO;
                }
            }

            InvalidateRect(hwnd, NULL, 0);
        }break;

        case TIMER_ID2:
            for (std::deque<Container>::iterator it = enemy.begin(); it != enemy.end(); ++it) {
                it->yVel = 5 - rand() % 10;
            }
            break;

        case TIMER_ID3:
            initEnemy(clientRect, enemyInfo);
            break;
        }break;
    }break;

    case WM_LBUTTONDOWN: {
        DWORD x = LOWORD(lParam);
        DWORD y = HIWORD(lParam);

        if (ammo > 0) {
            for (std::deque<Container>::iterator it = enemy.begin(); it != enemy.end(); ++it) {
                if (x > it->x && y < it->x + it->sizeX && y > it->y && y < it->y + it->sizeY) {
                    enemy.erase(it);
                    break;
                }
            }

            ammo--;

            if (ammo == 0)
                GetLocalTime(&startRelead);
        }
    }break;

    case WM_CLOSE:
        DestroyWindow(hwnd);
        break;

    case WM_DESTROY: {
        KillTimer(hwnd, TIMER_ID1);
        KillTimer(hwnd, TIMER_ID2);
        KillTimer(hwnd, TIMER_ID3);
        PostQuitMessage(0);
    }break;

    default:
        return DefWindowProc(hwnd, msg, wParam, lParam);
    }

    return 0;
}

int WINAPI WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance, LPSTR lpCmdLine, int nCmdShow)
{
    WNDCLASSEX wc;
    wc.cbSize = sizeof(WNDCLASSEX);
    wc.style = 0;
    wc.cbClsExtra = 0;
    wc.cbWndExtra = 0;
    wc.hInstance = hInstance;
    wc.hbrBackground = (HBRUSH)(COLOR_WINDOW + 1);
    wc.lpfnWndProc = WndProc;
    wc.lpszClassName = className;
    wc.lpszMenuName = NULL;
    wc.hIcon = LoadIcon(NULL, IDI_APPLICATION);
    wc.hIconSm = LoadIcon(NULL, IDI_APPLICATION);
    wc.hCursor = LoadCursor(NULL, IDC_ARROW);

    if (RegisterClassEx(&wc) == 0) {
        MessageBox(NULL, TEXT("Some problem with RegisterClassEx"), className, MB_OK);
        return 1;
    }

    hwnd = CreateWindowEx(WS_EX_APPWINDOW | WS_EX_CLIENTEDGE, className, appName, WS_OVERLAPPED | WS_CAPTION | WS_SYSMENU, CW_USEDEFAULT, CW_USEDEFAULT, SCREEN_WIDTH, SCREEN_HEIGHT, 0, 0, hInstance, 0);
    if (hwnd == NULL) {
        MessageBox(NULL, TEXT("Some problem with CreateWindowEx by hwnd"), className, MB_OK);
        return 1;
    }

    ShowWindow(hwnd, nCmdShow);
    UpdateWindow(hwnd);

    while (GetMessage(&msg, NULL, 0, 0) > 0)
    {
        TranslateMessage(&msg);
        DispatchMessage(&msg);
    }

    UnregisterClass(className, hInstance);

    return msg.wParam;
}