C++ Projects – Page 16 – Projects Inventory

Network Chat Application Gaming Project in C++

Leave a Comment / C++ Projects / By Projects Inventory

Server Code:

#include <iostream>
#include <thread>
#include <vector>
#include <cstring>
#include <sys/socket.h>
#include <netinet/in.h>
#include <unistd.h>

#define PORT 8080
#define BUFFER_SIZE 1024

void handleClient(int clientSocket) {
    char buffer[BUFFER_SIZE];
    int bytesRead;
    while ((bytesRead = recv(clientSocket, buffer, sizeof(buffer) - 1, 0)) > 0) {
        buffer[bytesRead] = '\0';
        std::cout << "Client: " << buffer << std::endl;
        send(clientSocket, buffer, bytesRead, 0); // Echo back the message
    }
    close(clientSocket);
}

int main() {
    int serverSocket, clientSocket;
    struct sockaddr_in serverAddr, clientAddr;
    socklen_t clientAddrLen = sizeof(clientAddr);

    serverSocket = socket(AF_INET, SOCK_STREAM, 0);
    if (serverSocket == 0) {
        perror("Socket creation failed");
        exit(EXIT_FAILURE);
    }

    serverAddr.sin_family = AF_INET;
    serverAddr.sin_addr.s_addr = INADDR_ANY;
    serverAddr.sin_port = htons(PORT);

    if (bind(serverSocket, (struct sockaddr*)&serverAddr, sizeof(serverAddr)) < 0) {
        perror("Bind failed");
        close(serverSocket);
        exit(EXIT_FAILURE);
    }

    if (listen(serverSocket, 3) < 0) {
        perror("Listen failed");
        close(serverSocket);
        exit(EXIT_FAILURE);
    }

    std::cout << "Server listening on port " << PORT << std::endl;

    while ((clientSocket = accept(serverSocket, (struct sockaddr*)&clientAddr, &clientAddrLen)) >= 0) {
        std::thread(handleClient, clientSocket).detach();
    }

    if (clientSocket < 0) {
        perror("Accept failed");
    }

    close(serverSocket);
    return 0;
}

#include <iostream>

#include <thread>

#include <vector>

#include <cstring>

#include <sys/socket.h>

#include <netinet/in.h>

#include <unistd.h>

#define PORT 8080

#define BUFFER_SIZE 1024

void handleClient(int clientSocket) {

char buffer[BUFFER_SIZE];

int bytesRead;

while ((bytesRead = recv(clientSocket, buffer, sizeof(buffer) - 1, 0)) > 0) {

buffer[bytesRead] = '\0';

std::cout << "Client: " << buffer << std::endl;

send(clientSocket, buffer, bytesRead, 0); // Echo back the message

}

close(clientSocket);

}

int main() {

int serverSocket, clientSocket;

struct sockaddr_in serverAddr, clientAddr;

socklen_t clientAddrLen = sizeof(clientAddr);

serverSocket = socket(AF_INET, SOCK_STREAM, 0);

if (serverSocket == 0) {

perror("Socket creation failed");

exit(EXIT_FAILURE);

}

serverAddr.sin_family = AF_INET;

serverAddr.sin_addr.s_addr = INADDR_ANY;

serverAddr.sin_port = htons(PORT);

if (bind(serverSocket, (struct sockaddr*)&serverAddr, sizeof(serverAddr)) < 0) {

perror("Bind failed");

close(serverSocket);

exit(EXIT_FAILURE);

}

if (listen(serverSocket, 3) < 0) {

perror("Listen failed");

close(serverSocket);

exit(EXIT_FAILURE);

}

std::cout << "Server listening on port " << PORT << std::endl;

while ((clientSocket = accept(serverSocket, (struct sockaddr*)&clientAddr, &clientAddrLen)) >= 0) {

std::thread(handleClient, clientSocket).detach();

}

if (clientSocket < 0) {

perror("Accept failed");

}

close(serverSocket);

return 0;

}

Client Code:

#include <iostream>
#include <cstring>
#include <sys/socket.h>
#include <netinet/in.h>
#include <unistd.h>

#define PORT 8080
#define BUFFER_SIZE 1024

int main() {
    int sock = 0;
    struct sockaddr_in serv_addr;
    char buffer[BUFFER_SIZE] = {0};

    if ((sock = socket(AF_INET, SOCK_STREAM, 0)) < 0) {
        std::cerr << "Socket creation error" << std::endl;
        return -1;
    }

    serv_addr.sin_family = AF_INET;
    serv_addr.sin_port = htons(PORT);

    if (inet_pton(AF_INET, "127.0.0.1", &serv_addr.sin_addr) <= 0) {
        std::cerr << "Invalid address/ Address not supported" << std::endl;
        return -1;
    }

    if (connect(sock, (struct sockaddr*)&serv_addr, sizeof(serv_addr)) < 0) {
        std::cerr << "Connection Failed" << std::endl
        return -1;
    }

    std::cout << "Connected to the server." << std::endl;

    while (true) {
        std::string message;
        std::cout << "Enter message (type 'exit' to quit): ";
        std::getline(std::cin, message);

        if (message == "exit") {
            break;
        }

        send(sock, message.c_str(), message.size(), 0);

        char buffer[BUFFER_SIZE] = {0};
        int bytesRead = recv(sock, buffer, sizeof(buffer) - 1, 0);
        if (bytesRead > 0) {
            buffer[bytesRead] = '\0';
            std::cout << "Server: " << buffer << std::endl;
        } else {
            std::cerr << "Connection closed or error occurred." << std::endl;
            break;
        }
    }

    close(sock);
    return 0;
}

#include <iostream>

#include <cstring>

#include <sys/socket.h>

#include <netinet/in.h>

#include <unistd.h>

#define PORT 8080

#define BUFFER_SIZE 1024

