2D-Racing-Game.cpp

#include <iostream>
#include <string>
#include <vector>
#include <cstdlib>
#include <ctime>

#ifdef _WIN32
    #include <conio.h>
    #include <windows.h>
    #ifndef ENABLE_VIRTUAL_TERMINAL_PROCESSING
        #define ENABLE_VIRTUAL_TERMINAL_PROCESSING 0x0004
    #endif
#else
    #include <termios.h>
    #include <unistd.h>
    #include <sys/select.h>
#endif

using namespace std;

const int roadWidth = 17; // Inner road width
const int screenHeight = 22;

// Coordinates
int playerX;
const int playerY = screenHeight - 4; // Fixed near the bottom

// Enemy settings
const int maxEnemies = 3;
int enemyX[maxEnemies];
int enemyY[maxEnemies];
bool enemyActive[maxEnemies];

// Game State
bool gameOver = false;
int score = 0;
int roadScroll = 0;
int spawnTimer = 0;

// ANSI Colors
const string RESET   = "\033[0m";
const string RED     = "\033[1;31m";
const string GREEN   = "\033[1;32m";
const string YELLOW  = "\033[1;33m";
const string BLUE    = "\033[1;34m";
const string WHITE   = "\033[1;37m";
const string GRAY    = "\033[1;30m";

void HideCursor() {
#ifdef _WIN32
    HANDLE hOut = GetStdHandle(STD_OUTPUT_HANDLE);
    CONSOLE_CURSOR_INFO cursorInfo;
    GetConsoleCursorInfo(hOut, &cursorInfo);
    cursorInfo.bVisible = false;
    SetConsoleCursorInfo(hOut, &cursorInfo);
#else
    cout << "\033[?25l";
#endif
}

void ShowCursor() {
#ifdef _WIN32
    HANDLE hOut = GetStdHandle(STD_OUTPUT_HANDLE);
    CONSOLE_CURSOR_INFO cursorInfo;
    GetConsoleCursorInfo(hOut, &cursorInfo);
    cursorInfo.bVisible = true;
    SetConsoleCursorInfo(hOut, &cursorInfo);
#else
    cout << "\033[?25h";
#endif
}

void Setup() {
    playerX = roadWidth / 2 + 1; // Start in middle lane
    for (int i = 0; i < maxEnemies; i++) {
        enemyActive[i] = false;
    }
    HideCursor();
}

void SpawnEnemy() {
    for (int i = 0; i < maxEnemies; i++) {
        if (!enemyActive[i]) {
            // Spawn in one of three lanes: Left (3), Middle (8), Right (13)
            int lane = rand() % 3;
            if (lane == 0) enemyX[i] = 3;
            else if (lane == 1) enemyX[i] = 8;
            else enemyX[i] = 13;

            enemyY[i] = -3; // Start just above the screen boundary
            enemyActive[i] = true;
            break;
        }
    }
}

void Draw() {
    string frame = "";

#ifdef _WIN32
    SetConsoleCursorPosition(GetStdHandle(STD_OUTPUT_HANDLE), {0, 0});
#else
    frame += "\033[H";
#endif

    // Top Boundary
    frame += YELLOW + "=========================\n" + RESET;

    for (int y = 0; y < screenHeight; y++) {
        // Red and White striped road borders that scroll
        if ((y + roadScroll) % 4 < 2) {
            frame += RED + "║ " + RESET; // Left Border stripe 1
        } else {
            frame += WHITE + "║ " + RESET; // Left Border stripe 2
        }

        for (int x = 1; x <= roadWidth; x++) {
            bool pixelDrawn = false;

            // 1. Draw Player Car (Blue body, White wheels)
            // Center is playerX, occupying y to y+2
            if (y >= playerY && y <= playerY + 2 && x >= playerX - 1 && x <= playerX + 1) {
                int localY = y - playerY;
                int localX = x - (playerX - 1);

                if (localY == 0) { // Front wheels
                    if (localX == 0 || localX == 2) frame += WHITE + "o" + RESET;
                    else frame += " ";
                } else if (localY == 1) { // Engine & Cabin
                    if (localX == 0) frame += BLUE + "[" + RESET;
                    else if (localX == 1) frame += BLUE + "A" + RESET;
                    else frame += BLUE + "]" + RESET;
                } else if (localY == 2) { // Rear wheels
                    if (localX == 0 || localX == 2) frame += WHITE + "o" + RESET;
                    else frame += BLUE + "-" + RESET;
                }
                pixelDrawn = true;
            }

            // 2. Draw Enemy Cars (Red body, Yellow wheels)
            if (!pixelDrawn) {
                for (int i = 0; i < maxEnemies; i++) {
                    if (enemyActive[i]) {
                        if (y >= enemyY[i] && y <= enemyY[i] + 2 && x >= enemyX[i] - 1 && x <= enemyX[i] + 1) {
                            int localY = y - enemyY[i];
                            int localX = x - (enemyX[i] - 1);

                            if (localY == 0) { // Front wheels
                                if (localX == 0 || localX == 2) frame += YELLOW + "o" + RESET;
                                else frame += RED + "-" + RESET;
                            } else if (localY == 1) { // Engine / Cabin
                                if (localX == 0) frame += RED + "[" + RESET;
                                else if (localX == 1) frame += RED + "V" + RESET;
                                else frame += RED + "]" + RESET;
                            } else if (localY == 2) { // Rear wheels
                                if (localX == 0 || localX == 2) frame += YELLOW + "o" + RESET;
                                else frame += " ";
                            }
                            pixelDrawn = true;
                            break;
                        }
                    }
                }
            }

            // 3. Draw Road Lane Markings
            if (!pixelDrawn) {
                // Dashed lines dividing the 3 lanes at X = 6 and X = 12
                if (x == 6 || x == 12) {
                    if ((y + roadScroll) % 4 < 2) {
                        frame += WHITE + "|" + RESET;
                    } else {
                        frame += " ";
                    }
                } else {
                    frame += " "; // Empty asphalt road space
                }
            }
        }

        // Right Border
        if ((y + roadScroll) % 4 < 2) {
            frame += RED + " ║\n" + RESET;
        } else {
            frame += WHITE + " ║\n" + RESET;
        }
    }

    // Bottom Boundary
    frame += YELLOW + "=========================\n" + RESET;

    // HUD Display
    frame += " Score: " + GREEN + to_string(score) + RESET + " pts       \n";
    frame += " Controls: " + WHITE + "A" + RESET + " = Left, " + WHITE + "D" + RESET + " = Right, " + RED + "Esc" + RESET + " = Exit\n";

    cout << frame << flush;
}

