C++ Projects – Page 15 – Projects Inventory

Quiz Game Gaming Project in C++

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

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

using namespace std;

// Structure to hold a question and its answer
struct Question {
    string questionText;
    string answer;
};

// Function to ask a question and get the user's answer
bool askQuestion(Question q) {
    string userAnswer;
    cout << q.questionText << endl;
    cout << "Your answer: ";
    getline(cin, userAnswer);

    // Compare user's answer to the correct answer
    if (userAnswer == q.answer) {
        cout << "Correct!" << endl;
        return true;
    } else {
        cout << "Wrong! The correct answer is: " << q.answer << endl;
        return false;
    }
}

int main() {
    // List of questions for the quiz
    vector<Question> quiz = {
        {"What is the capital of France?", "Paris"},
        {"What is 9 + 10?", "19"},
        {"Who wrote 'Romeo and Juliet'?", "Shakespeare"},
        {"What is the largest planet in our solar system?", "Jupiter"}
    };

    int score = 0;

    cout << "Welcome to the Quiz Game!" << endl;
    cout << "=========================" << endl;

    // Loop through each question
    for (size_t i = 0; i < quiz.size(); ++i) {
        cout << "Question " << i + 1 << ": " << endl;
        if (askQuestion(quiz[i])) {
            ++score;
        }
        cout << endl;
    }

    // Display the final score
    cout << "Quiz over!" << endl;
    cout << "Your final score is: " << score << " out of " << quiz.size() << endl;

    return 0;
}

#include <iostream>

#include <string>

#include <vector>

using namespace std;

// Structure to hold a question and its answer

struct Question {

string questionText;

string answer;

};

// Function to ask a question and get the user's answer

bool askQuestion(Question q) {

string userAnswer;

cout << q.questionText << endl;

cout << "Your answer: ";

getline(cin, userAnswer);

// Compare user's answer to the correct answer

if (userAnswer == q.answer) {

cout << "Correct!" << endl;

return true;

} else {

cout << "Wrong! The correct answer is: " << q.answer << endl;

return false;

}

int main() {

// List of questions for the quiz

vector<Question> quiz = {

{"What is the capital of France?", "Paris"},

{"What is 9 + 10?", "19"},

{"Who wrote 'Romeo and Juliet'?", "Shakespeare"},

{"What is the largest planet in our solar system?", "Jupiter"}

};

int score = 0;

cout << "Welcome to the Quiz Game!" << endl;

cout << "=========================" << endl;

// Loop through each question

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

cout << "Question " << i + 1 << ": " << endl;

if (askQuestion(quiz[i])) {

++score;

}

cout << endl;

}

// Display the final score

cout << "Quiz over!" << endl;

cout << "Your final score is: " << score << " out of " << quiz.size() << endl;

return 0;

}

Explanation Structure Definition: A struct named Question is defined to hold each quiz question and its corresponding correct answer. This helps to keep the question and answer logically grouped together. askQuestion Function: This function takes a Question object as input, displays the question, and prompts the user for an answer. It compares the user’s …

Quiz Game Gaming Project in C++ Read More »

Queue Implementation Gaming Project in C++

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

#include <iostream>
#include <vector>

class Queue {
private:
    std::vector<int> data;
    int frontIndex;
    int rearIndex;

public:
    // Constructor to initialize the queue
    Queue() : frontIndex(0), rearIndex(0) {}

    // Method to add an element to the queue
    void enqueue(int value) {
        data.push_back(value);
        rearIndex++;
    }

    // Method to remove and return the front element from the queue
    int dequeue() {
        if (isEmpty()) {
            throw std::out_of_range("Queue is empty");
        }
        int value = data[frontIndex];
        frontIndex++;
        return value;
    }

    // Method to get the front element without removing it
    int front() const {
        if (isEmpty()) {
            throw std::out_of_range("Queue is empty");
        }
        return data[frontIndex];
    }

    // Method to check if the queue is empty
    bool isEmpty() const {
        return frontIndex == rearIndex;
    }

    // Method to get the size of the queue
    int size() const {
        return rearIndex - frontIndex;
    }
};

int main() {
    Queue q;

    // Enqueue elements into the queue
    q.enqueue(10);
    q.enqueue(20);
    q.enqueue(30);
    q.enqueue(40);

    std::cout << "Front element: " << q.front() << std::endl;

    // Dequeue elements from the queue
    std::cout << "Dequeued: " << q.dequeue() << std::endl;
    std::cout << "Dequeued: " << q.dequeue() << std::endl;

    std::cout << "Front element after dequeuing: " << q.front() << std::endl;

    std::cout << "Queue size: " << q.size() << std::endl;

    return 0;
}

#include <iostream>

#include <vector>

class Queue {

private:

std::vector<int> data;

int frontIndex;

int rearIndex;

public:

// Constructor to initialize the queue

Queue() : frontIndex(0), rearIndex(0) {}

// Method to add an element to the queue

void enqueue(int value) {

data.push_back(value);

rearIndex++;

}

// Method to remove and return the front element from the queue

int dequeue() {

if (isEmpty()) {

throw std::out_of_range("Queue is empty");

}

int value = data[frontIndex];

frontIndex++;

return value;

}

// Method to get the front element without removing it

int front() const {

if (isEmpty()) {

throw std::out_of_range("Queue is empty");

}

return data[frontIndex];

}

// Method to check if the queue is empty

bool isEmpty() const {

return frontIndex == rearIndex;

}

// Method to get the size of the queue

int size() const {

return rearIndex - frontIndex;

}

};