int main() {

int sock = 0;

struct sockaddr_in serv_addr;

char buffer[BUFFER_SIZE] = {0};

if ((sock = socket(AF_INET, SOCK_STREAM, 0)) < 0) {

std::cerr << "Socket creation error" << std::endl;

return -1;

}

serv_addr.sin_family = AF_INET;

serv_addr.sin_port = htons(PORT);

if (inet_pton(AF_INET, "127.0.0.1", &serv_addr.sin_addr) <= 0) {

std::cerr << "Invalid address/ Address not supported" << std::endl;

return -1;

}

if (connect(sock, (struct sockaddr*)&serv_addr, sizeof(serv_addr)) < 0) {

std::cerr << "Connection Failed" << std::endl

return -1;

}

std::cout << "Connected to the server." << std::endl;

while (true) {

std::string message;

std::cout << "Enter message (type 'exit' to quit): ";

std::getline(std::cin, message);

if (message == "exit") {

break;

}

send(sock, message.c_str(), message.size(), 0);

char buffer[BUFFER_SIZE] = {0};

int bytesRead = recv(sock, buffer, sizeof(buffer) - 1, 0);

if (bytesRead > 0) {

buffer[bytesRead] = '\0';

std::cout << "Server: " << buffer << std::endl;

} else {

std::cerr << "Connection closed or error occurred." << std::endl;

break;

}

close(sock);

return 0;

}

Explanation: Server Code: Setup: Creates a socket using socket(). Configures server address serverAddr with AF_INET (IPv4), INADDR_ANY (binds to all available interfaces), and PORT. Binds the socket to the address using bind(). Listens for incoming connections with listen(). Handling Clients: Uses accept() to accept incoming client connections. Spawns a …

Network Chat Application Gaming Project in C++ Read More »

Music Player Gaming Project in C++

Leave a Comment / C++ Projects / By Projects Inventory

#include <iostream>
#include <vector>
#include <string>

// Class representing a Music Track
class MusicTrack {
public:
    MusicTrack(const std::string& title) : title(title) {}
    std::string getTitle() const { return title; }

private:
    std::string title;
};

// Class representing the Music Player
class MusicPlayer {
public:
    void addTrack(const MusicTrack& track) {
        playlist.push_back(track);
    }

    void playTrack(int index) const {
        if (index < 0 || index >= playlist.size()) {
            std::cout << "Invalid track number.\n";
            return;
        }
        std::cout << "Playing: " << playlist[index].getTitle() << "\n";
    }

    void listTracks() const {
        std::cout << "Playlist:\n";
        for (size_t i = 0; i < playlist.size(); ++i) {
            std::cout << i << ". " << playlist[i].getTitle() << "\n";
        }
    }

private:
    std::vector<MusicTrack> playlist;
};

int main() {
    MusicPlayer player;

    // Adding some tracks to the playlist
    player.addTrack(MusicTrack("Song 1 - Artist A"));
    player.addTrack(MusicTrack("Song 2 - Artist B"));
    player.addTrack(MusicTrack("Song 3 - Artist C"));

    int choice;

    do {
        std::cout << "\nMusic Player Menu:\n";
        std::cout << "1. List Tracks\n";
        std::cout << "2. Play Track\n";
        std::cout << "3. Exit\n";
        std::cout << "Enter your choice: ";
        std::cin >> choice;

        switch (choice) {
            case 1:
                player.listTracks();
                break;
            case 2: {
                int trackNumber;
                std::cout << "Enter track number to play: ";
                std::cin >> trackNumber;
                player.playTrack(trackNumber);
                break;
            }
            case 3:
                std::cout << "Exiting the music player.\n";
                break;
            default:
                std::cout << "Invalid choice. Please try again.\n";
                break;
        }
    } while (choice != 3);

    return 0;
}

#include <iostream>

#include <vector>

#include <string>

// Class representing a Music Track

class MusicTrack {

public:

MusicTrack(const std::string& title) : title(title) {}

std::string getTitle() const { return title; }

private:

std::string title;

};

// Class representing the Music Player

class MusicPlayer {

public:

void addTrack(const MusicTrack& track) {

playlist.push_back(track);

}

void playTrack(int index) const {

if (index < 0 || index >= playlist.size()) {

std::cout << "Invalid track number.\n";

return;

}

std::cout << "Playing: " << playlist[index].getTitle() << "\n";

}

void listTracks() const {

std::cout << "Playlist:\n";

for (size_t i = 0; i < playlist.size(); ++i) {

std::cout << i << ". " << playlist[i].getTitle() << "\n";

}

private:

std::vector<MusicTrack> playlist;

};

int main() {

MusicPlayer player;

// Adding some tracks to the playlist

player.addTrack(MusicTrack("Song 1 - Artist A"));

player.addTrack(MusicTrack("Song 2 - Artist B"));

player.addTrack(MusicTrack("Song 3 - Artist C"));

int choice;

do {

std::cout << "\nMusic Player Menu:\n";

std::cout << "1. List Tracks\n";

std::cout << "2. Play Track\n";

std::cout << "3. Exit\n";

std::cout << "Enter your choice: ";

std::cin >> choice;

switch (choice) {

case 1:

player.listTracks();

break;

case 2: {

int trackNumber;

std::cout << "Enter track number to play: ";

std::cin >> trackNumber;

player.playTrack(trackNumber);

break;

}

case 3:

std::cout << "Exiting the music player.\n";

break;

default:

std::cout << "Invalid choice. Please try again.\n";

break;

}

} while (choice != 3);

return 0;

}

Explanation: Classes: MusicTrack: Represents a music track with a title. It has a constructor to set the title and a method to retrieve the title. MusicPlayer: Manages a playlist of MusicTrack objects. It can add tracks, play a specific track, and list all tracks in the playlist. Methods: addTrack: Adds a MusicTrack to the …

Music Player Gaming Project in C++ Read More »

Memory Game Gaming Project in C++

Leave a Comment / C++ Projects / By Projects Inventory

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

// Constants for the game
const int GRID_SIZE = 4; // 4x4 grid
const int NUM_PAIRS = (GRID_SIZE * GRID_SIZE) / 2;

// Function prototypes
void initializeBoard(std::vector<std::vector<char>>& board, std::vector<std::vector<char>>& displayBoard);
void displayBoard(const std::vector<std::vector<char>>& board, const std::vector<std::vector<char>>& displayBoard);
bool isMatch(const std::vector<std::vector<char>>& board, int x1, int y1, int x2, int y2);
bool isBoardComplete(const std::vector<std::vector<char>>& displayBoard);

int main() {
    std::vector<std::vector<char>> board(GRID_SIZE, std::vector<char>(GRID_SIZE));
    std::vector<std::vector<char>> displayBoard(GRID_SIZE, std::vector<char>(GRID_SIZE, '*'));

    initializeBoard(board, displayBoard);

    int x1, y1, x2, y2;
    bool matched;
    int attempts = 0;

    while (!isBoardComplete(displayBoard)) {
        displayBoard(displayBoard, displayBoard);
        std::cout << "Enter coordinates of the first card (row and column): ";
        std::cin >> x1 >> y1;
        std::cout << "Enter coordinates of the second card (row and column): ";
        std::cin >> x2 >> y2;

        if (x1 < 0 || x1 >= GRID_SIZE || y1 < 0 || y1 >= GRID_SIZE ||
            x2 < 0 || x2 >= GRID_SIZE || y2 < 0 || y2 >= GRID_SIZE ||
            (x1 == x2 && y1 == y2)) {
            std::cout << "Invalid input. Try again.\n";
            continue;
        }

        if (isMatch(board, x1, y1, x2, y2)) {
            std::cout << "It's a match!\n";
            displayBoard[x1][y1] = board[x1][y1];
            displayBoard[x2][y2] = board[x2][y2];
        } else {
            std::cout << "Not a match. Try again.\n";
        }
        attempts++;
    }

    displayBoard(displayBoard, displayBoard);
    std::cout << "Congratulations! You matched all pairs in " << attempts << " attempts.\n";

    return 0;
}

void initializeBoard(std::vector<std::vector<char>>& board, std::vector<std::vector<char>>& displayBoard) {
    std::vector<char> cards;
    for (int i = 0; i < NUM_PAIRS; ++i) {
        cards.push_back('A' + i);
        cards.push_back('A' + i);
    }

    std::srand(std::time(0));
    std::random_shuffle(cards.begin(), cards.end());

    for (int i = 0; i < GRID_SIZE; ++i) {
        for (int j = 0; j < GRID_SIZE; ++j) {
            board[i][j] = cards[i * GRID_SIZE + j];
        }
    }
}

void displayBoard(const std::vector<std::vector<char>>& board, const std::vector<std::vector<char>>& displayBoard) {
    std::cout << "  ";
    for (int j = 0; j < GRID_SIZE; ++j) {
        std::cout << j << ' ';
    }
    std::cout << '\n';

    for (int i = 0; i < GRID_SIZE; ++i) {
        std::cout << i << ' ';
        for (int j = 0; j < GRID_SIZE; ++j) {
            std::cout << displayBoard[i][j] << ' ';
        }
        std::cout << '\n';
    }
}

bool isMatch(const std::vector<std::vector<char>>& board, int x1, int y1, int x2, int y2) {
    return board[x1][y1] == board[x2][y2];
}

bool isBoardComplete(const std::vector<std::vector<char>>& displayBoard) {
    for (int i = 0; i < GRID_SIZE; ++i) {
        for (int j = 0; j < GRID_SIZE; ++j) {
            if (displayBoard[i][j] == '*') {
                return false;
            }
        }
    }
    return true;
}

100

101

102

#include <iostream>

#include <vector>

#include <ctime>

#include <cstdlib>

// Constants for the game

const int GRID_SIZE = 4; // 4x4 grid

const int NUM_PAIRS = (GRID_SIZE * GRID_SIZE) / 2;

// Function prototypes

void initializeBoard(std::vector<std::vector<char>>& board, std::vector<std::vector<char>>& displayBoard);

void displayBoard(const std::vector<std::vector<char>>& board, const std::vector<std::vector<char>>& displayBoard);

bool isMatch(const std::vector<std::vector<char>>& board, int x1, int y1, int x2, int y2);

bool isBoardComplete(const std::vector<std::vector<char>>& displayBoard);

int main() {

std::vector<std::vector<char>> board(GRID_SIZE, std::vector<char>(GRID_SIZE));

std::vector<std::vector<char>> displayBoard(GRID_SIZE, std::vector<char>(GRID_SIZE, '*'));

initializeBoard(board, displayBoard);

int x1, y1, x2, y2;

bool matched;

int attempts = 0;

while (!isBoardComplete(displayBoard)) {

displayBoard(displayBoard, displayBoard);

std::cout << "Enter coordinates of the first card (row and column): ";

std::cin >> x1 >> y1;

std::cout << "Enter coordinates of the second card (row and column): ";

std::cin >> x2 >> y2;

if (x1 < 0 || x1 >= GRID_SIZE || y1 < 0 || y1 >= GRID_SIZE ||

x2 < 0 || x2 >= GRID_SIZE || y2 < 0 || y2 >= GRID_SIZE ||

(x1 == x2 && y1 == y2)) {

std::cout << "Invalid input. Try again.\n";

continue;

}

if (isMatch(board, x1, y1, x2, y2)) {

std::cout << "It's a match!\n";

displayBoard[x1][y1] = board[x1][y1];

displayBoard[x2][y2] = board[x2][y2];

} else {

std::cout << "Not a match. Try again.\n";

}

attempts++;

}

displayBoard(displayBoard, displayBoard);

std::cout << "Congratulations! You matched all pairs in " << attempts << " attempts.\n";

return 0;

}

void initializeBoard(std::vector<std::vector<char>>& board, std::vector<std::vector<char>>& displayBoard) {

std::vector<char> cards;

for (int i = 0; i < NUM_PAIRS; ++i) {

cards.push_back('A' + i);

}

std::srand(std::time(0));

std::random_shuffle(cards.begin(), cards.end());

for (int i = 0; i < GRID_SIZE; ++i) {

for (int j = 0; j < GRID_SIZE; ++j) {

board[i][j] = cards[i * GRID_SIZE + j];

}

void displayBoard(const std::vector<std::vector<char>>& board, const std::vector<std::vector<char>>& displayBoard) {

std::cout << " ";

for (int j = 0; j < GRID_SIZE; ++j) {

std::cout << j << ' ';

}

std::cout << '\n';

for (int i = 0; i < GRID_SIZE; ++i) {

std::cout << i << ' ';

for (int j = 0; j < GRID_SIZE; ++j) {

std::cout << displayBoard[i][j] << ' ';

}

std::cout << '\n';

}

bool isMatch(const std::vector<std::vector<char>>& board, int x1, int y1, int x2, int y2) {

return board[x1][y1] == board[x2][y2];

}

bool isBoardComplete(const std::vector<std::vector<char>>& displayBoard) {

for (int i = 0; i < GRID_SIZE; ++i) {

for (int j = 0; j < GRID_SIZE; ++j) {

if (displayBoard[i][j] == '*') {

return false;

}

return true;

}

Explanation: Initialization: initializeBoard: Sets up the game board with pairs of matching cards. Cards are shuffled and placed randomly in the grid. displayBoard: Prints the current state of the board with hidden cards represented by ‘*’ and revealed cards showing their actual values. Game Loop: The main loop runs until all cards are …

Memory Game Gaming Project in C++ Read More »

UDP/TCP Socket Programming Gaming Project in C++

Leave a Comment / C++ Projects / By Projects Inventory

UDP Socket Programming UDP Server

#include <iostream>
#include <cstring>
#include <arpa/inet.h>
#include <unistd.h>

using namespace std;

int main() {
    int sockfd;
    struct sockaddr_in serverAddr, clientAddr;
    char buffer[1024];
    socklen_t addrLen = sizeof(clientAddr);

    // Create UDP socket
    if ((sockfd = socket(AF_INET, SOCK_DGRAM, 0)) < 0) {
        cerr << "Socket creation failed" << endl;
        return -1;
    }

    // Setup server address
    memset(&serverAddr, 0, sizeof(serverAddr));
    serverAddr.sin_family = AF_INET;
    serverAddr.sin_addr.s_addr = INADDR_ANY;
    serverAddr.sin_port = htons(8080);

    // Bind socket to address
    if (bind(sockfd, (const struct sockaddr *)&serverAddr, sizeof(serverAddr)) < 0) {
        cerr << "Bind failed" << endl;
        close(sockfd);
        return -1;
    }

    cout << "UDP Server is listening on port 8080" << endl;

    while (true) {
        int len = recvfrom(sockfd, (char *)buffer, 1024, 0, (struct sockaddr *) &clientAddr, &addrLen);
        buffer[len] = '\0';
        cout << "Client: " << buffer << endl;

        string response = "Message received";
        sendto(sockfd, response.c_str(), response.length(), 0, (struct sockaddr *) &clientAddr, addrLen);
    }

    close(sockfd);
    return 0;
}

#include <iostream>

#include <cstring>

#include <arpa/inet.h>

#include <unistd.h>

using namespace std;

int main() {

int sockfd;

struct sockaddr_in serverAddr, clientAddr;

char buffer[1024];

socklen_t addrLen = sizeof(clientAddr);

// Create UDP socket

if ((sockfd = socket(AF_INET, SOCK_DGRAM, 0)) < 0) {

cerr << "Socket creation failed" << endl;

return -1;

}

// Setup server address

memset(&serverAddr, 0, sizeof(serverAddr));

serverAddr.sin_family = AF_INET;

serverAddr.sin_addr.s_addr = INADDR_ANY;

serverAddr.sin_port = htons(8080);

// Bind socket to address

if (bind(sockfd, (const struct sockaddr *)&serverAddr, sizeof(serverAddr)) < 0) {

cerr << "Bind failed" << endl;

close(sockfd);

return -1;

}

cout << "UDP Server is listening on port 8080" << endl;

while (true) {

int len = recvfrom(sockfd, (char *)buffer, 1024, 0, (struct sockaddr *) &clientAddr, &addrLen);

buffer[len] = '\0';

cout << "Client: " << buffer << endl;

string response = "Message received";

sendto(sockfd, response.c_str(), response.length(), 0, (struct sockaddr *) &clientAddr, addrLen);

}

close(sockfd);

return 0;

}

UDP Client

#include <iostream>
#include <cstring>
#include <arpa/inet.h>
#include <unistd.h>

using namespace std;

int main() {
    int sockfd;
    struct sockaddr_in serverAddr;
    char buffer[1024];
    string message = "Hello from UDP client";

    // Create UDP socket
    if ((sockfd = socket(AF_INET, SOCK_DGRAM, 0)) < 0) {
        cerr << "Socket creation failed" << endl;
        return -1;
    }

    // Setup server address
    memset(&serverAddr, 0, sizeof(serverAddr));
    serverAddr.sin_family = AF_INET;
    serverAddr.sin_addr.s_addr = inet_addr("127.0.0.1");
    serverAddr.sin_port = htons(8080);

    // Send message to server
    sendto(sockfd, message.c_str(), message.length(), 0, (const struct sockaddr *) &serverAddr, sizeof(serverAddr));

    // Receive response from server
    socklen_t len = sizeof(serverAddr);
    int n = recvfrom(sockfd, (char *)buffer, 1024, 0, (struct sockaddr *) &serverAddr, &len);
    buffer[n] = '\0';
    cout << "Server: " << buffer << endl;

    close(sockfd);
    return 0;
}

#include <iostream>

#include <cstring>

#include <arpa/inet.h>

#include <unistd.h>

using namespace std;

int main() {

int sockfd;

struct sockaddr_in serverAddr;

char buffer[1024];

string message = "Hello from UDP client";

// Create UDP socket

if ((sockfd = socket(AF_INET, SOCK_DGRAM, 0)) < 0) {

cerr << "Socket creation failed" << endl;

return -1;

}

// Setup server address

memset(&serverAddr, 0, sizeof(serverAddr));

serverAddr.sin_family = AF_INET;

serverAddr.sin_addr.s_addr = inet_addr("127.0.0.1");

serverAddr.sin_port = htons(8080);

// Send message to server

sendto(sockfd, message.c_str(), message.length(), 0, (const struct sockaddr *) &serverAddr, sizeof(serverAddr));

// Receive response from server

socklen_t len = sizeof(serverAddr);

int n = recvfrom(sockfd, (char *)buffer, 1024, 0, (struct sockaddr *) &serverAddr, &len);

buffer[n] = '\0';

cout << "Server: " << buffer << endl;

close(sockfd);

return 0;

}

TCP Socket Programming TCP Server

#include <iostream>
#include <cstring>
#include <arpa/inet.h>
#include <unistd.h>

using namespace std;

int main() {
    int serverFd, newSocket;
    struct sockaddr_in serverAddr, clientAddr;
    char buffer[1024];
    socklen_t addrLen = sizeof(clientAddr);

    // Create TCP socket
    if ((serverFd = socket(AF_INET, SOCK_STREAM, 0)) == 0) {
        cerr << "Socket creation error" << endl;
        return -1;
    }

    // Setup server address
    memset(&serverAddr, 0, sizeof(serverAddr));
    serverAddr.sin_family = AF_INET;
    serverAddr.sin_addr.s_addr = INADDR_ANY;
    serverAddr.sin_port = htons(8081);

    // Bind socket to address
    if (bind(serverFd, (struct sockaddr *)&serverAddr, sizeof(serverAddr)) < 0) {
        cerr << "Bind failed" << endl;
        close(serverFd);
        return -1;
    }

    // Listen for incoming connections
    if (listen(serverFd, 3) < 0) {
        cerr << "Listen failed" << endl;
        close(serverFd);
        return -1;
    }

    cout << "TCP Server is listening on port 8081" << endl;

    // Accept a connection
    if ((newSocket = accept(serverFd, (struct sockaddr *)&clientAddr, &addrLen)) < 0) {
        cerr << "Accept failed" << endl;
        close(serverFd);
        return -1;
    }

    while (true) {
        int valread = read(newSocket, buffer, 1024);
        buffer[valread] = '\0';
        cout << "Client: " << buffer << endl;

        string response = "Message received";
        send(newSocket, response.c_str(), response.length(), 0);
    }

    close(newSocket);
    close(serverFd);
    return 0;
}

#include <iostream>

#include <cstring>

#include <arpa/inet.h>

#include <unistd.h>

using namespace std;

int main() {

int serverFd, newSocket;

struct sockaddr_in serverAddr, clientAddr;

char buffer[1024];

socklen_t addrLen = sizeof(clientAddr);

// Create TCP socket

if ((serverFd = socket(AF_INET, SOCK_STREAM, 0)) == 0) {

cerr << "Socket creation error" << endl;

return -1;

}

// Setup server address

memset(&serverAddr, 0, sizeof(serverAddr));

serverAddr.sin_family = AF_INET;

serverAddr.sin_addr.s_addr = INADDR_ANY;

serverAddr.sin_port = htons(8081);

// Bind socket to address

if (bind(serverFd, (struct sockaddr *)&serverAddr, sizeof(serverAddr)) < 0) {

cerr << "Bind failed" << endl;

close(serverFd);

return -1;

}

// Listen for incoming connections

if (listen(serverFd, 3) < 0) {

cerr << "Listen failed" << endl;

close(serverFd);

return -1;

}

cout << "TCP Server is listening on port 8081" << endl;

// Accept a connection

if ((newSocket = accept(serverFd, (struct sockaddr *)&clientAddr, &addrLen)) < 0) {

cerr << "Accept failed" << endl;

close(serverFd);

return -1;

}

while (true) {

int valread = read(newSocket, buffer, 1024);

buffer[valread] = '\0';

cout << "Client: " << buffer << endl;

string response = "Message received";

send(newSocket, response.c_str(), response.length(), 0);

}

close(newSocket);

close(serverFd);

return 0;

}

TCP Client

#include <iostream>
#include <cstring>
#include <arpa/inet.h>
#include <unistd.h>

using namespace std;

int main() {
    int sock = 0;
    struct sockaddr_in servAddr;
    char buffer[1024];
    string message = "Hello from TCP client";

    // Create TCP socket
    if ((sock = socket(AF_INET, SOCK_STREAM, 0)) < 0) {
        cerr << "Socket creation error" << endl;
        return -1;
    }

    // Setup server address
    memset(&servAddr, 0, sizeof(servAddr));
    servAddr.sin_family = AF_INET;
    servAddr.sin_port = htons(8081);

    // Convert IP address from text to binary
    if (inet_pton(AF_INET, "127.0.0.1", &servAddr.sin_addr) <= 0) {
        cerr << "Invalid address or address not supported" << endl;
        close(sock);
        return -1;
    }

    // Connect to server
    if (connect(sock, (struct sockaddr *)&servAddr, sizeof(servAddr)) < 0) {
        cerr << "Connection failed" << endl;
        close(sock);
        return -1;
    }

    // Send message to server
    send(sock, message.c_str(), message.length(), 0);

    // Receive response from server
    int valread = read(sock, buffer, 1024);
    buffer[valread] = '\0';
    cout << "Server: " << buffer << endl;

    close(sock);
    return 0;
}

#include <iostream>

#include <cstring>

#include <arpa/inet.h>

#include <unistd.h>

using namespace std;

int main() {

int sock = 0;

struct sockaddr_in servAddr;

char buffer[1024];

string message = "Hello from TCP client";

// Create TCP socket

if ((sock = socket(AF_INET, SOCK_STREAM, 0)) < 0) {

cerr << "Socket creation error" << endl;

return -1;

}

// Setup server address

memset(&servAddr, 0, sizeof(servAddr));

servAddr.sin_family = AF_INET;

servAddr.sin_port = htons(8081);

// Convert IP address from text to binary

if (inet_pton(AF_INET, "127.0.0.1", &servAddr.sin_addr) <= 0) {

cerr << "Invalid address or address not supported" << endl;

close(sock);

return -1;

}

// Connect to server

if (connect(sock, (struct sockaddr *)&servAddr, sizeof(servAddr)) < 0) {

cerr << "Connection failed" << endl;

close(sock);

return -1;

}

// Send message to server

send(sock, message.c_str(), message.length(), 0);

// Receive response from server

int valread = read(sock, buffer, 1024);

buffer[valread] = '\0';

cout << "Server: " << buffer << endl;

close(sock);

return 0;

}

Explanation UDP Programming: UDP Server: Creates a UDP socket, binds it to port 8080, and listens for incoming messages. Receives messages from clients and sends a response. UDP Client: Creates a UDP socket, sends a …

UDP/TCP Socket Programming Gaming Project in C++ Read More »

Video Compression Gaming Project in C++

Leave a Comment / C++ Projects / By Projects Inventory

#include <opencv2/opencv.hpp>
#include <iostream>

using namespace cv;
using namespace std;

int main() {
    // Open video file
    VideoCapture cap("path/to/your/video.mp4");

    if (!cap.isOpened()) {
        cerr << "Error: Could not open video file!" << endl;
        return -1;
    }

    // Get original video properties
    int originalWidth = static_cast<int>(cap.get(CAP_PROP_FRAME_WIDTH));
    int originalHeight = static_cast<int>(cap.get(CAP_PROP_FRAME_HEIGHT));
    int fps = static_cast<int>(cap.get(CAP_PROP_FPS));
    
    // Define compression parameters
    double compressionFactor = 0.5; // Reduce resolution to 50%
    Size newSize(static_cast<int>(originalWidth * compressionFactor),
                 static_cast<int>(originalHeight * compressionFactor));

    // Create video writer for compressed video
    VideoWriter writer("path/to/your/compressed_video.mp4",
                       VideoWriter::fourcc('M', 'J', 'P', 'G'),
                       fps, newSize);

    if (!writer.isOpened()) {
        cerr << "Error: Could not open video writer!" << endl;
        return -1;
    }

    while (true) {
        Mat frame;
        cap >> frame; // Capture a new frame from the video

        if (frame.empty()) {
            break; // Exit loop if there are no more frames
        }

        Mat compressedFrame;
        resize(frame, compressedFrame, newSize); // Resize frame for compression
        writer.write(compressedFrame); // Write the compressed frame to the new video

        imshow("Compressed Video", compressedFrame); // Display the compressed frame

        int keyPressed = waitKey(30); // Wait for 30 ms for a key press
        if (keyPressed == 'q') {
            break; // Exit if 'q' is pressed
        }
    }

    cap.release(); // Release video file
    writer.release(); // Release video writer
    destroyAllWindows(); // Close all OpenCV windows

    return 0;
}

#include <opencv2/opencv.hpp>

#include <iostream>

using namespace cv;

using namespace std;

int main() {

// Open video file

VideoCapture cap("path/to/your/video.mp4");

if (!cap.isOpened()) {

cerr << "Error: Could not open video file!" << endl;

return -1;

}

// Get original video properties

int originalWidth = static_cast<int>(cap.get(CAP_PROP_FRAME_WIDTH));

int originalHeight = static_cast<int>(cap.get(CAP_PROP_FRAME_HEIGHT));

int fps = static_cast<int>(cap.get(CAP_PROP_FPS));

// Define compression parameters

double compressionFactor = 0.5; // Reduce resolution to 50%

Size newSize(static_cast<int>(originalWidth * compressionFactor),

static_cast<int>(originalHeight * compressionFactor));

// Create video writer for compressed video

VideoWriter writer("path/to/your/compressed_video.mp4",

VideoWriter::fourcc('M', 'J', 'P', 'G'),

fps, newSize);

if (!writer.isOpened()) {

cerr << "Error: Could not open video writer!" << endl;

return -1;

}

while (true) {

Mat frame;

cap >> frame; // Capture a new frame from the video

if (frame.empty()) {

break; // Exit loop if there are no more frames

}

Mat compressedFrame;

resize(frame, compressedFrame, newSize); // Resize frame for compression

writer.write(compressedFrame); // Write the compressed frame to the new video

imshow("Compressed Video", compressedFrame); // Display the compressed frame

int keyPressed = waitKey(30); // Wait for 30 ms for a key press

if (keyPressed == 'q') {

break; // Exit if 'q' is pressed

}

cap.release(); // Release video file

writer.release(); // Release video writer

destroyAllWindows(); // Close all OpenCV windows

return 0;

}

Explanation Include Libraries: #include <opencv2/opencv.hpp>: Includes OpenCV for video processing. #include <iostream>: Used for input and output operations. Open Video File: VideoCapture cap(“path/to/your/video.mp4”);: Opens the video file for reading. Checks if the file was opened successfully. If not, prints an error message and exits. Get Original Video Properties: Retrieves the original width, height, and …

Video Compression Gaming Project in C++ Read More »

Video Encryption/Decryption Gaming Project in C++

Leave a Comment / C++ Projects / By Projects Inventory

#include <opencv2/opencv.hpp>
#include <iostream>

using namespace cv;
using namespace std;

// XOR encryption/decryption function
void xorCipher(Mat& frame, char key) {
    frame.forEach<uchar>([&key](uchar& pixel, const int* position) {
        pixel ^= key; // XOR pixel value with key
    });
}

int main() {
    // Open video file
    VideoCapture cap("path/to/your/video.mp4");

    if (!cap.isOpened()) {
        cerr << "Error: Could not open video file!" << endl;
        return -1;
    }

    // Create windows for displaying the original and processed video
    namedWindow("Original Video", WINDOW_AUTOSIZE);
    namedWindow("Encrypted Video", WINDOW_AUTOSIZE);

    char key = 'K'; // Encryption/Decryption key

    while (true) {
        Mat frame;
        cap >> frame; // Capture a new frame from the video

        if (frame.empty()) {
            break; // Exit loop if there are no more frames
        }

        Mat encryptedFrame = frame.clone(); // Clone the frame for encryption
        xorCipher(encryptedFrame, key); // Encrypt the frame

        imshow("Original Video", frame); // Display the original frame
        imshow("Encrypted Video", encryptedFrame); // Display the encrypted frame

        int keyPressed = waitKey(30); // Wait for 30 ms for a key press
        if (keyPressed == 'q') {
            break; // Exit if 'q' is pressed
        }
    }

    cap.release(); // Release video file
    destroyAllWindows(); // Close all OpenCV windows

    return 0;
}

#include <opencv2/opencv.hpp>

#include <iostream>

using namespace cv;

using namespace std;

// XOR encryption/decryption function

void xorCipher(Mat& frame, char key) {

frame.forEach<uchar>([&key](uchar& pixel, const int* position) {

pixel ^= key; // XOR pixel value with key

});

}

int main() {

// Open video file

VideoCapture cap("path/to/your/video.mp4");

if (!cap.isOpened()) {

cerr << "Error: Could not open video file!" << endl;

return -1;

}

// Create windows for displaying the original and processed video

namedWindow("Original Video", WINDOW_AUTOSIZE);

namedWindow("Encrypted Video", WINDOW_AUTOSIZE);

char key = 'K'; // Encryption/Decryption key

while (true) {

Mat frame;

cap >> frame; // Capture a new frame from the video

if (frame.empty()) {

break; // Exit loop if there are no more frames

}

Mat encryptedFrame = frame.clone(); // Clone the frame for encryption

xorCipher(encryptedFrame, key); // Encrypt the frame

imshow("Original Video", frame); // Display the original frame

imshow("Encrypted Video", encryptedFrame); // Display the encrypted frame

int keyPressed = waitKey(30); // Wait for 30 ms for a key press

if (keyPressed == 'q') {

break; // Exit if 'q' is pressed

}

cap.release(); // Release video file

destroyAllWindows(); // Close all OpenCV windows

return 0;

}

Explanation Include Libraries: #include <opencv2/opencv.hpp>: Includes OpenCV for video processing. #include <iostream>: Used for input and output operations. XOR Cipher Function (xorCipher): void xorCipher(Mat& frame, char key): Function that applies XOR encryption/decryption to the video frame. frame.forEach<uchar>([&key](uchar& pixel, const int* position): Iterates through each pixel in the frame and XORs it with the given …

Video Encryption/Decryption Gaming Project in C++ Read More »

Video Player Gaming Project in C++

Leave a Comment / C++ Projects / By Projects Inventory

#include <opencv2/opencv.hpp>
#include <iostream>

using namespace cv;
using namespace std;

int main() {
    // Open video file
    VideoCapture cap("path/to/your/video.mp4");

    if (!cap.isOpened()) {
        cerr << "Error: Could not open video file!" << endl;
        return -1;
    }

    namedWindow("Video Player", WINDOW_AUTOSIZE);

    bool isPaused = false;
    while (true) {
        Mat frame;
        if (!isPaused) {
            cap >> frame; // Capture a new frame from the video

            if (frame.empty()) {
                break; // Exit loop if there are no more frames
            }
        }

        imshow("Video Player", frame); // Display the current frame

        int key = waitKey(30); // Wait for 30 ms for a key press
        if (key == 'q') {
            break; // Exit video player if 'q' is pressed
        } else if (key == 'p') {
            isPaused = !isPaused; // Toggle pause/resume if 'p' is pressed
        }
    }

    cap.release(); // Release video file
    destroyAllWindows(); // Close all OpenCV windows

    return 0;
}

#include <opencv2/opencv.hpp>

#include <iostream>

using namespace cv;

using namespace std;

int main() {

// Open video file

VideoCapture cap("path/to/your/video.mp4");

if (!cap.isOpened()) {

cerr << "Error: Could not open video file!" << endl;

return -1;

}

namedWindow("Video Player", WINDOW_AUTOSIZE);

bool isPaused = false;

while (true) {

Mat frame;

if (!isPaused) {

cap >> frame; // Capture a new frame from the video

if (frame.empty()) {

break; // Exit loop if there are no more frames

}

imshow("Video Player", frame); // Display the current frame

int key = waitKey(30); // Wait for 30 ms for a key press

if (key == 'q') {

break; // Exit video player if 'q' is pressed

} else if (key == 'p') {

isPaused = !isPaused; // Toggle pause/resume if 'p' is pressed

}

cap.release(); // Release video file

destroyAllWindows(); // Close all OpenCV windows

return 0;

}

Explanation Include Libraries: #include <opencv2/opencv.hpp>: Includes OpenCV for video processing. #include <iostream>: Used for input and output operations. Open Video File: VideoCapture cap(“path/to/your/video.mp4”);: Opens the video file for reading. Checks if the file was opened successfully. If not, prints an error message and exits. Create Window: namedWindow(“Video Player”, WINDOW_AUTOSIZE);: Creates a window to display …

Video Player Gaming Project in C++ Read More »

Video Streaming Application Gaming Project in C++

Leave a Comment / C++ Projects / By Projects Inventory

#include <opencv2/opencv.hpp>
#include <iostream>

using namespace cv;
using namespace std;

int main() {
    // Open video file
    VideoCapture cap("path/to/your/video.mp4");

    if (!cap.isOpened()) {
        cerr << "Error: Could not open video file!" << endl;
        return -1;
    }

    namedWindow("Video Stream", WINDOW_AUTOSIZE);

    while (true) {
        Mat frame;
        cap >> frame; // Capture a new frame from the video

        if (frame.empty()) {
            break; // Exit loop if there are no more frames
        }

        imshow("Video Stream", frame); // Display the current frame

        // Exit video stream if 'q' is pressed
        if (waitKey(30) == 'q') {
            break;
        }
    }

    cap.release(); // Release video file
    destroyAllWindows(); // Close all OpenCV windows

    return 0;
}

#include <opencv2/opencv.hpp>

#include <iostream>

using namespace cv;

using namespace std;

int main() {

// Open video file

VideoCapture cap("path/to/your/video.mp4");

if (!cap.isOpened()) {

cerr << "Error: Could not open video file!" << endl;

return -1;

}

namedWindow("Video Stream", WINDOW_AUTOSIZE);

while (true) {

Mat frame;

cap >> frame; // Capture a new frame from the video

if (frame.empty()) {

break; // Exit loop if there are no more frames

}

imshow("Video Stream", frame); // Display the current frame

// Exit video stream if 'q' is pressed

if (waitKey(30) == 'q') {

break;

}

cap.release(); // Release video file

destroyAllWindows(); // Close all OpenCV windows

return 0;

}

Explanation Include Libraries: #include <opencv2/opencv.hpp> includes the OpenCV library for video processing. #include <iostream> is used for input and output operations. Open Video File: VideoCapture cap(“path/to/your/video.mp4”); opens the video file for reading. Checks if the file was opened successfully. If not, prints an error message and exits. Create Window: namedWindow(“Video Stream”, WINDOW_AUTOSIZE); creates a …

Video Streaming Application Gaming Project in C++ Read More »

Gaming Project in C++

Leave a Comment / C++ Projects / By Projects Inventory

#include <iostream>
#include <cstdlib>
#include <ctime>

using namespace std;

int main() {
    // Initialize random seed
    srand(static_cast<unsigned>(time(0)));

    // Generate a random number between 1 and 100
    int numberToGuess = rand() % 100 + 1;
    int userGuess = 0;
    int numberOfTries = 0;

    cout << "Welcome to Guess the Number Game!" << endl;
    cout << "I have selected a number between 1 and 100." << endl;
    cout << "Can you guess what it is?" << endl;

    while (userGuess != numberToGuess) {
        cout << "Enter your guess: ";
        cin >> userGuess;
        numberOfTries++;

        if (userGuess > numberToGuess) {
            cout << "Too high! Try again." << endl;
        } else if (userGuess < numberToGuess) {
            cout << "Too low! Try again." << endl;
        } else {
            cout << "Congratulations! You guessed the number in " << numberOfTries << " tries." << endl;
        }
    }

    return 0;
}

#include <iostream>

#include <cstdlib>

#include <ctime>

using namespace std;

int main() {

// Initialize random seed

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

// Generate a random number between 1 and 100

int numberToGuess = rand() % 100 + 1;

int userGuess = 0;

int numberOfTries = 0;

cout << "Welcome to Guess the Number Game!" << endl;

cout << "I have selected a number between 1 and 100." << endl;

cout << "Can you guess what it is?" << endl;

while (userGuess != numberToGuess) {

cout << "Enter your guess: ";

cin >> userGuess;

numberOfTries++;

if (userGuess > numberToGuess) {

cout << "Too high! Try again." << endl;

} else if (userGuess < numberToGuess) {

cout << "Too low! Try again." << endl;

} else {

cout << "Congratulations! You guessed the number in " << numberOfTries << " tries." << endl;

}

return 0;

}

Explanation Initialize Random Seed: srand(static_cast<unsigned>(time(0))); initializes the random number generator with the current time to ensure different sequences of random numbers each time the program runs. Generate Random Number: int numberToGuess = rand() % 100 + 1; generates a random number between 1 and 100 for the player to guess. Game Loop: The loop …

Gaming Project in C++ Read More »

Maze Solver Gaming Project in C++

Leave a Comment / C++ Projects / By Projects Inventory

#include <iostream>
#include <vector>
#include <queue>

using namespace std;

const int ROW = 5;
const int COL = 5;

// Function to check if a cell is within bounds and not yet visited
bool isValid(int row, int col, vector<vector<int>>& maze, vector<vector<bool>>& visited) {
    return (row >= 0 && row < ROW && col >= 0 && col < COL && maze[row][col] == 0 && !visited[row][col]);
}

// Function to print the solution path
void printPath(const vector<vector<int>>& path) {
    for (const auto& row : path) {
        for (int cell : row) {
            cout << (cell ? '*' : ' ') << ' ';
        }
        cout << endl;
    }
}

// Function to solve the maze using BFS
bool solveMaze(vector<vector<int>>& maze) {
    // Directions for moving in the maze (right, down, left, up)
    vector<pair<int, int>> directions = {{0, 1}, {1, 0}, {0, -1}, {-1, 0}};
    
    vector<vector<bool>> visited(ROW, vector<bool>(COL, false));
    vector<vector<int>> path(ROW, vector<int>(COL, 0));

    queue<pair<int, int>> q;
    q.push({0, 0});
    visited[0][0] = true;
    path[0][0] = 1;

    while (!q.empty()) {
        auto [currentRow, currentCol] = q.front();
        q.pop();

        if (currentRow == ROW - 1 && currentCol == COL - 1) {
            printPath(path);
            return true;
        }

        for (const auto& dir : directions) {
            int newRow = currentRow + dir.first;
            int newCol = currentCol + dir.second;

            if (isValid(newRow, newCol, maze, visited)) {
                q.push({newRow, newCol});
                visited[newRow][newCol] = true;
                path[newRow][newCol] = 1;
            }
        }
    }
    return false;
}

int main() {
    // Define a maze where 0 represents a free cell and 1 represents a blocked cell
    vector<vector<int>> maze = {
        {0, 1, 0, 0, 0},
        0, 1, 0, 1, 0,
        0, 0, 0, 1, 0,
        1, 1, 0, 1, 0,
        0, 0, 0, 0, 0
    };

    cout << "Maze Path:" << endl;
    if (!solveMaze(maze)) {
        cout << "No path found!" << endl;
    }

    return 0;
}

#include <iostream>

#include <vector>

#include <queue>

using namespace std;

const int ROW = 5;

const int COL = 5;

// Function to check if a cell is within bounds and not yet visited

bool isValid(int row, int col, vector<vector<int>>& maze, vector<vector<bool>>& visited) {

return (row >= 0 && row < ROW && col >= 0 && col < COL && maze[row][col] == 0 && !visited[row][col]);

}

// Function to print the solution path

void printPath(const vector<vector<int>>& path) {

for (const auto& row : path) {

for (int cell : row) {

cout << (cell ? '*' : ' ') << ' ';

}

cout << endl;

}

// Function to solve the maze using BFS

bool solveMaze(vector<vector<int>>& maze) {

// Directions for moving in the maze (right, down, left, up)

vector<pair<int, int>> directions = {{0, 1}, {1, 0}, {0, -1}, {-1, 0}};

vector<vector<bool>> visited(ROW, vector<bool>(COL, false));

vector<vector<int>> path(ROW, vector<int>(COL, 0));

queue<pair<int, int>> q;

q.push({0, 0});

visited[0][0] = true;

path[0][0] = 1;

while (!q.empty()) {

auto [currentRow, currentCol] = q.front();

q.pop();

if (currentRow == ROW - 1 && currentCol == COL - 1) {

printPath(path);

return true;

}

for (const auto& dir : directions) {

int newRow = currentRow + dir.first;

int newCol = currentCol + dir.second;

if (isValid(newRow, newCol, maze, visited)) {

q.push({newRow, newCol});

visited[newRow][newCol] = true;

path[newRow][newCol] = 1;

}

return false;

}

int main() {

// Define a maze where 0 represents a free cell and 1 represents a blocked cell

vector<vector<int>> maze = {

{0, 1, 0, 0, 0},

0, 1, 0, 1, 0,

0, 0, 0, 1, 0,

1, 1, 0, 1, 0,

0, 0, 0, 0, 0

};

cout << "Maze Path:" << endl;

if (!solveMaze(maze)) {

cout << "No path found!" << endl;

}

return 0;

}

Explanation Maze Representation: 0 represents a free cell. 1 represents a blocked cell. isValid Function: Checks if a cell is within maze bounds, not blocked, and not yet visited. printPath Function: Prints the solution path where 1 represents the path and 0 represents non-path cells. solveMaze Function: Uses Breadth-First Search (BFS) to find the …

Maze Solver Gaming Project in C++ Read More »