void Input() {
#ifdef _WIN32
    if (_kbhit()) {
        switch (_getch()) {
            case 'a':
            case 'A':
                if (playerX > 2) playerX -= 5; // Move exactly one lane left
                break;
            case 'd':
            case 'D':
                if (playerX < roadWidth - 2) playerX += 5; // Move exactly one lane right
                break;
            case 27: // Escape key
                gameOver = true;
                break;
        }
    }
#else
    struct termios oldt, newt;
    tcgetattr(STDIN_FILENO, &oldt);
    newt = oldt;
    newt.c_lflag &= ~(ICANON | ECHO);
    tcsetattr(STDIN_FILENO, TCSANOW, &newt);

    fd_set rfds;
    FD_ZERO(&rfds);
    FD_SET(STDIN_FILENO, &rfds);
    struct timeval tv = {0, 0};

    if (select(1, &rfds, NULL, NULL, &tv) > 0) {
        char ch = getchar();
        switch (ch) {
            case 'a':
            case 'A':
                if (playerX > 2) playerX -= 5;
                break;
            case 'd':
            case 'D':
                if (playerX < roadWidth - 2) playerX += 5;
                break;
            case 27:
                gameOver = true;
                break;
        }
    }
    tcsetattr(STDIN_FILENO, TCSANOW, &oldt);
#endif
}

void Logic() {
    // 1. Scroll the road
    roadScroll++;
    score++; // Survival points

    // 2. Spawn incoming enemies
    spawnTimer++;
    if (spawnTimer >= 12) { // Adjust spawn frequency
        spawnTimer = 0;
        SpawnEnemy();
    }

    // 3. Update Enemy Positions and check collisions
    for (int i = 0; i < maxEnemies; i++) {
        if (enemyActive[i]) {
            enemyY[i]++; // Move downward

            // Deactivate enemy if it goes off screen
            if (enemyY[i] > screenHeight) {
                enemyActive[i] = false;
            }

            // Bounding box collision checking (Both cars are 3x3)
            if (abs(playerX - enemyX[i]) < 3 && abs(playerY - enemyY[i]) < 3) {
                gameOver = true;
            }
        }
    }
}

int main() {
    srand(time(nullptr));

#ifdef _WIN32
    // Setup Virtual Terminal Escapes for CMD/PowerShell Colors
    HANDLE hOut = GetStdHandle(STD_OUTPUT_HANDLE);
    DWORD dwMode = 0;
    GetConsoleMode(hOut, &dwMode);
    dwMode |= ENABLE_VIRTUAL_TERMINAL_PROCESSING;
    SetConsoleMode(hOut, dwMode);
    
    system("cls");
#else
    cout << "\033[2J";
#endif

    Setup();

    while (!gameOver) {
        Draw();
        Input();
        Logic();

#ifdef _WIN32
        Sleep(50); // Frame delay (approx 20 FPS)
#else
        usleep(50000);
#endif
    }

    ShowCursor();
    
    // Game Over Crash screen
    cout << "\n" << RED << "  CRASH!!! GAME OVER! " << RESET << "\n";
    cout << "  Final Score: " << GREEN << score << RESET << " pts\n\n";
    return 0;
}