C++ Projects – Page 18 – Projects Inventory

Game of Life (Graphics Version) Gaming Project in C++

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

#include <SFML/Graphics.hpp>
#include <vector>

using namespace std;
using namespace sf;

// Function to update the grid based on the Game of Life rules
void updateGrid(vector<vector<bool>>& grid) {
    int rows = grid.size();
    int cols = grid[0].size();
    vector<vector<bool>> newGrid(rows, vector<bool>(cols, false));

    // Helper function to count live neighbors
    auto countLiveNeighbors = [&](int x, int y) {
        int count = 0;
        for (int i = -1; i <= 1; ++i) {
            for (int j = -1; j <= 1; ++j) {
                if (i == 0 && j == 0) continue;
                int ni = x + i, nj = y + j;
                if (ni >= 0 && ni < rows && nj >= 0 && nj < cols && grid[ni][nj]) {
                    ++count;
                }
            }
        }
        return count;
    };

    // Update each cell based on its neighbors
    for (int x = 0; x < rows; ++x) {
        for (int y = 0; y < cols; ++y) {
            int liveNeighbors = countLiveNeighbors(x, y);
            if (grid[x][y]) {
                newGrid[x][y] = (liveNeighbors == 2 || liveNeighbors == 3);
            } else {
                newGrid[x][y] = (liveNeighbors == 3);
            }
        }
    }

    grid = newGrid;
}

// Main function
int main() {
    const int cellSize = 10;
    const int width = 80;
    const int height = 60;
    const int windowWidth = width * cellSize;
    const int windowHeight = height * cellSize;

    // Create the window
    RenderWindow window(VideoMode(windowWidth, windowHeight), "Game of Life");

    // Initialize grid
    vector<vector<bool>> grid(height, vector<bool>(width, false));
    // Set initial pattern (glider)
    grid[10][10] = true;
    grid[10][11] = true;
    grid[10][12] = true;
    grid[11][12] = true;
    grid[12][11] = true;

    Clock clock;
    float elapsed = 0;
    float interval = 0.1f; // Update interval in seconds

    while (window.isOpen()) {
        // Event handling
        Event event;
        while (window.pollEvent(event)) {
            if (event.type == Event::Closed)
                window.close();
        }

        // Update the grid at regular intervals
        elapsed += clock.restart().asSeconds();
        if (elapsed >= interval) {
            elapsed = 0;
            updateGrid(grid);
        }

        // Clear the window
        window.clear(Color::White);

        // Draw the grid
        for (int x = 0; x < height; ++x) {
            for (int y = 0; y < width; ++y) {
                RectangleShape cell(Vector2f(cellSize, cellSize));
                cell.setPosition(y * cellSize, x * cellSize);
                cell.setFillColor(grid[x][y] ? Color::Black : Color::White);
                window.draw(cell);
            }
        }

        // Display the updated window
        window.display();
    }

    return 0;
}

100

#include <SFML/Graphics.hpp>

#include <vector>

using namespace std;

using namespace sf;

// Function to update the grid based on the Game of Life rules