int main() {

Queue q;

// Enqueue elements into the queue

q.enqueue(10);

q.enqueue(20);

q.enqueue(30);

q.enqueue(40);

std::cout << "Front element: " << q.front() << std::endl;

// Dequeue elements from the queue

std::cout << "Dequeued: " << q.dequeue() << std::endl;

std::cout << "Front element after dequeuing: " << q.front() << std::endl;

std::cout << "Queue size: " << q.size() << std::endl;

return 0;

}

Explanation Queue Class: The Queue class is implemented using a std::vector<int> to store the elements. It maintains two indices: frontIndex and rearIndex, which represent the positions of the front and rear elements in the queue. Enqueue Operation: The enqueue(int value) method adds an element to the rear of the queue by pushing it to …

Queue Implementation Gaming Project in C++ Read More »

Quadratic Equation Solver Gaming Project in C++

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

#include <iostream>
#include <cmath>
#include <complex>

// Function to solve the quadratic equation ax^2 + bx + c = 0
void solveQuadratic(double a, double b, double c) {
    if (a == 0) {
        std::cerr << "This is not a quadratic equation." << std::endl;
        return;
    }

    double discriminant = b * b - 4 * a * c;

    if (discriminant > 0) {
        // Two distinct real roots
        double root1 = (-b + std::sqrt(discriminant)) / (2 * a);
        double root2 = (-b - std::sqrt(discriminant)) / (2 * a);
        std::cout << "Roots are real and different:" << std::endl;
        std::cout << "Root 1 = " << root1 << std::endl;
        std::cout << "Root 2 = " << root2 << std::endl;
    } else if (discriminant == 0) {
        // One real root
        double root = -b / (2 * a);
        std::cout << "Roots are real and the same:" << std::endl;
        std::cout << "Root = " << root << std::endl;
    } else {
        // Complex roots
        std::complex<double> root1 = (-b + std::sqrt(std::complex<double>(discriminant))) / (2.0 * a);
        std::complex<double> root2 = (-b - std::sqrt(std::complex<double>(discriminant))) / (2.0 * a);
        std::cout << "Roots are complex and different:" << std::endl;
        std::cout << "Root 1 = " << root1 << std::endl;
        std::cout << "Root 2 = " << root2 << std::endl;
    }
}

int main() {
    double a, b, c;

    std::cout << "Enter coefficients a, b, and c: ";
    std::cin >> a >> b >> c;

    solveQuadratic(a, b, c);

    return 0;
}

#include <iostream>

#include <cmath>

#include <complex>

// Function to solve the quadratic equation ax^2 + bx + c = 0

