Asteroids Impact (Fix For Countdown Not Displaying "3")

==++ Here's the full code for (file 1/2) "GDIGameEngine.cpp"::: ++==
```GDIGameEngine.cpp
#include <windows.h>
#include <vector>
#include <cmath>
#include <ctime>
#include <algorithm>  // Include this header for std::min and std::max
#include <tchar.h>
// Add these global variables
#include <thread>
#include <atomic>
#include "resource.h"

#include <mmsystem.h>
#pragma comment(lib, "winmm.lib")

#define WIN_WIDTH 800
#define WIN_HEIGHT 600
// Add this to your global variables
#define NUM_STARS 100
// Add with other global variables
bool keyStates[256] = { false };  // Track key states
bool godMode = false; // Track God Mode state
bool paused = false; // Track paused state
bool gameStarted = false;
//int countdownTimer = 240; // 4 seconds total (3,2,1,Get Ready!)
int countdownTimer = 241; // 4 seconds total (3,2,1,Get Ready!)
int windowWidth;
int windowHeight;
MCIDEVICEID midiDeviceID = 0;
std::atomic<bool> isMusicPlaying(false);
std::thread musicThread;
bool isShielded = true; //changetofalse
int shieldTimer = 0;
const int SHIELD_DURATION = 240; // 4 seconds at 60 FPS

LRESULT CALLBACK WndProc(HWND, UINT, WPARAM, LPARAM);
void DrawSpacecraft(HDC hdc, POINT pts[], int x, int y, double angle);
void DrawAsteroid(HDC hdc, POINT pts[], int x, int y, double angle);
bool CheckCollision(POINT player[], POINT asteroid[], int px, int py, int ax, int ay);
void MoveAsteroids();
void ShootBullet();
void DrawBullet(HDC hdc, int x, int y);
bool CheckBulletCollision(int bx, int by);
bool DoLinesIntersect(int x1, int y1, int x2, int y2, int x3, int y3, int x4, int y4);
int Direction(int x1, int y1, int x2, int y2, int x3, int y3);
bool OnSegment(int x1, int y1, int x2, int y2, int x3, int y3);
bool PointInPolygon(int px, int py, POINT polygon[], int ox, int oy);
void GenerateAsteroids();
void SpawnNewAsteroid();
void UpdatePlayerMovement();
void InitStars();
void DrawStarfield(HDC hdc);

struct Asteroid {
    int x, y;
    double angle;
    double speed;
    POINT shape[8];
};

struct Bullet {
    int x, y;
    double angle;
};

struct Star {
    int x, y;
    int brightness; // 0-255 for varying star brightness
};
Star stars[NUM_STARS];

std::vector<Asteroid> asteroids;
std::vector<Bullet> bullets;
// Replace the existing player points definition
// Define more points for a detailed spacecraft
POINT player[15] = {
    {0, -40},    // Nose
    {15, -20},   // Right front
    {20, -10},   // Right body
    {25, 0},     // Right wing
    {30, 20},    // Right thruster
    {20, 25},    // Right back
    {10, 30},    // Right exhaust
    {0, 35},     // Center exhaust
    {-10, 30},   // Left exhaust
    {-20, 25},   // Left back
    {-30, 20},   // Left thruster
    {-25, 0},    // Left wing
    {-20, -10},  // Left body
    {-15, -20},  // Left front
    {0, -40}     // Back to nose
};
int playerX = WIN_WIDTH / 2, playerY = WIN_HEIGHT / 2;
double playerAngle = 0;
int score = 0;
int lives = 3;

void PlayMidiInBackground(HWND hwnd, const TCHAR* midiPath) {
    while (isMusicPlaying) {
        MCI_OPEN_PARMS mciOpen = { 0 };
        mciOpen.lpstrDeviceType = TEXT("sequencer");
        mciOpen.lpstrElementName = midiPath;

        if (mciSendCommand(0, MCI_OPEN, MCI_OPEN_TYPE | MCI_OPEN_ELEMENT, (DWORD_PTR)&mciOpen) == 0) {
            midiDeviceID = mciOpen.wDeviceID;

            MCI_PLAY_PARMS mciPlay = { 0 };
            mciSendCommand(midiDeviceID, MCI_PLAY, 0, (DWORD_PTR)&mciPlay);

            // Wait for playback to complete
            MCI_STATUS_PARMS mciStatus = { 0 };
            mciStatus.dwItem = MCI_STATUS_MODE;

            do {
                mciSendCommand(midiDeviceID, MCI_STATUS, MCI_STATUS_ITEM, (DWORD_PTR)&mciStatus);
                Sleep(100); // Reduce CPU usage
            } while (mciStatus.dwReturn == MCI_MODE_PLAY && isMusicPlaying);

            mciSendCommand(midiDeviceID, MCI_CLOSE, 0, NULL);
            midiDeviceID = 0;
        }
    }
}

void PlayGameMusic(HWND hwnd) {
    // Stop any existing playback
    if (isMusicPlaying) {
        isMusicPlaying = false;
        if (musicThread.joinable()) {
            musicThread.join();
        }
        if (midiDeviceID != 0) {
            mciSendCommand(midiDeviceID, MCI_CLOSE, 0, NULL);
            midiDeviceID = 0;
        }
    }

    // Get the path of the executable
    TCHAR exePath[MAX_PATH];
    GetModuleFileName(NULL, exePath, MAX_PATH);

    // Extract the directory path
    TCHAR* lastBackslash = _tcsrchr(exePath, '\\');
    if (lastBackslash != NULL) {
        *(lastBackslash + 1) = '\0';
    }

    // Construct the full path to the MIDI file
    static TCHAR midiPath[MAX_PATH];
    _tcscpy_s(midiPath, MAX_PATH, exePath);
    _tcscat_s(midiPath, MAX_PATH, TEXT("GAME MUSIC.MID"));

    // Start the background playback
    isMusicPlaying = true;
    musicThread = std::thread(PlayMidiInBackground, hwnd, midiPath);
}

int WINAPI WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance, LPSTR lpCmdLine, int nCmdShow) {
    WNDCLASSEX wcex;
    HWND hwnd;
    MSG msg;

    wcex.cbSize = sizeof(WNDCLASSEX);
    wcex.style = CS_HREDRAW | CS_VREDRAW;
    wcex.lpfnWndProc = WndProc;
    wcex.cbClsExtra = 0;
    wcex.cbWndExtra = 0;
    wcex.hInstance = hInstance;
    wcex.hIcon = LoadIcon(NULL, IDI_APPLICATION);
    wcex.hCursor = LoadCursor(NULL, IDC_ARROW);
    wcex.hbrBackground = CreateSolidBrush(RGB(0, 0, 0)); // Replace NULL with this // Set background brush to NULL
    wcex.lpszMenuName = NULL;
    wcex.lpszClassName = TEXT("Asteroids");
    wcex.hIconSm = LoadIcon(wcex.hInstance, MAKEINTRESOURCE(IDI_ICON1));
    //wcex.hIconSm = LoadIcon(NULL, IDI_APPLICATION);

    RegisterClassEx(&wcex);

    // Remove WS_MAXIMIZEBOX and WS_THICKFRAME from the window style
    DWORD style = (WS_OVERLAPPEDWINDOW & ~WS_MAXIMIZEBOX) & ~WS_THICKFRAME;

    // Get the screen dimensions
    int screenWidth = GetSystemMetrics(SM_CXSCREEN);
    int screenHeight = GetSystemMetrics(SM_CYSCREEN);

    // Calculate the window position to center it
    int windowWidth = WIN_WIDTH + 16;
    int windowHeight = WIN_HEIGHT + 39;
    int posX = (screenWidth - windowWidth) / 2;
    int posY = (screenHeight - windowHeight) / 2;

    hwnd = CreateWindow(TEXT("Asteroids"), TEXT("Asteroids ArrowKeys=Controls Space=Shoot F1=GodMode P=Pause F2=About Escape=Quit"), style,
        posX, posY, windowWidth + 16, windowHeight + 39, NULL, NULL, hInstance, NULL);

    //show window + update window here

    srand(static_cast<unsigned int>(time(0)));

    GenerateAsteroids();

    // Add this line in WinMain before the main loop:
    //initstars + playgamemusic here
    InitStars();
    ShowWindow(hwnd, nCmdShow);
    UpdateWindow(hwnd);
    Sleep(500); // Allow window to fully initialize before starting the countdown
    PlayGameMusic(hwnd);

    // Main game loop
    while (true) {
        if (PeekMessage(&msg, NULL, 0, 0, PM_REMOVE)) {
            if (msg.message == WM_QUIT) break;
            TranslateMessage(&msg);
            DispatchMessage(&msg);
        }
        else {
            if (!gameStarted) {
                InvalidateRect(hwnd, NULL, FALSE);
                Sleep(16);
                countdownTimer--;
                if (countdownTimer <= 0) {
                    gameStarted = true;
                }
                continue;
            }
            if (!paused) { //re-enable-code-below-for-nonshielding
                /*if (isShielded) {
                    shieldTimer--;
                    if (shieldTimer <= 0) {
                        isShielded = false;
                    }
                }*/

                UpdatePlayerMovement();
                for (auto& ast : asteroids) {
                    if (!godMode && !isShielded && CheckCollision(player, ast.shape, playerX, playerY, ast.x, ast.y)) {
                        lives--;
                        if (lives <= 0) {
                            if (MessageBox(hwnd, TEXT("Game Over! Play again?"), TEXT("Asteroids"), MB_YESNO) == IDYES) {
                                // Reset game
                                lives = 3;
                                score = 0;
                                playerX = WIN_WIDTH / 2;
                                playerY = WIN_HEIGHT / 2;
                                playerAngle = 0;
                                asteroids.clear();
                                bullets.clear();
                                GenerateAsteroids();
                            }
                            else {
                                PostQuitMessage(0);
                            }
                            continue;
                        }
                        playerX = WIN_WIDTH / 2;
                        playerY = WIN_HEIGHT / 2;
                        playerAngle = 0;
                        isShielded = true;
                        shieldTimer = SHIELD_DURATION;
                        memset(keyStates, 0, sizeof(keyStates));
                    }
                }

                if (rand() % 100 < 2) {
                    SpawnNewAsteroid();
                }

                MoveAsteroids();

                for (auto it = bullets.begin(); it != bullets.end();) {
                    it->x += 10 * cos(it->angle * 3.14159 / 180);
                    it->y += 10 * sin(it->angle * 3.14159 / 180);

                    if (CheckBulletCollision(it->x, it->y)) {
                        //Beep(500, 50); // Beep sound when asteroid is destroyed
                        it = bullets.erase(it);
                    }
                    else {
                        ++it;
                    }
                }
            }
            InvalidateRect(hwnd, NULL, FALSE);
            Sleep(16);
        }
    }

    return (int)msg.wParam;
}


LRESULT CALLBACK WndProc(HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam) {
    static HDC hdcMem;
    static HBITMAP hbmMem;
    static HBITMAP hbmOld;
    static HBRUSH hbrBkGnd;
    static RECT rect;
    PAINTSTRUCT ps;
    static TCHAR scoreText[50];

    switch (msg) {
    case WM_CREATE:
    {   // Add these braces
        GetClientRect(hwnd, &rect);
        HDC hdcWindow = GetDC(hwnd);
        hdcMem = CreateCompatibleDC(hdcWindow);
        hbmMem = CreateCompatibleBitmap(hdcWindow, rect.right, rect.bottom);
        ReleaseDC(hwnd, hdcWindow);
        hbmOld = (HBITMAP)SelectObject(hdcMem, hbmMem);
        hbrBkGnd = CreateSolidBrush(RGB(0, 0, 0));
    }    // Add these braces
    break;  // Add break statement

    case WM_ERASEBKGND:
        return 1;


    case WM_PAINT: {
        HDC hdc = BeginPaint(hwnd, &ps);
        FillRect(hdcMem, &rect, hbrBkGnd);

        // Draw starfield first (before everything else)
        DrawStarfield(hdcMem);

        if (!gameStarted) {
            SetTextColor(hdcMem, RGB(255, 255, 255));
            SetBkMode(hdcMem, TRANSPARENT);
            HFONT hFont = CreateFont(72, 0, 0, 0, FW_BOLD, FALSE, FALSE, FALSE,
                ANSI_CHARSET, // Changed from DEFAULT_CHARSET to ANSI_CHARSET
                OUT_OUTLINE_PRECIS, CLIP_DEFAULT_PRECIS,
                CLEARTYPE_QUALITY, DEFAULT_PITCH | FF_SWISS, TEXT("Arial"));
            HFONT hOldFont = (HFONT)SelectObject(hdcMem, hFont);

            const TCHAR* countText;  // Changed to const TCHAR*
            //int count = (countdownTimer / 60);
            int count = ((countdownTimer + 1) / 60);

            // Use direct string assignments instead of wsprintf
            if (count == 4) {
                countText = TEXT("3");
            }
            else if (count == 3) {
                countText = TEXT("2");
            }
            else if (count == 2) {
                countText = TEXT("1");
            }
            else if (count == 1) {
                countText = TEXT("Get Ready!");
            }
            else {
                countText = TEXT("");  // Add default case
            }

            RECT textRect;
            GetClientRect(hwnd, &textRect);
            DrawText(hdcMem, countText, -1, &textRect,
                DT_SINGLELINE | DT_CENTER | DT_VCENTER);

            SelectObject(hdcMem, hOldFont);
            DeleteObject(hFont);
        }
        else {
            // Your existing drawing code...
            DrawSpacecraft(hdcMem, player, playerX, playerY, playerAngle);
            for (auto& ast : asteroids) {
                DrawAsteroid(hdcMem, ast.shape, ast.x, ast.y, ast.angle);
            }
            for (auto& bullet : bullets) {
                DrawBullet(hdcMem, bullet.x, bullet.y);
            }

            SetTextColor(hdcMem, RGB(255, 255, 255));
            SetBkMode(hdcMem, TRANSPARENT);
            wsprintf(scoreText, TEXT("Score: %d  Lives: %d"), score, lives);
            TextOut(hdcMem, 10, 10, scoreText, lstrlen(scoreText));

            if (godMode) {
                TextOut(hdcMem, WIN_WIDTH / 2 - 50, 10, TEXT("God Mode"), 8);
            }
            if (paused) {
                TextOut(hdcMem, WIN_WIDTH / 2 - 50, WIN_HEIGHT / 2 - 10, TEXT("Game Paused"), 10);
            }
        }

        BitBlt(hdc, 0, 0, rect.right, rect.bottom, hdcMem, 0, 0, SRCCOPY);
        EndPaint(hwnd, &ps);
        break;
    }



    case WM_KEYDOWN:
        keyStates[wParam] = true;
        if (wParam == VK_F1) {
            godMode = !godMode; // Toggle God Mode
        }
        else if (wParam == 'P') {
            paused = !paused; // Toggle Pause
        }
        if (wParam == VK_ESCAPE) {
            PostQuitMessage(0);
            return 0;
        }
        // Add this new code block
        else if (wParam == VK_F2) {
            MessageBox(hwnd, TEXT("Asteroids v10.8 Basic GDI-Based C++ Win32 Game (663 lines of code) by Entisoft Software (c) Evans Thorpemorton"), TEXT("About"), MB_OK | MB_ICONINFORMATION);
        }
        break;

    case WM_KEYUP:
        keyStates[wParam] = false;
        break;

    case WM_DESTROY:
        SelectObject(hdcMem, hbmOld);  // Restore the original bitmap in the memory DC
        DeleteObject(hbmMem);          // Delete the off-screen bitmap
        DeleteDC(hdcMem);              // Delete the memory DC
        DeleteObject(hbrBkGnd);        // Delete the background brush
        isMusicPlaying = false;
        if (musicThread.joinable()) {
            musicThread.join();
        }
        if (midiDeviceID != 0) {
            mciSendCommand(midiDeviceID, MCI_CLOSE, 0, NULL);
            midiDeviceID = 0;
        }
        PostQuitMessage(0);
        break;

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

void DrawSpacecraft(HDC hdc, POINT pts[], int x, int y, double angle) {
    POINT rotated[15];
    for (int i = 0; i < 15; ++i) {
        rotated[i].x = pts[i].x * cos(angle * 3.14159 / 180) -
            pts[i].y * sin(angle * 3.14159 / 180);
        rotated[i].y = pts[i].x * sin(angle * 3.14159 / 180) +
            pts[i].y * cos(angle * 3.14159 / 180);
        rotated[i].x += x;
        rotated[i].y += y;
    }

    // Draw shield effect if active
    if (isShielded) {
        // Create shield gradient effect
        int shieldRadius = 60;
        HPEN shieldPen;

        // Multiple shield layers with different colors and opacity
        for (int i = 0; i < 3; i++) {
            int alpha = (255 - i * 40) * ((sin(shieldTimer * 0.1) + 1) / 2);
            COLORREF shieldColor;

            switch ((shieldTimer / 8 + i) % 3) {
            case 0:
                shieldColor = RGB(0, 255, 255); // Cyan
                break;
            case 1:
                shieldColor = RGB(0, 191, 255); // Deep Sky Blue
                break;
            case 2:
                shieldColor = RGB(30, 144, 255); // Dodger Blue
                break;
            }

            shieldPen = CreatePen(PS_SOLID, 2 - i, shieldColor);
            HPEN oldPen = (HPEN)SelectObject(hdc, shieldPen);

            // Draw shield circles
            int currentRadius = shieldRadius - (i * 10);
            Arc(hdc, x - currentRadius, y - currentRadius,
                x + currentRadius, y + currentRadius,
                x + currentRadius, y, x + currentRadius, y);

            // Draw energy field lines
            for (int j = 0; j < 8; j++) {
                double angleRad = (angle + j * 45) * 3.14159 / 180;
                int startX = x + (currentRadius - 10) * cos(angleRad);
                int startY = y + (currentRadius - 10) * sin(angleRad);
                int endX = x + currentRadius * cos(angleRad);
                int endY = y + currentRadius * sin(angleRad);
                MoveToEx(hdc, startX, startY, NULL);
                LineTo(hdc, endX, endY);
            }

            // Draw energy particles
            for (int j = 0; j < 12; j++) {
                double particleAngle = (shieldTimer * 2 + j * 30) * 3.14159 / 180;
                int particleX = x + currentRadius * cos(particleAngle);
                int particleY = y + currentRadius * sin(particleAngle);
                SetPixel(hdc, particleX, particleY, shieldColor);
            }

            SelectObject(hdc, oldPen);
            DeleteObject(shieldPen);
        }

        // Add shield shimmer effect
        HPEN shimmerPen = CreatePen(PS_SOLID, 1, RGB(255, 255, 255));
        SelectObject(hdc, shimmerPen);
        for (int i = 0; i < 16; i++) {
            double shimmerAngle = (shieldTimer * 3 + i * 22.5) * 3.14159 / 180;
            int shimmerX = x + shieldRadius * cos(shimmerAngle);
            int shimmerY = y + shieldRadius * sin(shimmerAngle);
            Ellipse(hdc, shimmerX - 2, shimmerY - 2, shimmerX + 2, shimmerY + 2);
        }
        DeleteObject(shimmerPen);
    }

    // Draw main body
    HPEN hotPinkPen = CreatePen(PS_SOLID, 1, RGB(255, 20, 147));
    HBRUSH hotPinkBrush = CreateSolidBrush(RGB(255, 20, 147));
    SelectObject(hdc, hotPinkPen);
    SelectObject(hdc, hotPinkBrush);
    Polygon(hdc, rotated, 15);

    // Draw headlights
    HPEN whitePen = CreatePen(PS_SOLID, 1, RGB(255, 255, 255));
    SelectObject(hdc, whitePen);

    // Left headlight
    int lightX1 = x + 15 * cos((angle - 100) * 3.14159 / 180);
    int lightY1 = y + 15 * sin((angle - 100) * 3.14159 / 180);
    Ellipse(hdc, lightX1 - 3, lightY1 - 3, lightX1 + 3, lightY1 + 3);

    // Right headlight
    int lightX2 = x + 15 * cos((angle - 80) * 3.14159 / 180);
    int lightY2 = y + 15 * sin((angle - 80) * 3.14159 / 180);
    Ellipse(hdc, lightX2 - 3, lightY2 - 3, lightX2 + 3, lightY2 + 3);

    // Draw engine glow when moving forward
    if (keyStates[VK_UP] || keyStates[VK_DOWN]) {
        HPEN orangePen = CreatePen(PS_SOLID, 1, RGB(255, 165, 0));
        HBRUSH orangeBrush = CreateSolidBrush(RGB(255, 165, 0));
        SelectObject(hdc, orangePen);
        SelectObject(hdc, orangeBrush);

        // Draw three exhaust flames
        for (int i = -1; i <= 1; i++) {
            int exhaustX = x - 30 * cos((angle - 90 + i * 15) * 3.14159 / 180);
            int exhaustY = y - 30 * sin((angle - 90 + i * 15) * 3.14159 / 180);
            Ellipse(hdc, exhaustX - 5, exhaustY - 5, exhaustX + 5, exhaustY + 5);
        }

        DeleteObject(orangePen);
        DeleteObject(orangeBrush);
    }

    DeleteObject(hotPinkPen);
    DeleteObject(hotPinkBrush);
    DeleteObject(whitePen);
}

void DrawAsteroid(HDC hdc, POINT pts[], int x, int y, double angle) {
    POINT rotated[8];
    for (int i = 0; i < 8; ++i) {
        rotated[i].x = pts[i].x * cos(angle * 3.14159 / 180) - pts[i].y * sin(angle * 3.14159 / 180);
        rotated[i].y = pts[i].x * sin(angle * 3.14159 / 180) + pts[i].y * cos(angle * 3.14159 / 180);
        rotated[i].x += x;
        rotated[i].y += y;
    }

    // In DrawAsteroid function, before Polygon call
    HPEN goldPen = CreatePen(PS_SOLID, 1, RGB(255, 215, 0));
    HBRUSH goldBrush = CreateSolidBrush(RGB(255, 215, 0));
    SelectObject(hdc, goldPen);
    SelectObject(hdc, goldBrush);
    Polygon(hdc, rotated, 8);
    DeleteObject(goldPen);
    DeleteObject(goldBrush);
}

void UpdatePlayerMovement() {
    if (keyStates[VK_LEFT]) {
        playerAngle -= 5;
    }
    if (keyStates[VK_RIGHT]) {
        playerAngle += 5;
    }
    if (keyStates[VK_UP]) {
        playerX += 5 * cos((playerAngle - 90) * 3.14159 / 180);
        playerY += 5 * sin((playerAngle - 90) * 3.14159 / 180);

        // Move stars in opposite direction of player movement for parallax effect
        for (int i = 0; i < NUM_STARS; i++) {
            stars[i].y += 1;
            if (stars[i].y > WIN_HEIGHT) {
                stars[i].y = 0;
                stars[i].x = rand() % WIN_WIDTH;
            }
        }
    }
    // Add to UpdatePlayerMovement() function
    if (keyStates[VK_DOWN]) {
        playerX -= 5 * cos((playerAngle - 90) * 3.14159 / 180);
        playerY -= 5 * sin((playerAngle - 90) * 3.14159 / 180);

        // Move stars in opposite direction of player movement for parallax effect
        for (int i = 0; i < NUM_STARS; i++) {
            stars[i].y += 1;
            if (stars[i].y > WIN_HEIGHT) {
                stars[i].y = 0;
                stars[i].x = rand() % WIN_WIDTH;
            }
        }
    }
    // Add to UpdatePlayerMovement() function
    static int shootCooldown = 0;
    if (keyStates[VK_SPACE] && shootCooldown == 0) {
        ShootBullet();
        shootCooldown = 10; // Adjust this value to control firing rate
    }
    if (shootCooldown > 0) {
        shootCooldown--;
    }

    // Wrap around screen
    if (playerX < 0) playerX = WIN_WIDTH;
    if (playerX > WIN_WIDTH) playerX = 0;
    if (playerY < 0) playerY = WIN_HEIGHT;
    if (playerY > WIN_HEIGHT) playerY = 0;
}

bool CheckCollision(POINT player[], POINT asteroid[], int px, int py, int ax, int ay) {
    for (int i = 0; i < 3; ++i) {
        int px1 = player[i].x + px;
        int py1 = player[i].y + py;
        int px2 = player[(i + 1) % 3].x + px;
        int py2 = player[(i + 1) % 3].y + py;

        for (int j = 0; j < 8; ++j) {
            int ax1 = asteroid[j].x + ax;
            int ay1 = asteroid[j].y + ay;
            int ax2 = asteroid[(j + 1) % 8].x + ax;
            int ay2 = asteroid[(j + 1) % 8].y + ay;

            // Check if the line segments intersect
            if (DoLinesIntersect(px1, py1, px2, py2, ax1, ay1, ax2, ay2)) {
                return true;
            }
        }
    }
    return false;
}

bool DoLinesIntersect(int x1, int y1, int x2, int y2, int x3, int y3, int x4, int y4) {
    // Calculate the direction of the lines
    int d1 = Direction(x3, y3, x4, y4, x1, y1);
    int d2 = Direction(x3, y3, x4, y4, x2, y2);
    int d3 = Direction(x1, y1, x2, y2, x3, y3);
    int d4 = Direction(x1, y1, x2, y2, x4, y4);

    // Check if the lines intersect
    if (((d1 > 0 && d2 < 0) || (d1 < 0 && d2 > 0)) && ((d3 > 0 && d4 < 0) || (d3 < 0 && d4 > 0))) {
        return true;
    }

    // Check for collinear points
    if (d1 == 0 && OnSegment(x3, y3, x4, y4, x1, y1)) return true;
    if (d2 == 0 && OnSegment(x3, y3, x4, y4, x2, y2)) return true;
    if (d3 == 0 && OnSegment(x1, y1, x2, y2, x3, y3)) return true;
    if (d4 == 0 && OnSegment(x1, y1, x2, y2, x4, y4)) return true;

    return false;
}

int Direction(int x1, int y1, int x2, int y2, int x3, int y3) {
    return (x3 - x1) * (y2 - y1) - (y3 - y1) * (x2 - x1);
}

bool OnSegment(int x1, int y1, int x2, int y2, int x3, int y3) {
    int minX = x1 < x2 ? x1 : x2;
    int maxX = x1 > x2 ? x1 : x2;
    int minY = y1 < y2 ? y1 : y2;
    int maxY = y1 > y2 ? y1 : y2;

    if (minX <= x3 && x3 <= maxX && minY <= y3 && y3 <= maxY) {
        return true;
    }
    return false;
}

void MoveAsteroids() {
    for (auto& ast : asteroids) {
        ast.x += ast.speed * cos(ast.angle * 3.14159 / 180);
        ast.y += ast.speed * sin(ast.angle * 3.14159 / 180);

        // Randomly adjust angle occasionally
        if (rand() % 100 < 2) {
            ast.angle += (rand() % 21 - 10); // Random turn between -10 and +10 degrees
        }

        // Screen wrapping
        if (ast.x < 0) ast.x = WIN_WIDTH;
        if (ast.x > WIN_WIDTH) ast.x = 0;
        if (ast.y < 0) ast.y = WIN_HEIGHT;
        if (ast.y > WIN_HEIGHT) ast.y = 0;
    }
}

void ShootBullet() {
    Bullet bullet;
    // Calculate the tip of the triangle (point[0] is the top vertex)
    bullet.x = playerX + player[0].x * cos(playerAngle * 3.14159 / 180)
        - player[0].y * sin(playerAngle * 3.14159 / 180);
    bullet.y = playerY + player[0].x * sin(playerAngle * 3.14159 / 180)
        + player[0].y * cos(playerAngle * 3.14159 / 180);
    // Adjust the bullet angle to match the ship's orientation
    bullet.angle = playerAngle - 90;  // Subtract 90 degrees to align with the ship's nose
    bullets.push_back(bullet);
}

// Modified DrawBullet function for green bullets
void DrawBullet(HDC hdc, int x, int y) {
    HPEN greenPen = CreatePen(PS_SOLID, 1, RGB(0, 255, 0));    // Bright green
    HBRUSH greenBrush = CreateSolidBrush(RGB(0, 255, 0));      // Bright green
    SelectObject(hdc, greenPen);
    SelectObject(hdc, greenBrush);
    Ellipse(hdc, x - 4, y - 4, x + 4, y + 4);
    DeleteObject(greenPen);
    DeleteObject(greenBrush);
}

bool CheckBulletCollision(int bx, int by) {
    for (auto it = asteroids.begin(); it != asteroids.end();) {
        if (PointInPolygon(bx, by, it->shape, it->x, it->y)) {
            //Beep(500, 50); // Add this line
            it = asteroids.erase(it);
            score += 10;
            return true;
        }
        else {
            ++it;
        }
    }
    return false;
}

bool PointInPolygon(int px, int py, POINT polygon[], int ox, int oy) {
    int i, j, nvert = 8;
    bool c = false;

    for (i = 0, j = nvert - 1; i < nvert; j = i++) {
        int polyX1 = polygon[i].x + ox;
        int polyY1 = polygon[i].y + oy;
        int polyX2 = polygon[j].x + ox;
        int polyY2 = polygon[j].y + oy;

        if (((polyY1 > py) != (polyY2 > py)) &&
            (px < (polyX2 - polyX1) * (py - polyY1) / (polyY2 - polyY1) + polyX1)) {
            c = !c;
        }
    }
    return c;
}

void GenerateAsteroids() {
    int initialAsteroids = 3; // Start with fewer asteroids
    for (int i = 0; i < initialAsteroids; ++i) {
        Asteroid ast;
        ast.x = rand() % WIN_WIDTH;
        ast.y = rand() % WIN_HEIGHT;
        ast.angle = rand() % 360;

        for (int j = 0; j < 8; ++j) {
            int radius = 30 + rand() % 20;
            double angle = j * 45.0 * 3.14159 / 180.0;
            ast.shape[j].x = radius * cos(angle);
            ast.shape[j].y = radius * sin(angle);
        }
        asteroids.push_back(ast);
    }
}

void SpawnNewAsteroid() {
    if (asteroids.size() >= 6) return;

    Asteroid ast;
    // Spawn from edges
    if (rand() % 2 == 0) {
        ast.x = (rand() % 2) * WIN_WIDTH;
        ast.y = rand() % WIN_HEIGHT;
    }
    else {
        ast.x = rand() % WIN_WIDTH;
        ast.y = (rand() % 2) * WIN_HEIGHT;
    }

    // Random angle between 0 and 360
    ast.angle = rand() % 360;

    // Random speed variation
    ast.speed = 1.0 + (rand() % 30) / 10.0; // Speed between 1.0 and 4.0

    for (int j = 0; j < 8; ++j) {
        int radius = 30 + rand() % 20;
        double angle = j * 45.0 * 3.14159 / 180.0;
        ast.shape[j].x = radius * cos(angle);
        ast.shape[j].y = radius * sin(angle);
    }
    asteroids.push_back(ast);
}

// Add this function to initialize the stars (call it once in WinMain before the main loop)
void InitStars() {
    for (int i = 0; i < NUM_STARS; i++) {
        stars[i].x = rand() % WIN_WIDTH;
        stars[i].y = rand() % WIN_HEIGHT;
        stars[i].brightness = 100 + (rand() % 156); // Random brightness between 100-255
    }
}

// Add this function to draw the starfield
void DrawStarfield(HDC hdc) {
    for (int i = 0; i < NUM_STARS; i++) {
        int brightness = stars[i].brightness;
        HPEN starPen = CreatePen(PS_SOLID, 1, RGB(brightness, brightness, brightness));
        HBRUSH starBrush = CreateSolidBrush(RGB(brightness, brightness, brightness));
        SelectObject(hdc, starPen);
        SelectObject(hdc, starBrush);

        // Draw each star as a small circle
        Ellipse(hdc, stars[i].x - 1, stars[i].y - 1,
            stars[i].x + 1, stars[i].y + 1);

        DeleteObject(starPen);
        DeleteObject(starBrush);

        // Optional: make stars twinkle
        if (rand() % 100 < 5) { // 5% chance each frame
            stars[i].brightness = 100 + (rand() % 156);
        }
    }
}
```

==++ Here's the full code for (file 2/2) "resource.h"::: ++==
```resource.h
//{{NO_DEPENDENCIES}}
// Microsoft Visual C++ generated include file.
// Used by AsteroidsImpact.rc
//
#define IDI_ICON1                       101

// Next default values for new objects
//
#ifdef APSTUDIO_INVOKED
#ifndef APSTUDIO_READONLY_SYMBOLS
#define _APS_NEXT_RESOURCE_VALUE        102
#define _APS_NEXT_COMMAND_VALUE         40001
#define _APS_NEXT_CONTROL_VALUE         1001
#define _APS_NEXT_SYMED_VALUE           101
#endif
#endif
```