void updateGrid(vector<vector<bool>>& grid) {

int rows = grid.size();

int cols = grid[0].size();

vector<vector<bool>> newGrid(rows, vector<bool>(cols, false));

// Helper function to count live neighbors

auto countLiveNeighbors = [&](int x, int y) {

int count = 0;

for (int i = -1; i <= 1; ++i) {

for (int j = -1; j <= 1; ++j) {

if (i == 0 && j == 0) continue;

int ni = x + i, nj = y + j;

if (ni >= 0 && ni < rows && nj >= 0 && nj < cols && grid[ni][nj]) {

++count;

}

return count;

};

// Update each cell based on its neighbors

for (int x = 0; x < rows; ++x) {

for (int y = 0; y < cols; ++y) {

int liveNeighbors = countLiveNeighbors(x, y);

if (grid[x][y]) {

newGrid[x][y] = (liveNeighbors == 2 || liveNeighbors == 3);

} else {

newGrid[x][y] = (liveNeighbors == 3);

}

grid = newGrid;

}

// Main function

int main() {

const int cellSize = 10;

const int width = 80;

const int height = 60;

const int windowWidth = width * cellSize;

const int windowHeight = height * cellSize;

// Create the window

RenderWindow window(VideoMode(windowWidth, windowHeight), "Game of Life");

// Initialize grid

vector<vector<bool>> grid(height, vector<bool>(width, false));

// Set initial pattern (glider)

grid[10][10] = true;

grid[10][11] = true;

grid[10][12] = true;

grid[11][12] = true;

grid[12][11] = true;

Clock clock;

float elapsed = 0;

float interval = 0.1f; // Update interval in seconds

while (window.isOpen()) {

// Event handling

Event event;

while (window.pollEvent(event)) {

if (event.type == Event::Closed)

window.close();

}

// Update the grid at regular intervals

elapsed += clock.restart().asSeconds();

if (elapsed >= interval) {

elapsed = 0;

updateGrid(grid);

}

// Clear the window

window.clear(Color::White);

// Draw the grid

for (int x = 0; x < height; ++x) {

for (int y = 0; y < width; ++y) {

RectangleShape cell(Vector2f(cellSize, cellSize));

cell.setPosition(y * cellSize, x * cellSize);

cell.setFillColor(grid[x][y] ? Color::Black : Color::White);

window.draw(cell);

}

// Display the updated window

window.display();

}

return 0;

}

Explanation: Game of Life Rules (updateGrid): The updateGrid function updates the grid according to Conway’s Game of Life rules: A live cell with 2 or 3 live neighbors remains alive; otherwise, it dies. A dead cell with exactly 3 live neighbors becomes alive. Neighbor Counting (countLiveNeighbors): A lambda function counts the number of live …

Game of Life (Graphics Version) Gaming Project in C++ Read More »

Floyd-Warshall Algorithm Gaming Project in C++

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

#include <iostream>
#include <vector>
#include <limits>

using namespace std;

const int INF = numeric_limits<int>::max(); // Define a large value for infinity

// Function to perform Floyd-Warshall algorithm
void floydWarshall(vector<vector<int>>& graph) {
    int V = graph.size();

    // Initialize distance matrix
    vector<vector<int>> dist = graph;

    // Floyd-Warshall algorithm
    for (int k = 0; k < V; ++k) {
        for (int i = 0; i < V; ++i) {
            for (int j = 0; j < V; ++j) {
                if (dist[i][k] != INF && dist[k][j] != INF) {
                    dist[i][j] = min(dist[i][j], dist[i][k] + dist[k][j]);
                }
            }
        }
    }

    // Print the distance matrix
    cout << "Shortest distances between every pair of vertices:" << endl;
    for (int i = 0; i < V; ++i) {
        for (int j = 0; j < V; ++j) {
            if (dist[i][j] == INF) {
                cout << "INF ";
            } else {
                cout << dist[i][j] << " ";
            }
        }
        cout << endl;
    }
}

int main() {
    int V; // Number of vertices
    cout << "Enter the number of vertices: ";
    cin >> V;

    vector<vector<int>> graph(V, vector<int>(V, INF));

    cout << "Enter the adjacency matrix (use " << INF << " for infinity):" << endl;
    for (int i = 0; i < V; ++i) {
        for (int j = 0; j < V; ++j) {
            cin >> graph[i][j];
        }
    }

    floydWarshall(graph);

    return 0;
}

#include <iostream>

#include <vector>

#include <limits>

using namespace std;

const int INF = numeric_limits<int>::max(); // Define a large value for infinity

// Function to perform Floyd-Warshall algorithm

void floydWarshall(vector<vector<int>>& graph) {

int V = graph.size();

// Initialize distance matrix

vector<vector<int>> dist = graph;

// Floyd-Warshall algorithm

for (int k = 0; k < V; ++k) {

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

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

if (dist[i][k] != INF && dist[k][j] != INF) {

dist[i][j] = min(dist[i][j], dist[i][k] + dist[k][j]);

}

// Print the distance matrix

cout << "Shortest distances between every pair of vertices:" << endl;

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

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

if (dist[i][j] == INF) {

cout << "INF ";

} else {

cout << dist[i][j] << " ";

}

cout << endl;

}

int main() {

int V; // Number of vertices

cout << "Enter the number of vertices: ";

cin >> V;

vector<vector<int>> graph(V, vector<int>(V, INF));

cout << "Enter the adjacency matrix (use " << INF << " for infinity):" << endl;

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

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

cin >> graph[i][j];

}

floydWarshall(graph);

return 0;

}

Explanation: Constants and Data Structures: INF is defined as a large value to represent infinity, indicating no direct path between vertices. graph is a 2D vector where graph[i][j] represents the weight of the edge from vertex i to vertex j. Floyd-Warshall Algorithm (floydWarshall): Initializes a distance matrix dist with the values from the input …

Floyd-Warshall Algorithm Gaming Project in C++ Read More »

File Handling: Read/Write to File Gaming Project in C++

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

#include <iostream>
#include <fstream>
#include <vector>

using namespace std;

// Function to read integers from a file
vector<int> readIntegersFromFile(const string& filename) {
    ifstream file(filename);
    if (!file) {
        cerr << "Error opening file for reading: " << filename << endl;
        exit(1);
    }

    vector<int> numbers;
    int number;
    while (file >> number) {
        numbers.push_back(number);
    }

    file.close();
    return numbers;
}

// Function to write the sum to a file
void writeSumToFile(const string& filename, int sum) {
    ofstream file(filename);
    if (!file) {
        cerr << "Error opening file for writing: " << filename << endl;
        exit(1);
    }

    file << "Sum of integers: " << sum << endl;
    file.close();
}

int main() {
    string inputFilename, outputFilename;

    cout << "Enter the input file name: ";
    cin >> inputFilename;
    cout << "Enter the output file name: ";
    cin >> outputFilename;

    // Read integers from the input file
    vector<int> numbers = readIntegersFromFile(inputFilename);

    // Calculate the sum of integers
    int sum = 0;
    for (int number : numbers) {
        sum += number;
    }

    // Write the sum to the output file
    writeSumToFile(outputFilename, sum);

    cout << "Sum calculation complete. Check the output file: " << outputFilename << endl;

    return 0;
}

#include <iostream>

#include <fstream>

#include <vector>

using namespace std;

// Function to read integers from a file

vector<int> readIntegersFromFile(const string& filename) {

ifstream file(filename);

if (!file) {

cerr << "Error opening file for reading: " << filename << endl;

exit(1);

}

vector<int> numbers;

int number;

while (file >> number) {

numbers.push_back(number);

}

file.close();

return numbers;

}

// Function to write the sum to a file

void writeSumToFile(const string& filename, int sum) {

ofstream file(filename);

if (!file) {

cerr << "Error opening file for writing: " << filename << endl;

exit(1);

}

file << "Sum of integers: " << sum << endl;

file.close();

}

int main() {

string inputFilename, outputFilename;

cout << "Enter the input file name: ";

cin >> inputFilename;

cout << "Enter the output file name: ";

cin >> outputFilename;

// Read integers from the input file

vector<int> numbers = readIntegersFromFile(inputFilename);

// Calculate the sum of integers

int sum = 0;

for (int number : numbers) {

sum += number;

}

// Write the sum to the output file

writeSumToFile(outputFilename, sum);

cout << "Sum calculation complete. Check the output file: " << outputFilename << endl;

return 0;

}

Explanation: Reading from a File (readIntegersFromFile): Opens a file for reading using an ifstream. Checks if the file was successfully opened. Reads integers from the file and stores them in a vector<int>. Closes the file and returns the vector of integers. Writing to a File (writeSumToFile): Opens a file for writing using an ofstream. …

File Handling: Read/Write to File Gaming Project in C++ Read More »

Face Detection Gaming Project in C++

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

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

using namespace std;
using namespace cv;

int main() {
    // Load the pre-trained Haar Cascade classifier for face detection
    CascadeClassifier faceCascade;
    if (!faceCascade.load("haarcascade_frontalface_default.xml")) {
        cerr << "Error loading Haar Cascade classifier!" << endl;
        return -1;
    }

    // Open an image file
    Mat image = imread("input_image.jpg");
    if (image.empty()) {
        cerr << "Error loading image!" << endl;
        return -1;
    }

    // Convert the image to grayscale
    Mat grayImage;
    cvtColor(image, grayImage, COLOR_BGR2GRAY);

    // Detect faces in the grayscale image
    vector<Rect> faces;
    faceCascade.detectMultiScale(grayImage, faces);

    // Draw rectangles around detected faces
    for (const auto& face : faces) {
        rectangle(image, face, Scalar(255, 0, 0), 2); // Blue rectangles
    }

    // Display the result
    imshow("Face Detection", image);
    waitKey(0); // Wait for a key press before closing the window

    return 0;
}

#include <opencv2/opencv.hpp>

#include <iostream>

using namespace std;

using namespace cv;

int main() {

// Load the pre-trained Haar Cascade classifier for face detection

CascadeClassifier faceCascade;

if (!faceCascade.load("haarcascade_frontalface_default.xml")) {

cerr << "Error loading Haar Cascade classifier!" << endl;

return -1;

}

// Open an image file

Mat image = imread("input_image.jpg");

if (image.empty()) {

cerr << "Error loading image!" << endl;

return -1;

}

// Convert the image to grayscale

Mat grayImage;

cvtColor(image, grayImage, COLOR_BGR2GRAY);

// Detect faces in the grayscale image

vector<Rect> faces;

faceCascade.detectMultiScale(grayImage, faces);

// Draw rectangles around detected faces

for (const auto& face : faces) {

rectangle(image, face, Scalar(255, 0, 0), 2); // Blue rectangles

}

// Display the result

imshow("Face Detection", image);

waitKey(0); // Wait for a key press before closing the window

return 0;

}

Explanation: OpenCV Library: This program uses the OpenCV library, which provides various computer vision tools. Make sure you have OpenCV installed and properly linked to your project. Loading Haar Cascade Classifier (faceCascade): The CascadeClassifier class is used to load the pre-trained Haar Cascade classifier for face detection. The classifier XML file (haarcascade_frontalface_default.xml) contains the …

Face Detection Gaming Project in C++ Read More »

Encryption/Decryption of Images Gaming Project in C++

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

#include <iostream>
#include <fstream>
#include <vector>

using namespace std;

// Function to encrypt or decrypt data using XOR cipher
void xorCipher(vector<unsigned char>& data, unsigned char key) {
    for (auto& byte : data) {
        byte ^= key;
    }
}

// Function to read a binary file into a vector
vector<unsigned char> readFile(const string& filename) {
    ifstream file(filename, ios::binary | ios::ate);
    if (!file) {
        cerr << "Error opening file: " << filename << endl;
        exit(1);
    }
    
    streamsize size = file.tellg();
    file.seekg(0, ios::beg);

    vector<unsigned char> buffer(size);
    if (!file.read(reinterpret_cast<char*>(buffer.data()), size)) {
        cerr << "Error reading file: " << filename << endl;
        exit(1);
    }

    return buffer;
}

// Function to write a vector to a binary file
void writeFile(const string& filename, const vector<unsigned char>& data) {
    ofstream file(filename, ios::binary);
    if (!file) {
        cerr << "Error opening file: " << filename << endl;
        exit(1);
    }

    file.write(reinterpret_cast<const char*>(data.data()), data.size());
}

int main() {
    string inputFilename, outputFilename;
    unsigned char key;

    cout << "Enter the input image file name: ";
    cin >> inputFilename;
    cout << "Enter the output image file name: ";
    cin >> outputFilename;
    cout << "Enter the encryption/decryption key (0-255): ";
    cin >> key;

    if (key < 0 || key > 255) {
        cerr << "Key must be between 0 and 255." << endl;
        return 1;
    }

    // Read the input file into a vector
    vector<unsigned char> data = readFile(inputFilename);

    // Encrypt or decrypt the data
    xorCipher(data, key);

    // Write the processed data to the output file
    writeFile(outputFilename, data);

    cout << "Processing complete. Check the output file: " << outputFilename << endl;

    return 0;
}

#include <iostream>

#include <fstream>

#include <vector>

using namespace std;

// Function to encrypt or decrypt data using XOR cipher

void xorCipher(vector<unsigned char>& data, unsigned char key) {

for (auto& byte : data) {

byte ^= key;

}

// Function to read a binary file into a vector

vector<unsigned char> readFile(const string& filename) {

ifstream file(filename, ios::binary | ios::ate);

if (!file) {

cerr << "Error opening file: " << filename << endl;

exit(1);

}

streamsize size = file.tellg();

file.seekg(0, ios::beg);

vector<unsigned char> buffer(size);

if (!file.read(reinterpret_cast<char*>(buffer.data()), size)) {

cerr << "Error reading file: " << filename << endl;

exit(1);

}

return buffer;

}

// Function to write a vector to a binary file

void writeFile(const string& filename, const vector<unsigned char>& data) {

ofstream file(filename, ios::binary);

if (!file) {

cerr << "Error opening file: " << filename << endl;

exit(1);

}

file.write(reinterpret_cast<const char*>(data.data()), data.size());

}

int main() {

string inputFilename, outputFilename;

unsigned char key;

cout << "Enter the input image file name: ";

cin >> inputFilename;

cout << "Enter the output image file name: ";

cin >> outputFilename;

cout << "Enter the encryption/decryption key (0-255): ";

cin >> key;

if (key < 0 || key > 255) {

cerr << "Key must be between 0 and 255." << endl;

return 1;

}

// Read the input file into a vector

vector<unsigned char> data = readFile(inputFilename);

// Encrypt or decrypt the data

xorCipher(data, key);

// Write the processed data to the output file

writeFile(outputFilename, data);

cout << "Processing complete. Check the output file: " << outputFilename << endl;

return 0;

}

Explanation: XOR Cipher Function (xorCipher): The xorCipher function performs encryption or decryption by applying an XOR operation with a single byte key. XOR is a symmetric operation, meaning the same function can be used for both encrypting and decrypting data. File Reading (readFile): The readFile function opens a binary file (e.g., an image file) …

Encryption/Decryption of Images Gaming Project in C++ Read More »

Encryption/Decryption of Audio Files Gaming Project in C++

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

#include <iostream>
#include <fstream>
#include <vector>

using namespace std;

// Function to encrypt or decrypt data using XOR cipher
void xorCipher(vector<unsigned char>& data, unsigned char key) {
    for (auto& byte : data) {
        byte ^= key;
    }
}

// Function to read a binary file into a vector
vector<unsigned char> readFile(const string& filename) {
    ifstream file(filename, ios::binary | ios::ate);
    if (!file) {
        cerr << "Error opening file: " << filename << endl;
        exit(1);
    }
    
    streamsize size = file.tellg();
    file.seekg(0, ios::beg);

    vector<unsigned char> buffer(size);
    if (!file.read(reinterpret_cast<char*>(buffer.data()), size)) {
        cerr << "Error reading file: " << filename << endl;
        exit(1);
    }

    return buffer;
}

// Function to write a vector to a binary file
void writeFile(const string& filename, const vector<unsigned char>& data) {
    ofstream file(filename, ios::binary);
    if (!file) {
        cerr << "Error opening file: " << filename << endl;
        exit(1);
    }

    file.write(reinterpret_cast<const char*>(data.data()), data.size());
}

int main() {
    string inputFilename, outputFilename;
    unsigned char key;

    cout << "Enter the input file name: ";
    cin >> inputFilename;
    cout << "Enter the output file name: ";
    cin >> outputFilename;
    cout << "Enter the encryption/decryption key (0-255): ";
    cin >> key;

    if (key < 0 || key > 255) {
        cerr << "Key must be between 0 and 255." << endl;
        return 1;
    }

    // Read the input file into a vector
    vector<unsigned char> data = readFile(inputFilename);

    // Encrypt or decrypt the data
    xorCipher(data, key);

    // Write the processed data to the output file
    writeFile(outputFilename, data);

    cout << "Processing complete. Check the output file: " << outputFilename << endl;

    return 0;
}

#include <iostream>

#include <fstream>

#include <vector>

using namespace std;

// Function to encrypt or decrypt data using XOR cipher

void xorCipher(vector<unsigned char>& data, unsigned char key) {

for (auto& byte : data) {

byte ^= key;

}

// Function to read a binary file into a vector

vector<unsigned char> readFile(const string& filename) {

ifstream file(filename, ios::binary | ios::ate);

if (!file) {

cerr << "Error opening file: " << filename << endl;

exit(1);

}

streamsize size = file.tellg();

file.seekg(0, ios::beg);

vector<unsigned char> buffer(size);

if (!file.read(reinterpret_cast<char*>(buffer.data()), size)) {

cerr << "Error reading file: " << filename << endl;

exit(1);

}

return buffer;

}

// Function to write a vector to a binary file

void writeFile(const string& filename, const vector<unsigned char>& data) {

ofstream file(filename, ios::binary);

if (!file) {

cerr << "Error opening file: " << filename << endl;

exit(1);

}

file.write(reinterpret_cast<const char*>(data.data()), data.size());

}

int main() {

string inputFilename, outputFilename;

unsigned char key;

cout << "Enter the input file name: ";

cin >> inputFilename;

cout << "Enter the output file name: ";

cin >> outputFilename;

cout << "Enter the encryption/decryption key (0-255): ";

cin >> key;

if (key < 0 || key > 255) {

cerr << "Key must be between 0 and 255." << endl;

return 1;

}

// Read the input file into a vector

vector<unsigned char> data = readFile(inputFilename);

// Encrypt or decrypt the data

xorCipher(data, key);

// Write the processed data to the output file

writeFile(outputFilename, data);

cout << "Processing complete. Check the output file: " << outputFilename << endl;

return 0;

}

Explanation: XOR Cipher Function (xorCipher): The xorCipher function performs encryption or decryption by applying an XOR operation with a single byte key. XOR is a symmetric operation, so it can be used for both encryption and decryption. It iterates through each byte of the data and applies the XOR operation. File Reading (readFile): The …

Encryption/Decryption of Audio Files Gaming Project in C++ Read More »

Encryption/Decryption Algorithm Gaming Project in C++

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

#include <iostream>
#include <string>

using namespace std;

// Function to encrypt a message using Caesar cipher
string encrypt(const string& message, int shift) {
    string encryptedMessage = message;

    for (char& c : encryptedMessage) {
        if (isalpha(c)) {
            char base = islower(c) ? 'a' : 'A';
            c = (c - base + shift) % 26 + base;
        }
    }

    return encryptedMessage;
}

// Function to decrypt a message using Caesar cipher
string decrypt(const string& message, int shift) {
    return encrypt(message, 26 - shift); // Decryption is encryption with (26 - shift)
}

int main() {
    string message;
    int shift;

    cout << "Enter the message to encrypt: ";
    getline(cin, message);

    cout << "Enter the shift value (1-25): ";
    cin >> shift;

    if (shift < 1 || shift > 25) {
        cout << "Invalid shift value. It should be between 1 and 25." << endl;
        return 1;
    }

    // Encrypt the message
    string encryptedMessage = encrypt(message, shift);
    cout << "Encrypted message: " << encryptedMessage << endl;

    // Decrypt the message
    string decryptedMessage = decrypt(encryptedMessage, shift);
    cout << "Decrypted message: " << decryptedMessage << endl;

    return 0;
}

#include <iostream>

#include <string>

using namespace std;

// Function to encrypt a message using Caesar cipher

string encrypt(const string& message, int shift) {

string encryptedMessage = message;

for (char& c : encryptedMessage) {

if (isalpha(c)) {

char base = islower(c) ? 'a' : 'A';

c = (c - base + shift) % 26 + base;

}

return encryptedMessage;

}

// Function to decrypt a message using Caesar cipher

string decrypt(const string& message, int shift) {

return encrypt(message, 26 - shift); // Decryption is encryption with (26 - shift)

}

int main() {

string message;

int shift;

cout << "Enter the message to encrypt: ";

getline(cin, message);

cout << "Enter the shift value (1-25): ";

cin >> shift;

if (shift < 1 || shift > 25) {

cout << "Invalid shift value. It should be between 1 and 25." << endl;

return 1;

}

// Encrypt the message

string encryptedMessage = encrypt(message, shift);

cout << "Encrypted message: " << encryptedMessage << endl;

// Decrypt the message

string decryptedMessage = decrypt(encryptedMessage, shift);

cout << "Decrypted message: " << decryptedMessage << endl;

return 0;

}

Explanation: Caesar Cipher Encryption (encrypt): The encrypt function shifts each letter in the input message by a specified number of positions in the alphabet. It loops through each character in the message: If the character is a letter, it calculates its new position by shifting it and wraps around the end of the alphabet …

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

Employee Payroll System Gaming Project in C++

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

#include <iostream>
#include <vector>
#include <iomanip>

using namespace std;

// Employee class to store employee details and salary calculation
class Employee {
public:
    Employee(const string& name, double hourlyRate, int hoursWorked)
        : name(name), hourlyRate(hourlyRate), hoursWorked(hoursWorked) {}

    double calculateSalary() const {
        return hourlyRate * hoursWorked;
    }

    void display() const {
        cout << "Name: " << name << endl
             << "Hourly Rate: $" << fixed << setprecision(2) << hourlyRate << endl
             << "Hours Worked: " << hoursWorked << endl
             << "Salary: $" << fixed << setprecision(2) << calculateSalary() << endl
             << "--------------------------" << endl;
    }

private:
    string name;
    double hourlyRate;
    int hoursWorked;
};

// Function to add an employee
void addEmployee(vector<Employee>& employees) {
    string name;
    double hourlyRate;
    int hoursWorked;

    cout << "Enter employee name: ";
    cin.ignore();
    getline(cin, name);
    cout << "Enter hourly rate: $";
    cin >> hourlyRate;
    cout << "Enter hours worked: ";
    cin >> hoursWorked;

    employees.emplace_back(name, hourlyRate, hoursWorked);
    cout << "Employee added successfully!" << endl;
}

// Function to display all employees' payroll
void displayPayroll(const vector<Employee>& employees) {
    cout << "Employee Payroll:" << endl;
    for (const auto& employee : employees) {
        employee.display();
    }
}

int main() {
    vector<Employee> employees;
    int choice;

    do {
        cout << "Employee Payroll System Menu:" << endl;
        cout << "1. Add Employee" << endl;
        cout << "2. Display Payroll" << endl;
        cout << "3. Exit" << endl;
        cout << "Enter your choice: ";
        cin >> choice;

        switch (choice) {
            case 1:
                addEmployee(employees);
                break;
            case 2:
                displayPayroll(employees);
                break;
            case 3:
                cout << "Exiting the system." << endl;
                break;
            default:
                cout << "Invalid choice. Please try again." << endl;
        }
    } while (choice != 3);

    return 0;
}

#include <iostream>

#include <vector>

#include <iomanip>

using namespace std;

// Employee class to store employee details and salary calculation

class Employee {

public:

Employee(const string& name, double hourlyRate, int hoursWorked)

: name(name), hourlyRate(hourlyRate), hoursWorked(hoursWorked) {}

double calculateSalary() const {

return hourlyRate * hoursWorked;

}

void display() const {

cout << "Name: " << name << endl

<< "Hourly Rate: $" << fixed << setprecision(2) << hourlyRate << endl

<< "Hours Worked: " << hoursWorked << endl

<< "Salary: $" << fixed << setprecision(2) << calculateSalary() << endl

<< "--------------------------" << endl;

}

private:

string name;

double hourlyRate;

int hoursWorked;

};

// Function to add an employee

void addEmployee(vector<Employee>& employees) {

string name;

double hourlyRate;

int hoursWorked;

cout << "Enter employee name: ";

cin.ignore();

getline(cin, name);

cout << "Enter hourly rate: $";

cin >> hourlyRate;

cout << "Enter hours worked: ";

cin >> hoursWorked;

employees.emplace_back(name, hourlyRate, hoursWorked);

cout << "Employee added successfully!" << endl;

}

// Function to display all employees' payroll

void displayPayroll(const vector<Employee>& employees) {

cout << "Employee Payroll:" << endl;

for (const auto& employee : employees) {

employee.display();

}

int main() {

vector<Employee> employees;

int choice;

do {

cout << "Employee Payroll System Menu:" << endl;

cout << "1. Add Employee" << endl;

cout << "2. Display Payroll" << endl;

cout << "3. Exit" << endl;

cout << "Enter your choice: ";

cin >> choice;

switch (choice) {

case 1:

addEmployee(employees);

break;

case 2:

displayPayroll(employees);

break;

case 3:

cout << "Exiting the system." << endl;

break;

default:

cout << "Invalid choice. Please try again." << endl;

}

} while (choice != 3);

return 0;

}

Explanation: Employee Class: The Employee class stores information about an employee, including their name, hourly rate, and hours worked. The calculateSalary method computes the employee’s salary based on their hourly rate and hours worked. The display method prints the employee’s details and calculated salary. Add Employee (addEmployee): This function prompts the user to input …

Employee Payroll System Gaming Project in C++ Read More »

Drawing Application Gaming Project in C++

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

#include <SFML/Graphics.hpp>
#include <vector>

using namespace std;

int main() {
    // Create a window
    sf::RenderWindow window(sf::VideoMode(800, 600), "Simple Drawing Application");

    // Vector to hold drawn lines
    vector<sf::VertexArray> lines;

    // Create a vertex array for the current line being drawn
    sf::VertexArray currentLine(sf::LinesStrip);

    bool isDrawing = false;

    while (window.isOpen()) {
        sf::Event event;
        while (window.pollEvent(event)) {
            if (event.type == sf::Event::Closed) {
                window.close();
            }
        }

        // Check if the mouse is pressed
        if (sf::Mouse::isButtonPressed(sf::Mouse::Left)) {
            if (!isDrawing) {
                isDrawing = true;
                currentLine.clear();
                currentLine.append(sf::Vertex(sf::Vector2f(sf::Mouse::getPosition(window)), sf::Color::Red));
            } else {
                currentLine.append(sf::Vertex(sf::Vector2f(sf::Mouse::getPosition(window)), sf::Color::Red));
            }
        } else {
            if (isDrawing) {
                isDrawing = false;
                lines.push_back(currentLine);
                currentLine.clear();
            }
        }

        // Clear the window
        window.clear(sf::Color::White);

        // Draw all lines
        for (const auto& line : lines) {
            window.draw(line);
        }

        // Draw the current line being drawn
        window.draw(currentLine);

        // Display the contents of the window
        window.display();
    }

    return 0;
}

#include <SFML/Graphics.hpp>

#include <vector>

using namespace std;

int main() {

// Create a window

sf::RenderWindow window(sf::VideoMode(800, 600), "Simple Drawing Application");

// Vector to hold drawn lines

vector<sf::VertexArray> lines;

// Create a vertex array for the current line being drawn

sf::VertexArray currentLine(sf::LinesStrip);

bool isDrawing = false;

while (window.isOpen()) {

sf::Event event;

while (window.pollEvent(event)) {

if (event.type == sf::Event::Closed) {

window.close();

}

// Check if the mouse is pressed

if (sf::Mouse::isButtonPressed(sf::Mouse::Left)) {

if (!isDrawing) {

isDrawing = true;

currentLine.clear();

currentLine.append(sf::Vertex(sf::Vector2f(sf::Mouse::getPosition(window)), sf::Color::Red));

} else {

currentLine.append(sf::Vertex(sf::Vector2f(sf::Mouse::getPosition(window)), sf::Color::Red));

}

} else {

if (isDrawing) {

isDrawing = false;

lines.push_back(currentLine);

currentLine.clear();

}

// Clear the window

window.clear(sf::Color::White);

// Draw all lines

for (const auto& line : lines) {

window.draw(line);

}

// Draw the current line being drawn

window.draw(currentLine);

// Display the contents of the window

window.display();

}

return 0;

}

Explanation: SFML Library: The program uses the SFML library to create a graphical window and handle drawing operations. Ensure you have SFML installed and linked to your project. Window Creation: sf::RenderWindow is used to create a window with a specified size (800×600) and a title (“Simple Drawing Application”). Drawing Data: vector<sf::VertexArray> stores all the …

Drawing Application Gaming Project in C++ Read More »

Dijkstra’s Algorithm Gaming Project in C++

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

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

using namespace std;

const int INF = numeric_limits<int>::max(); // Represents infinity

// A structure to represent a node in the priority queue
struct Node {
    int vertex, distance;
    bool operator>(const Node& other) const {
        return distance > other.distance;
    }
};

// Function to perform Dijkstra's algorithm
vector<int> dijkstra(int start, const vector<vector<pair<int, int>>>& graph) {
    int n = graph.size();
    vector<int> distances(n, INF);
    distances[start] = 0;

    priority_queue<Node, vector<Node>, greater<Node>> pq;
    pq.push({start, 0});

    while (!pq.empty()) {
        int currentVertex = pq.top().vertex;
        int currentDistance = pq.top().distance;
        pq.pop();

        // Explore the neighbors
        for (const auto& neighbor : graph[currentVertex]) {
            int nextVertex = neighbor.first;
            int weight = neighbor.second;

            int newDistance = currentDistance + weight;

            // If a shorter path is found
            if (newDistance < distances[nextVertex]) {
                distances[nextVertex] = newDistance;
                pq.push({nextVertex, newDistance});
            }
        }
    }

    return distances;
}

int main() {
    int vertices = 6;
    vector<vector<pair<int, int>>> graph(vertices);

    // Adding edges to the graph (graph is represented as an adjacency list)
    graph[0].push_back({1, 7});
    graph[0].push_back({2, 9});
    graph[0].push_back({5, 14});
    graph[1].push_back({0, 7});
    graph[1].push_back({2, 10});
    graph[1].push_back({3, 15});
    graph[2].push_back({0, 9});
    graph[2].push_back({1, 10});
    graph[2].push_back({3, 11});
    graph[2].push_back({5, 2});
    graph[3].push_back({1, 15});
    graph[3].push_back({2, 11});
    graph[3].push_back({4, 6});
    graph[4].push_back({3, 6});
    graph[4].push_back({5, 9});
    graph[5].push_back({0, 14});
    graph[5].push_back({2, 2});
    graph[5].push_back({4, 9});

    int startVertex = 0;
    vector<int> distances = dijkstra(startVertex, graph);

    cout << "Shortest distances from vertex " << startVertex << ":\n";
    for (int i = 0; i < vertices; ++i) {
        if (distances[i] == INF) {
            cout << "Vertex " << i << ": INF (unreachable)" << endl;
        } else {
            cout << "Vertex " << i << ": " << distances[i] << endl;
        }
    }

    return 0;
}

#include <iostream>

#include <vector>

#include <queue>

#include <limits>

using namespace std;

const int INF = numeric_limits<int>::max(); // Represents infinity

// A structure to represent a node in the priority queue

struct Node {

int vertex, distance;

bool operator>(const Node& other) const {

return distance > other.distance;

}

};

// Function to perform Dijkstra's algorithm

vector<int> dijkstra(int start, const vector<vector<pair<int, int>>>& graph) {

int n = graph.size();

vector<int> distances(n, INF);

distances[start] = 0;

priority_queue<Node, vector<Node>, greater<Node>> pq;

pq.push({start, 0});

while (!pq.empty()) {

int currentVertex = pq.top().vertex;

int currentDistance = pq.top().distance;

pq.pop();

// Explore the neighbors

for (const auto& neighbor : graph[currentVertex]) {

int nextVertex = neighbor.first;

int weight = neighbor.second;

int newDistance = currentDistance + weight;

// If a shorter path is found

if (newDistance < distances[nextVertex]) {

distances[nextVertex] = newDistance;

pq.push({nextVertex, newDistance});

}

return distances;

}

int main() {

int vertices = 6;

vector<vector<pair<int, int>>> graph(vertices);

// Adding edges to the graph (graph is represented as an adjacency list)

graph[0].push_back({1, 7});

graph[0].push_back({2, 9});

graph[0].push_back({5, 14});

graph[1].push_back({0, 7});

graph[1].push_back({2, 10});

graph[1].push_back({3, 15});

graph[2].push_back({0, 9});

graph[2].push_back({1, 10});

graph[2].push_back({3, 11});

graph[2].push_back({5, 2});

graph[3].push_back({1, 15});

graph[3].push_back({2, 11});

graph[3].push_back({4, 6});

graph[4].push_back({3, 6});

graph[4].push_back({5, 9});

graph[5].push_back({0, 14});

graph[5].push_back({2, 2});

graph[5].push_back({4, 9});

int startVertex = 0;

vector<int> distances = dijkstra(startVertex, graph);

cout << "Shortest distances from vertex " << startVertex << ":\n";

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

if (distances[i] == INF) {

cout << "Vertex " << i << ": INF (unreachable)" << endl;

} else {

cout << "Vertex " << i << ": " << distances[i] << endl;

}

return 0;

}

Explanation: Graph Representation: The graph is represented as an adjacency list using a vector of vectors. Each inner vector contains pairs representing a connected vertex and the weight of the edge to that vertex. Node Structure: The Node structure is used to store the current vertex and the distance from the source vertex. It …

Dijkstra’s Algorithm Gaming Project in C++ Read More »