void solveQuadratic(double a, double b, double c) {

if (a == 0) {

std::cerr << "This is not a quadratic equation." << std::endl;

return;

}

double discriminant = b * b - 4 * a * c;

if (discriminant > 0) {

// Two distinct real roots

double root1 = (-b + std::sqrt(discriminant)) / (2 * a);

double root2 = (-b - std::sqrt(discriminant)) / (2 * a);

std::cout << "Roots are real and different:" << std::endl;

std::cout << "Root 1 = " << root1 << std::endl;

std::cout << "Root 2 = " << root2 << std::endl;

} else if (discriminant == 0) {

// One real root

double root = -b / (2 * a);

std::cout << "Roots are real and the same:" << std::endl;

std::cout << "Root = " << root << std::endl;

} else {

// Complex roots

std::complex<double> root1 = (-b + std::sqrt(std::complex<double>(discriminant))) / (2.0 * a);

std::complex<double> root2 = (-b - std::sqrt(std::complex<double>(discriminant))) / (2.0 * a);

std::cout << "Roots are complex and different:" << std::endl;

std::cout << "Root 1 = " << root1 << std::endl;

std::cout << "Root 2 = " << root2 << std::endl;

}

int main() {

double a, b, c;

std::cout << "Enter coefficients a, b, and c: ";

std::cin >> a >> b >> c;

solveQuadratic(a, b, c);

return 0;

}

Explanation Quadratic Equation: The general form of a quadratic equation is ax2+bx+c=0ax^2 + bx + c = 0ax2+bx+c=0, where aaa, bbb, and ccc are coefficients. Discriminant: The discriminant of the quadratic equation is calculated as discriminant=b2−4ac\text{discriminant} = b^2 – 4acdiscriminant=b2−4ac. The nature of the roots depends on the discriminant: If the discriminant is positive, …

Quadratic Equation Solver Gaming Project in C++ Read More »

Priority Queue Implementation Gaming Project in C++

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

#include <iostream>
#include <vector>
#include <algorithm>

// A class to represent a priority queue
class PriorityQueue {
private:
    std::vector<int> data;

    // Helper function to heapify the tree
    void heapify_up(int index) {
        if (index == 0) return; // Base case: root node
        int parent = (index - 1) / 2;

        if (data[index] > data[parent]) {
            std::swap(data[index], data[parent]);
            heapify_up(parent);
        }
    }

    void heapify_down(int index) {
        int leftChild = 2 * index + 1;
        int rightChild = 2 * index + 2;
        int largest = index;

        if (leftChild < data.size() && data[leftChild] > data[largest]) {
            largest = leftChild;
        }

        if (rightChild < data.size() && data[rightChild] > data[largest]) {
            largest = rightChild;
        }

        if (largest != index) {
            std::swap(data[index], data[largest]);
            heapify_down(largest);
        }
    }

public:
    // Insert a new element into the priority queue
    void push(int value) {
        data.push_back(value);
        heapify_up(data.size() - 1);
    }

    // Remove and return the highest priority element
    int pop() {
        if (data.empty()) {
            throw std::out_of_range("Priority Queue is empty");
        }
        int root = data.front();
        data[0] = data.back();
        data.pop_back();
        heapify_down(0);
        return root;
    }

    // Return the highest priority element without removing it
    int top() const {
        if (data.empty()) {
            throw std::out_of_range("Priority Queue is empty");
        }
        return data.front();
    }

    // Check if the priority queue is empty
    bool empty() const {
        return data.empty();
    }
};

int main() {
    PriorityQueue pq;

    // Inserting elements into the priority queue
    pq.push(5);
    pq.push(15);
    pq.push(10);
    pq.push(30);
    pq.push(20);

    std::cout << "Top element: " << pq.top() << std::endl;

    // Removing elements from the priority queue
    std::cout << "Popped element: " << pq.pop() << std::endl;
    std::cout << "Popped element: " << pq.pop() << std::endl;

    std::cout << "Top element after popping: " << pq.top() << std::endl;

    return 0;
}

#include <iostream>

#include <vector>

#include <algorithm>

// A class to represent a priority queue

class PriorityQueue {

private:

std::vector<int> data;

// Helper function to heapify the tree

void heapify_up(int index) {

if (index == 0) return; // Base case: root node

int parent = (index - 1) / 2;

if (data[index] > data[parent]) {

std::swap(data[index], data[parent]);

heapify_up(parent);

}

void heapify_down(int index) {

int leftChild = 2 * index + 1;

int rightChild = 2 * index + 2;

int largest = index;

if (leftChild < data.size() && data[leftChild] > data[largest]) {

largest = leftChild;

}

if (rightChild < data.size() && data[rightChild] > data[largest]) {

largest = rightChild;

}

if (largest != index) {

std::swap(data[index], data[largest]);

heapify_down(largest);

}

public:

// Insert a new element into the priority queue

void push(int value) {

data.push_back(value);

heapify_up(data.size() - 1);

}

// Remove and return the highest priority element

int pop() {

if (data.empty()) {

throw std::out_of_range("Priority Queue is empty");

}

int root = data.front();

data[0] = data.back();

data.pop_back();

heapify_down(0);

return root;

}

// Return the highest priority element without removing it

int top() const {

if (data.empty()) {

throw std::out_of_range("Priority Queue is empty");

}

return data.front();

}

// Check if the priority queue is empty

bool empty() const {

return data.empty();

}

};

int main() {

PriorityQueue pq;

// Inserting elements into the priority queue

pq.push(5);

pq.push(15);

pq.push(10);

pq.push(30);

pq.push(20);

std::cout << "Top element: " << pq.top() << std::endl;

// Removing elements from the priority queue

std::cout << "Popped element: " << pq.pop() << std::endl;

std::cout << "Top element after popping: " << pq.top() << std::endl;

return 0;

}

Explanation Priority Queue Class: The PriorityQueue class uses a vector (std::vector<int> data) to store the elements. It maintains a max-heap, where the highest priority element is always at the root (index 0). heapify_up: This method ensures the heap property is maintained after inserting a new element by comparing the newly added element with its …

Priority Queue Implementation Gaming Project in C++ Read More »

Photo Viewer Gaming Project in C++

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

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

namespace fs = std::filesystem;

void showImage(const cv::Mat& image, const std::string& windowName) {
    cv::imshow(windowName, image);
    cv::waitKey(0); // Wait for a key press
}

std::vector<std::string> loadImagePaths(const std::string& directory) {
    std::vector<std::string> imagePaths;
    for (const auto& entry : fs::directory_iterator(directory)) {
        if (entry.is_regular_file() && (entry.path().extension() == ".jpg" ||
                                        entry.path().extension() == ".png" ||
                                        entry.path().extension() == ".bmp")) {
            imagePaths.push_back(entry.path().string());
        }
    }
    return imagePaths;
}

int main() {
    std::string directory;
    std::cout << "Enter the directory path containing images: ";
    std::cin >> directory;

    std::vector<std::string> imagePaths = loadImagePaths(directory);

    if (imagePaths.empty()) {
        std::cout << "No images found in the directory.\n";
        return 1;
    }

    int index = 0;
    while (true) {
        cv::Mat image = cv::imread(imagePaths[index]);
        if (image.empty()) {
            std::cerr << "Error loading image: " << imagePaths[index] << std::endl;
            return 1;
        }

        showImage(image, "Photo Viewer");

        std::cout << "Press 'n' for next image, 'p' for previous image, or 'q' to quit.\n";
        char key = static_cast<char>(cv::waitKey(0));
        if (key == 'n') {
            index = (index + 1) % imagePaths.size();
        } else if (key == 'p') {
            index = (index - 1 + imagePaths.size()) % imagePaths.size();
        } else if (key == 'q') {
            break;
        } else {
            std::cout << "Invalid key. Use 'n', 'p', or 'q'.\n";
        }
    }

    cv::destroyAllWindows();
    return 0;
}

#include <opencv2/opencv.hpp>

#include <iostream>

#include <vector>

#include <filesystem>

namespace fs = std::filesystem;

void showImage(const cv::Mat& image, const std::string& windowName) {

cv::imshow(windowName, image);

cv::waitKey(0); // Wait for a key press

}

std::vector<std::string> loadImagePaths(const std::string& directory) {

std::vector<std::string> imagePaths;

for (const auto& entry : fs::directory_iterator(directory)) {

if (entry.is_regular_file() && (entry.path().extension() == ".jpg" ||

entry.path().extension() == ".png" ||

entry.path().extension() == ".bmp")) {

imagePaths.push_back(entry.path().string());

}

return imagePaths;

}

int main() {

std::string directory;

std::cout << "Enter the directory path containing images: ";

std::cin >> directory;

std::vector<std::string> imagePaths = loadImagePaths(directory);

if (imagePaths.empty()) {

std::cout << "No images found in the directory.\n";

return 1;

}

int index = 0;

while (true) {

cv::Mat image = cv::imread(imagePaths[index]);

if (image.empty()) {

std::cerr << "Error loading image: " << imagePaths[index] << std::endl;

return 1;

}

showImage(image, "Photo Viewer");

std::cout << "Press 'n' for next image, 'p' for previous image, or 'q' to quit.\n";

char key = static_cast<char>(cv::waitKey(0));

if (key == 'n') {

index = (index + 1) % imagePaths.size();

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

index = (index - 1 + imagePaths.size()) % imagePaths.size();

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

break;

} else {

std::cout << "Invalid key. Use 'n', 'p', or 'q'.\n";

}

cv::destroyAllWindows();

return 0;

}

Explanation: Include OpenCV and Standard Libraries: #include <opencv2/opencv.hpp>: Includes the OpenCV core functionalities. #include <iostream>: For input and output operations. #include <vector>: For using the std::vector container. #include <filesystem>: For directory and file handling in C++17. Show Image Function: showImage(const cv::Mat& image, const std::string& windowName): Displays the image in a window named windowName. The …

Photo Viewer Gaming Project in C++ Read More »

Password Manager Gaming Project in C++

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

#include <iostream>
#include <fstream>
#include <string>
#include <map>

void addPassword(std::map<std::string, std::string>& passwords) {
    std::string account, password;
    std::cout << "Enter account name: ";
    std::cin.ignore();
    std::getline(std::cin, account);
    std::cout << "Enter password: ";
    std::getline(std::cin, password);
    passwords[account] = password;
    std::cout << "Password added successfully.\n";
}

void viewPasswords(const std::map<std::string, std::string>& passwords) {
    if (passwords.empty()) {
        std::cout << "No passwords stored.\n";
        return;
    }
    std::cout << "Stored passwords:\n";
    for (const auto& entry : passwords) {
        std::cout << "Account: " << entry.first << " | Password: " << entry.second << '\n';
    }
}

void savePasswords(const std::map<std::string, std::string>& passwords) {
    std::ofstream file("passwords.txt");
    if (!file) {
        std::cerr << "Error opening file for writing.\n";
        return;
    }
    for (const auto& entry : passwords) {
        file << entry.first << '\n' << entry.second << '\n';
    }
    file.close();
    std::cout << "Passwords saved successfully.\n";
}

void loadPasswords(std::map<std::string, std::string>& passwords) {
    std::ifstream file("passwords.txt");
    if (!file) {
        std::cerr << "Error opening file for reading.\n";
        return;
    }
    std::string account, password;
    while (std::getline(file, account) && std::getline(file, password)) {
        passwords[account] = password;
    }
    file.close();
}

int main() {
    std::map<std::string, std::string> passwords;
    loadPasswords(passwords);

    int choice;
    while (true) {
        std::cout << "Password Manager\n";
        std::cout << "1. Add Password\n";
        std::cout << "2. View Passwords\n";
        std::cout << "3. Save and Exit\n";
        std::cout << "Enter your choice: ";
        std::cin >> choice;

        switch (choice) {
            case 1:
                addPassword(passwords);
                break;
            case 2:
                viewPasswords(passwords);
                break;
            case 3:
                savePasswords(passwords);
                return 0;
            default:
                std::cout << "Invalid choice. Please try again.\n";
        }
    }

    return 0;
}

#include <iostream>

#include <fstream>

#include <string>

#include <map>

void addPassword(std::map<std::string, std::string>& passwords) {

std::string account, password;

std::cout << "Enter account name: ";

std::cin.ignore();

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

std::cout << "Enter password: ";

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

passwords[account] = password;

std::cout << "Password added successfully.\n";

}

void viewPasswords(const std::map<std::string, std::string>& passwords) {

if (passwords.empty()) {

std::cout << "No passwords stored.\n";

return;

}

std::cout << "Stored passwords:\n";

for (const auto& entry : passwords) {

std::cout << "Account: " << entry.first << " | Password: " << entry.second << '\n';

}

void savePasswords(const std::map<std::string, std::string>& passwords) {

std::ofstream file("passwords.txt");

if (!file) {

std::cerr << "Error opening file for writing.\n";

return;

}

for (const auto& entry : passwords) {

file << entry.first << '\n' << entry.second << '\n';

}

file.close();

std::cout << "Passwords saved successfully.\n";

}

void loadPasswords(std::map<std::string, std::string>& passwords) {

std::ifstream file("passwords.txt");

if (!file) {

std::cerr << "Error opening file for reading.\n";

return;

}

std::string account, password;

while (std::getline(file, account) && std::getline(file, password)) {

passwords[account] = password;

}

file.close();

}

int main() {

std::map<std::string, std::string> passwords;

loadPasswords(passwords);

int choice;

while (true) {

std::cout << "Password Manager\n";

std::cout << "1. Add Password\n";

std::cout << "2. View Passwords\n";

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

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

std::cin >> choice;

switch (choice) {

case 1:

addPassword(passwords);

break;

case 2:

viewPasswords(passwords);

break;

case 3:

savePasswords(passwords);

return 0;

default:

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

}

return 0;

}

Explanation: Include Headers: #include <iostream>: For input and output operations. #include <fstream>: For file operations. #include <string>: For string manipulations. #include <map>: For using the std::map container to store account-password pairs. Functions: addPassword: Prompts the user to enter an account name and password, then stores these in the passwords map. viewPasswords: Displays all stored …

Password Manager Gaming Project in C++ Read More »

Optical Character Recognition (OCR) Gaming Project in C++

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

#include <iostream>
#include <tesseract/baseapi.h>
#include <leptonica/allheaders.h>

int main() {
    // Initialize Tesseract API
    tesseract::TessBaseAPI *api = new tesseract::TessBaseAPI();
    if (api->Init(NULL, "eng")) {  // Initialize with the English language
        std::cerr << "Could not initialize tesseract.\n";
        return 1;
    }

    // Load an image from file
    Pix *image = pixRead("image.png");  // Replace with your image file path
    if (image == NULL) {
        std::cerr << "Could not open image file.\n";
        api->End();
        return 1;
    }

    // Set the image for OCR processing
    api->SetImage(image);

    // Perform OCR
    char *text = api->GetUTF8Text();
    if (text == NULL) {
        std::cerr << "Could not perform OCR.\n";
        pixDestroy(&image);
        api->End();
        return 1;
    }

    // Output the extracted text
    std::cout << "Extracted Text:\n" << text << std::endl;

    // Clean up
    delete[] text;
    pixDestroy(&image);
    api->End();

    return 0;
}

#include <iostream>

#include <tesseract/baseapi.h>

#include <leptonica/allheaders.h>

int main() {

// Initialize Tesseract API

tesseract::TessBaseAPI *api = new tesseract::TessBaseAPI();

if (api->Init(NULL, "eng")) { // Initialize with the English language

std::cerr << "Could not initialize tesseract.\n";

return 1;

}

// Load an image from file

Pix *image = pixRead("image.png"); // Replace with your image file path

if (image == NULL) {

std::cerr << "Could not open image file.\n";

api->End();

return 1;

}

// Set the image for OCR processing

api->SetImage(image);

// Perform OCR

char *text = api->GetUTF8Text();

if (text == NULL) {

std::cerr << "Could not perform OCR.\n";

pixDestroy(&image);

api->End();

return 1;

}

// Output the extracted text

std::cout << "Extracted Text:\n" << text << std::endl;

// Clean up

delete[] text;

pixDestroy(&image);

api->End();

return 0;

}

Explanation: Include Tesseract and Leptonica Headers: #include <tesseract/baseapi.h>: Includes the Tesseract API for OCR. #include <leptonica/allheaders.h>: Includes Leptonica library headers for image processing. Initialize Tesseract API: tesseract::TessBaseAPI *api = new tesseract::TessBaseAPI();: Creates an instance of the Tesseract API. api->Init(NULL, “eng”);: Initializes the Tesseract API with the English language. You may specify the path to …

Optical Character Recognition (OCR) Gaming Project in C++ Read More »

Object Detection Gaming Project in C++

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

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

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

    // Open a video capture from the default camera
    cv::VideoCapture cap(0);
    if (!cap.isOpened()) {
        std::cerr << "Error opening video capture!" << std::endl;
        return -1;
    }

    cv::Mat frame;
    std::vector<cv::Rect> faces;

    while (true) {
        // Capture a new frame from the video feed
        cap >> frame;
        if (frame.empty()) {
            std::cerr << "Error capturing frame!" << std::endl;
            break;
        }

        // Convert the frame to grayscale
        cv::Mat gray;
        cv::cvtColor(frame, gray, cv::COLOR_BGR2GRAY);

        // Detect faces in the frame
        faceCascade.detectMultiScale(gray, faces, 1.1, 3, 0, cv::Size(30, 30));

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

        // Display the frame with detected faces
        cv::imshow("Object Detection", frame);

        // Exit loop when 'q' is pressed
        if (cv::waitKey(30) >= 0) {
            break;
        }
    }

    // Release video capture and close windows
    cap.release();
    cv::destroyAllWindows();

    return 0;
}

#include <opencv2/opencv.hpp>

#include <iostream>

int main() {

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

cv::CascadeClassifier faceCascade;

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

std::cerr << "Error loading Haar Cascade file!" << std::endl;

return -1;

}

// Open a video capture from the default camera

cv::VideoCapture cap(0);

if (!cap.isOpened()) {

std::cerr << "Error opening video capture!" << std::endl;

return -1;

}

cv::Mat frame;

std::vector<cv::Rect> faces;

while (true) {

// Capture a new frame from the video feed

cap >> frame;

if (frame.empty()) {

std::cerr << "Error capturing frame!" << std::endl;

break;

}

// Convert the frame to grayscale

cv::Mat gray;

cv::cvtColor(frame, gray, cv::COLOR_BGR2GRAY);

// Detect faces in the frame

faceCascade.detectMultiScale(gray, faces, 1.1, 3, 0, cv::Size(30, 30));

// Draw rectangles around detected faces

for (const auto& face : faces) {

cv::rectangle(frame, face, cv::Scalar(255, 0, 0), 2);

}

// Display the frame with detected faces

cv::imshow("Object Detection", frame);

// Exit loop when 'q' is pressed

if (cv::waitKey(30) >= 0) {

break;

}

// Release video capture and close windows

cap.release();

cv::destroyAllWindows();

return 0;

}

Explanation: Include OpenCV Header: #include <opencv2/opencv.hpp>: Includes the OpenCV core functionalities. Load Haar Cascade: cv::CascadeClassifier faceCascade;: Creates an object to load and use Haar cascade classifiers. faceCascade.load(“haarcascade_frontalface_default.xml”);: Loads the pre-trained Haar cascade for face detection. Ensure that the haarcascade_frontalface_default.xml file is available in your working directory or provide the correct path. Capture Video: cv::VideoCapture …

Object Detection Gaming Project in C++ Read More »

Number Guessing Game Gaming Project in C++

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

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

int main() {
    // Seed the random number generator
    std::srand(std::time(0));

    // Define the range for the random number
    const int MIN_NUMBER = 1;
    const int MAX_NUMBER = 100;

    // Generate a random number within the range
    int randomNumber = MIN_NUMBER + std::rand() % (MAX_NUMBER - MIN_NUMBER + 1);

    int guess;
    bool hasGuessedCorrectly = false;

    std::cout << "Welcome to the Number Guessing Game!" << std::endl;
    std::cout << "Guess the number between " << MIN_NUMBER << " and " << MAX_NUMBER << ": " << std::endl;

    while (!hasGuessedCorrectly) {
        std::cout << "Enter your guess: ";
        std::cin >> guess;

        if (guess < MIN_NUMBER || guess > MAX_NUMBER) {
            std::cout << "Please enter a number between " << MIN_NUMBER << " and " << MAX_NUMBER << "." << std::endl;
        } else if (guess < randomNumber) {
            std::cout << "Too low! Try again." << std::endl;
        } else if (guess > randomNumber) {
            std::cout << "Too high! Try again." << std::endl;
        } else {
            std::cout << "Congratulations! You guessed the number!" << std::endl;
            hasGuessedCorrectly = true;
        }
    }

    return 0;
}

#include <iostream>

#include <cstdlib>

#include <ctime>

int main() {

// Seed the random number generator

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

// Define the range for the random number

const int MIN_NUMBER = 1;

const int MAX_NUMBER = 100;

// Generate a random number within the range

int randomNumber = MIN_NUMBER + std::rand() % (MAX_NUMBER - MIN_NUMBER + 1);

int guess;

bool hasGuessedCorrectly = false;

std::cout << "Welcome to the Number Guessing Game!" << std::endl;

std::cout << "Guess the number between " << MIN_NUMBER << " and " << MAX_NUMBER << ": " << std::endl;

while (!hasGuessedCorrectly) {

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

std::cin >> guess;

if (guess < MIN_NUMBER || guess > MAX_NUMBER) {

std::cout << "Please enter a number between " << MIN_NUMBER << " and " << MAX_NUMBER << "." << std::endl;

} else if (guess < randomNumber) {

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

} else if (guess > randomNumber) {

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

} else {

std::cout << "Congratulations! You guessed the number!" << std::endl;

hasGuessedCorrectly = true;

}

return 0;

}

Explanation: Random Number Generation: std::srand(std::time(0)); seeds the random number generator using the current time to ensure different sequences of random numbers on each run. std::rand() generates a random integer. By scaling and shifting it, we get a number within the desired range. int randomNumber = MIN_NUMBER + std::rand() % (MAX_NUMBER – MIN_NUMBER + 1); …

Number Guessing Game Gaming Project in C++ Read More »

Neural Network Basics Gaming Project in C++

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

Neural Network Code:

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

const double LEARNING_RATE = 0.1;
const int INPUT_SIZE = 2;
const int HIDDEN_SIZE = 2;
const int OUTPUT_SIZE = 1;
const int NUM_EPOCHS = 10000;

// Sigmoid activation function
double sigmoid(double x) {
    return 1.0 / (1.0 + std::exp(-x));
}

// Derivative of sigmoid function
double sigmoid_derivative(double x) {
    return x * (1.0 - x);
}

// Neural Network class
class NeuralNetwork {
public:
    NeuralNetwork() {
        std::srand(std::time(0));
        
        // Initialize weights for hidden layer and output layer
        for (int i = 0; i < INPUT_SIZE; ++i) {
            for (int j = 0; j < HIDDEN_SIZE; ++j) {
                hiddenWeights[i][j] = (std::rand() / double(RAND_MAX)) - 0.5;
            }
        }
        
        for (int j = 0; j < HIDDEN_SIZE; ++j) {
            for (int k = 0; k < OUTPUT_SIZE; ++k) {
                outputWeights[j][k] = (std::rand() / double(RAND_MAX)) - 0.5;
            }
        }
        
        // Initialize biases
        for (int j = 0; j < HIDDEN_SIZE; ++j) {
            hiddenBiases[j] = (std::rand() / double(RAND_MAX)) - 0.5;
        }
        
        for (int k = 0; k < OUTPUT_SIZE; ++k) {
            outputBiases[k] = (std::rand() / double(RAND_MAX)) - 0.5;
        }
    }

    // Forward pass
    std::vector<double> forward(const std::vector<double>& input) {
        // Compute hidden layer activations
        std::vector<double> hiddenLayer(HIDDEN_SIZE);
        for (int j = 0; j < HIDDEN_SIZE; ++j) {
            double sum = 0.0;
            for (int i = 0; i < INPUT_SIZE; ++i) {
                sum += input[i] * hiddenWeights[i][j];
            }
            sum += hiddenBiases[j];
            hiddenLayer[j] = sigmoid(sum);
        }
        
        // Compute output layer activations
        std::vector<double> outputLayer(OUTPUT_SIZE);
        for (int k = 0; k < OUTPUT_SIZE; ++k) {
            double sum = 0.0;
            for (int j = 0; j < HIDDEN_SIZE; ++j) {
                sum += hiddenLayer[j] * outputWeights[j][k];
            }
            sum += outputBiases[k];
            outputLayer[k] = sigmoid(sum);
        }
        
        return outputLayer;
    }

    // Backpropagation to update weights
    void train(const std::vector<std::vector<double>>& inputs, const std::vector<std::vector<double>>& targets) {
        for (int epoch = 0; epoch < NUM_EPOCHS; ++epoch) {
            for (size_t i = 0; i < inputs.size(); ++i) {
                // Forward pass
                std::vector<double> hiddenLayer(HIDDEN_SIZE);
                std::vector<double> outputLayer(OUTPUT_SIZE);

                // Compute hidden layer activations
                for (int j = 0; j < HIDDEN_SIZE; ++j) {
                    double sum = 0.0;
                    for (int k = 0; k < INPUT_SIZE; ++k) {
                        sum += inputs[i][k] * hiddenWeights[k][j];
                    }
                    sum += hiddenBiases[j];
                    hiddenLayer[j] = sigmoid(sum);
                }

                // Compute output layer activations
                for (int k = 0; k < OUTPUT_SIZE; ++k) {
                    double sum = 0.0;
                    for (int j = 0; j < HIDDEN_SIZE; ++j) {
                        sum += hiddenLayer[j] * outputWeights[j][k];
                    }
                    sum += outputBiases[k];
                    outputLayer[k] = sigmoid(sum);
                }

                // Backpropagation
                std::vector<double> outputErrors(OUTPUT_SIZE);
                for (int k = 0; k < OUTPUT_SIZE; ++k) {
                    outputErrors[k] = targets[i][k] - outputLayer[k];
                }

                std::vector<double> hiddenErrors(HIDDEN_SIZE);
                for (int j = 0; j < HIDDEN_SIZE; ++j) {
                    hiddenErrors[j] = 0.0;
                    for (int k = 0; k < OUTPUT_SIZE; ++k) {
                        hiddenErrors[j] += outputErrors[k] * outputWeights[j][k];
                    }
                }

                // Update weights and biases for output layer
                for (int k = 0; k < OUTPUT_SIZE; ++k) {
                    for (int j = 0; j < HIDDEN_SIZE; ++j) {
                        double delta = LEARNING_RATE * outputErrors[k] * sigmoid_derivative(outputLayer[k]) * hiddenLayer[j];
                        outputWeights[j][k] += delta;
                    }
                    outputBiases[k] += LEARNING_RATE * outputErrors[k] * sigmoid_derivative(outputLayer[k]);
                }

                // Update weights and biases for hidden layer
                for (int j = 0; j < HIDDEN_SIZE; ++j) {
                    for (int k = 0; k < INPUT_SIZE; ++k) {
                        double delta = LEARNING_RATE * hiddenErrors[j] * sigmoid_derivative(hiddenLayer[j]) * inputs[i][k];
                        hiddenWeights[k][j] += delta;
                    }
                    hiddenBiases[j] += LEARNING_RATE * hiddenErrors[j] * sigmoid_derivative(hiddenLayer[j]);
                }
            }
        }
    }

private:
    double hiddenWeights[INPUT_SIZE][HIDDEN_SIZE];
    double outputWeights[HIDDEN_SIZE][OUTPUT_SIZE];
    double hiddenBiases[HIDDEN_SIZE];
    double outputBiases[OUTPUT_SIZE];
};

int main() {
    // Example dataset for training: XOR function
    std::vector<std::vector<double>> inputs = {
        {0.0, 0.0},
        {0.0, 1.0},
        {1.0, 0.0},
        {1.0, 1.0}
    };

    std::vector<std::vector<double>> targets = {
        {0.0},
        {1.0},
        {1.0},
        {0.0}
    };

    NeuralNetwork nn;
    nn.train(inputs, targets);

    std::cout << "Training completed.\n";

    // Test the network
    for (const auto& input : inputs) {
        std::vector<double> output = nn.forward(input);
        std::cout << "Input: ";
        for (double val : input) {
            std::cout << val << ' ';
        }
        std::cout << "-> Output: " << output[0] << std::endl;
    }

    return 0;
}

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

139

140

141

142

143

144

145

146

147

148

149

150

151

152

153

154

155

156

157

158

159

160

161

162

163

164

165

166

167

168

169

170

171

172

173

174

175

176

177

178

179

180

181

#include <iostream>

#include <vector>

#include <cmath>

#include <cstdlib>

#include <ctime>

const double LEARNING_RATE = 0.1;

const int INPUT_SIZE = 2;

const int HIDDEN_SIZE = 2;

const int OUTPUT_SIZE = 1;

const int NUM_EPOCHS = 10000;

// Sigmoid activation function

double sigmoid(double x) {

return 1.0 / (1.0 + std::exp(-x));

}

// Derivative of sigmoid function

double sigmoid_derivative(double x) {

return x * (1.0 - x);

}

// Neural Network class

class NeuralNetwork {

public:

NeuralNetwork() {

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

// Initialize weights for hidden layer and output layer

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

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

hiddenWeights[i][j] = (std::rand() / double(RAND_MAX)) - 0.5;

}

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

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

outputWeights[j][k] = (std::rand() / double(RAND_MAX)) - 0.5;

}

// Initialize biases

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

hiddenBiases[j] = (std::rand() / double(RAND_MAX)) - 0.5;

}

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

outputBiases[k] = (std::rand() / double(RAND_MAX)) - 0.5;

}

// Forward pass

std::vector<double> forward(const std::vector<double>& input) {

// Compute hidden layer activations

std::vector<double> hiddenLayer(HIDDEN_SIZE);

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

double sum = 0.0;

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

sum += input[i] * hiddenWeights[i][j];

}

sum += hiddenBiases[j];

hiddenLayer[j] = sigmoid(sum);

}

// Compute output layer activations

std::vector<double> outputLayer(OUTPUT_SIZE);

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

double sum = 0.0;

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

sum += hiddenLayer[j] * outputWeights[j][k];

}

sum += outputBiases[k];

outputLayer[k] = sigmoid(sum);

}

return outputLayer;

}

// Backpropagation to update weights

void train(const std::vector<std::vector<double>>& inputs, const std::vector<std::vector<double>>& targets) {

for (int epoch = 0; epoch < NUM_EPOCHS; ++epoch) {

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

// Forward pass

std::vector<double> hiddenLayer(HIDDEN_SIZE);

std::vector<double> outputLayer(OUTPUT_SIZE);

// Compute hidden layer activations

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

double sum = 0.0;

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

sum += inputs[i][k] * hiddenWeights[k][j];

}

sum += hiddenBiases[j];

hiddenLayer[j] = sigmoid(sum);

}

// Compute output layer activations

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

double sum = 0.0;

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

sum += hiddenLayer[j] * outputWeights[j][k];

}

sum += outputBiases[k];

outputLayer[k] = sigmoid(sum);

}

// Backpropagation

std::vector<double> outputErrors(OUTPUT_SIZE);

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

outputErrors[k] = targets[i][k] - outputLayer[k];

}

std::vector<double> hiddenErrors(HIDDEN_SIZE);

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

hiddenErrors[j] = 0.0;

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

hiddenErrors[j] += outputErrors[k] * outputWeights[j][k];

}

// Update weights and biases for output layer

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

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

double delta = LEARNING_RATE * outputErrors[k] * sigmoid_derivative(outputLayer[k]) * hiddenLayer[j];

outputWeights[j][k] += delta;

}

outputBiases[k] += LEARNING_RATE * outputErrors[k] * sigmoid_derivative(outputLayer[k]);

}

// Update weights and biases for hidden layer

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

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

double delta = LEARNING_RATE * hiddenErrors[j] * sigmoid_derivative(hiddenLayer[j]) * inputs[i][k];

hiddenWeights[k][j] += delta;

}

hiddenBiases[j] += LEARNING_RATE * hiddenErrors[j] * sigmoid_derivative(hiddenLayer[j]);

}

private:

double hiddenWeights[INPUT_SIZE][HIDDEN_SIZE];

double outputWeights[HIDDEN_SIZE][OUTPUT_SIZE];

double hiddenBiases[HIDDEN_SIZE];

double outputBiases[OUTPUT_SIZE];

};

int main() {

// Example dataset for training: XOR function

std::vector<std::vector<double>> inputs = {

{0.0, 0.0},

{0.0, 1.0},

{1.0, 0.0},

{1.0, 1.0}

};

std::vector<std::vector<double>> targets = {

{0.0},

{1.0},

{0.0}

};

NeuralNetwork nn;

nn.train(inputs, targets);

std::cout << "Training completed.\n";

// Test the network

for (const auto& input : inputs) {

std::vector<double> output = nn.forward(input);

std::cout << "Input: ";

for (double val : input) {

std::cout << val << ' ';

}

std::cout << "-> Output: " << output[0] << std::endl;

}

return 0;

}

Explanation: Activation Function: sigmoid(double x): Sigmoid activation function which squashes the input to the range [0, 1]. sigmoid_derivative(double x): Derivative of the sigmoid function used in backpropagation. Neural Network Class: Constructor: Initializes weights and biases randomly for both the hidden and output layers. forward(const std::vector<double>& input): Performs a forward pass through …

Neural Network Basics Gaming Project in C++ Read More »