C++ Projects – Projects Inventory

Quadratic Equation Solver Gaming Project in C++

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

#include <iostream>
#include <cmath>
#include <stdexcept>

// Function to calculate the roots of the quadratic equation
void solveQuadraticEquation(double a, double b, double c) {
    // Check if the equation is actually quadratic
    if (a == 0) {
        throw std::invalid_argument("Coefficient 'a' cannot be zero for a quadratic equation.");
    }

    // Calculate the discriminant
    double discriminant = b * b - 4 * a * c;

    std::cout << "Solving equation: " << a << "x^2 + " << b << "x + " << c << " = 0\n";

    // Check the discriminant value
    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.\n";
        std::cout << "Root 1: " << root1 << "\n";
        std::cout << "Root 2: " << root2 << "\n";
    } else if (discriminant == 0) {
        // One real root (repeated)
        double root = -b / (2 * a);
        std::cout << "Roots are real and the same.\n";
        std::cout << "Root: " << root << "\n";
    } else {
        // Complex roots
        double realPart = -b / (2 * a);
        double imaginaryPart = std::sqrt(-discriminant) / (2 * a);
        std::cout << "Roots are complex and different.\n";
        std::cout << "Root 1: " << realPart << " + " << imaginaryPart << "i\n";
        std::cout << "Root 2: " << realPart << " - " << imaginaryPart << "i\n";
    }
}

int main() {
    // Example coefficients for the quadratic equation
    double a = 1.0, b = -3.0, c = 2.0;

    try {
        solveQuadraticEquation(a, b, c);
    } catch (const std::exception& e) {
        std::cerr << "Error: " << e.what() << "\n";
    }

    return 0;
}

#include <iostream>

#include <cmath>

#include <stdexcept>

// Function to calculate the roots of the quadratic equation

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

// Check if the equation is actually quadratic

if (a == 0) {

throw std::invalid_argument("Coefficient 'a' cannot be zero for a quadratic equation.");

}

// Calculate the discriminant

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

std::cout << "Solving equation: " << a << "x^2 + " << b << "x + " << c << " = 0\n";

// Check the discriminant value

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.\n";

std::cout << "Root 1: " << root1 << "\n";

std::cout << "Root 2: " << root2 << "\n";

} else if (discriminant == 0) {

// One real root (repeated)

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

std::cout << "Roots are real and the same.\n";

std::cout << "Root: " << root << "\n";

} else {

// Complex roots

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

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

std::cout << "Roots are complex and different.\n";

std::cout << "Root 1: " << realPart << " + " << imaginaryPart << "i\n";

std::cout << "Root 2: " << realPart << " - " << imaginaryPart << "i\n";

}

int main() {

// Example coefficients for the quadratic equation

double a = 1.0, b = -3.0, c = 2.0;

try {

solveQuadraticEquation(a, b, c);

} catch (const std::exception& e) {

std::cerr << "Error: " << e.what() << "\n";

}

return 0;

}

Explanation solveQuadraticEquation Function: Parameters: Takes three coefficients a, b, and c representing the quadratic equation ax2+bx+c=0ax^2 + bx + c = 0ax2+bx+c=0. Discriminant Calculation: Computes the discriminant using the formula b2−4acb^2 – 4acb2−4ac. The discriminant determines the nature of the roots: If the discriminant is positive, the equation has two distinct real roots. If …

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

Simulation of Marketing Strategies Gaming Project in C++

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

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

// Define a structure for a marketing strategy
struct MarketingStrategy {
    std::string name;
    double effectiveness; // Effectiveness score (0.0 to 1.0)
};

// Define a class for a marketing campaign
class MarketingCampaign {
public:
    MarketingCampaign(const std::vector<MarketingStrategy>& strategies)
        : strategies(strategies) {
        std::srand(static_cast<unsigned>(std::time(nullptr))); // Seed for randomness
    }

    void simulateCampaign() {
        std::cout << "Simulating marketing campaign:\n";
        for (const auto& strategy : strategies) {
            double response = simulateCustomerResponse(strategy.effectiveness);
            std::cout << "Strategy: " << strategy.name << ", Response: " << response << "\n";
        }
    }

private:
    std::vector<MarketingStrategy> strategies;

    // Function to simulate customer response based on strategy effectiveness
    double simulateCustomerResponse(double effectiveness) {
        // Simulate a response score based on effectiveness
        return (effectiveness * (std::rand() % 100 + 1)) / 100.0;
    }
};

int main() {
    // Define some marketing strategies
    std::vector<MarketingStrategy> strategies = {
        {"Social Media Advertising", 0.7},
        {"Email Marketing", 0.5},
        {"Influencer Partnerships", 0.6},
        {"Content Marketing", 0.8}
    };

    // Create a marketing campaign
    MarketingCampaign campaign(strategies);

    // Simulate the marketing campaign
    campaign.simulateCampaign();

    return 0;
}

#include <iostream>

#include <vector>

#include <string>

#include <cstdlib>

#include <ctime>

// Define a structure for a marketing strategy

struct MarketingStrategy {

std::string name;

double effectiveness; // Effectiveness score (0.0 to 1.0)

};

// Define a class for a marketing campaign

class MarketingCampaign {

public:

MarketingCampaign(const std::vector<MarketingStrategy>& strategies)

: strategies(strategies) {

std::srand(static_cast<unsigned>(std::time(nullptr))); // Seed for randomness

}

void simulateCampaign() {

std::cout << "Simulating marketing campaign:\n";

for (const auto& strategy : strategies) {

double response = simulateCustomerResponse(strategy.effectiveness);

std::cout << "Strategy: " << strategy.name << ", Response: " << response << "\n";

}

private:

std::vector<MarketingStrategy> strategies;

// Function to simulate customer response based on strategy effectiveness

double simulateCustomerResponse(double effectiveness) {

// Simulate a response score based on effectiveness

return (effectiveness * (std::rand() % 100 + 1)) / 100.0;

}

};

int main() {

// Define some marketing strategies

std::vector<MarketingStrategy> strategies = {

{"Social Media Advertising", 0.7},

{"Email Marketing", 0.5},

{"Influencer Partnerships", 0.6},

{"Content Marketing", 0.8}

};

// Create a marketing campaign

MarketingCampaign campaign(strategies);

// Simulate the marketing campaign

campaign.simulateCampaign();

return 0;

}

Explanation MarketingStrategy Structure: Represents a marketing strategy with a name and an effectiveness score (ranging from 0.0 to 1.0). MarketingCampaign Class: Manages a list of marketing strategies and simulates their effectiveness. Constructor: Initializes the list of strategies and seeds the random number generator for customer response simulation. simulateCampaign() Method: Simulates the marketing campaign by …

Simulation of Marketing Strategies Gaming Project in C++ Read More »

Simulation of Manufacturing Systems Gaming Project in C++

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

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

// Define a structure for a product
struct Product {
    int id;
    std::string name;
};

// Define a class for a manufacturing machine
class Machine {
public:
    Machine(const std::string& name) : machineName(name) {}

    void addProduct(const Product& product) {
        queue.push(product);
    }

    void processProduct() {
        if (queue.empty()) {
            std::cout << machineName << " has no products to process.\n";
            return;
        }
        Product product = queue.front();
        queue.pop();
        std::cout << machineName << " processed product ID: " << product.id << ", Name: " << product.name << "\n";
    }

    bool hasProducts() const {
        return !queue.empty();
    }

private:
    std::string machineName;
    std::queue<Product> queue;
};

// Define a class for the manufacturing system
class ManufacturingSystem {
public:
    void addMachine(const Machine& machine) {
        machines.push_back(machine);
    }

    void addProductToMachine(int machineIndex, const Product& product) {
        if (machineIndex >= 0 && machineIndex < machines.size()) {
            machines[machineIndex].addProduct(product);
        } else {
            std::cout << "Invalid machine index.\n";
        }
    }

    void processAllMachines() {
        for (auto& machine : machines) {
            machine.processProduct();
        }
    }

private:
    std::vector<Machine> machines;
};

int main() {
    // Create machines
    Machine machine1("Machine 1");
    Machine machine2("Machine 2");
    Machine machine3("Machine 3");

    // Create a manufacturing system
    ManufacturingSystem system;
    system.addMachine(machine1);
    system.addMachine(machine2);
    system.addMachine(machine3);

    // Create and add products to machines
    system.addProductToMachine(0, {1, "Product A"});
    system.addProductToMachine(1, {2, "Product B"});
    system.addProductToMachine(2, {3, "Product C"});
    system.addProductToMachine(0, {4, "Product D"});

    // Process all machines
    std::cout << "Processing products:\n";
    system.processAllMachines();

    return 0;
}

#include <iostream>

#include <queue>

#include <vector>

#include <string>

// Define a structure for a product

struct Product {

int id;

std::string name;

};

// Define a class for a manufacturing machine

class Machine {

public:

Machine(const std::string& name) : machineName(name) {}

void addProduct(const Product& product) {

queue.push(product);

}

void processProduct() {

if (queue.empty()) {

std::cout << machineName << " has no products to process.\n";

return;

}

Product product = queue.front();

queue.pop();

std::cout << machineName << " processed product ID: " << product.id << ", Name: " << product.name << "\n";

}

bool hasProducts() const {

return !queue.empty();

}

private:

std::string machineName;

std::queue<Product> queue;

};

// Define a class for the manufacturing system

class ManufacturingSystem {

public:

void addMachine(const Machine& machine) {

machines.push_back(machine);

}

void addProductToMachine(int machineIndex, const Product& product) {

if (machineIndex >= 0 && machineIndex < machines.size()) {

machines[machineIndex].addProduct(product);

} else {

std::cout << "Invalid machine index.\n";

}

void processAllMachines() {

for (auto& machine : machines) {

machine.processProduct();

}

private:

std::vector<Machine> machines;

};

int main() {

// Create machines

Machine machine1("Machine 1");

Machine machine2("Machine 2");

Machine machine3("Machine 3");

// Create a manufacturing system

ManufacturingSystem system;

system.addMachine(machine1);

system.addMachine(machine2);

system.addMachine(machine3);

// Create and add products to machines

system.addProductToMachine(0, {1, "Product A"});

system.addProductToMachine(1, {2, "Product B"});

system.addProductToMachine(2, {3, "Product C"});

system.addProductToMachine(0, {4, "Product D"});

// Process all machines

std::cout << "Processing products:\n";

system.processAllMachines();

return 0;

}

Explanation Product Structure: Represents a product with an id and a name. Machine Class: Represents a manufacturing machine with a name and a queue to hold products. Methods: addProduct(const Product& product): Adds a product to the machine’s queue. processProduct(): Processes the product at the front of the queue and removes it. hasProducts() const: Checks …

Simulation of Manufacturing Systems Gaming Project in C++ Read More »

Simulation of Machine Learning Algorithms Gaming Project in C++

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

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

// Define a structure to hold data points
struct DataPoint {
    std::vector<double> features; // Features of the data point
    int label; // Class label
};

// Function to calculate Euclidean distance between two data points
double euclideanDistance(const DataPoint& a, const DataPoint& b) {
    double sum = 0.0;
    for (size_t i = 0; i < a.features.size(); ++i) {
        double diff = a.features[i] - b.features[i];
        sum += diff * diff;
    }
    return std::sqrt(sum);
}

// Function to perform K-Nearest Neighbors classification
int knn(const std::vector<DataPoint>& trainingData, const DataPoint& testPoint, int k) {
    std::vector<std::pair<double, int>> distances;

    // Calculate distance from testPoint to each point in trainingData
    for (const auto& trainPoint : trainingData) {
        double dist = euclideanDistance(testPoint, trainPoint);
        distances.emplace_back(dist, trainPoint.label);
    }

    // Sort distances by the first element (distance)
    std::sort(distances.begin(), distances.end());

    // Count the labels of the k nearest neighbors
    std::vector<int> labelCount(10, 0); // Assuming labels are in the range [0, 9]
    for (int i = 0; i < k; ++i) {
        labelCount[distances[i].second]++;
    }

    // Find the most frequent label
    int maxCount = 0;
    int predictedLabel = -1;
    for (int i = 0; i < labelCount.size(); ++i) {
        if (labelCount[i] > maxCount) {
            maxCount = labelCount[i];
            predictedLabel = i;
        }
    }

    return predictedLabel;
}

int main() {
    // Sample training data
    std::vector<DataPoint> trainingData = {
        {{1.0, 2.0}, 0},
        {{2.0, 3.0}, 0},
        {{3.0, 4.0}, 1},
        {{5.0, 5.0}, 1}
    };

    // Sample test data
    DataPoint testPoint = {{4.0, 4.0}, -1}; // -1 indicates that we don't know the label

    // Number of neighbors to consider
    int k = 3;

    // Perform KNN classification
    int predictedLabel = knn(trainingData, testPoint, k);

    // Display the result
    std::cout << "Predicted label for test point: " << predictedLabel << "\n";

    return 0;
}

#include <iostream>

#include <vector>

#include <cmath>

#include <algorithm>

// Define a structure to hold data points

struct DataPoint {

std::vector<double> features; // Features of the data point

int label; // Class label

};

// Function to calculate Euclidean distance between two data points

double euclideanDistance(const DataPoint& a, const DataPoint& b) {

double sum = 0.0;

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

double diff = a.features[i] - b.features[i];

sum += diff * diff;

}

return std::sqrt(sum);

}

// Function to perform K-Nearest Neighbors classification

int knn(const std::vector<DataPoint>& trainingData, const DataPoint& testPoint, int k) {

std::vector<std::pair<double, int>> distances;

// Calculate distance from testPoint to each point in trainingData

for (const auto& trainPoint : trainingData) {

double dist = euclideanDistance(testPoint, trainPoint);

distances.emplace_back(dist, trainPoint.label);

}

// Sort distances by the first element (distance)

std::sort(distances.begin(), distances.end());

// Count the labels of the k nearest neighbors

std::vector<int> labelCount(10, 0); // Assuming labels are in the range [0, 9]

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

labelCount[distances[i].second]++;

}

// Find the most frequent label

int maxCount = 0;

int predictedLabel = -1;

for (int i = 0; i < labelCount.size(); ++i) {

if (labelCount[i] > maxCount) {

maxCount = labelCount[i];

predictedLabel = i;

}

return predictedLabel;

}

int main() {

// Sample training data

std::vector<DataPoint> trainingData = {

{{1.0, 2.0}, 0},

{{2.0, 3.0}, 0},

{{3.0, 4.0}, 1},

{{5.0, 5.0}, 1}

};

// Sample test data

DataPoint testPoint = {{4.0, 4.0}, -1}; // -1 indicates that we don't know the label

// Number of neighbors to consider

int k = 3;

// Perform KNN classification

int predictedLabel = knn(trainingData, testPoint, k);

// Display the result

std::cout << "Predicted label for test point: " << predictedLabel << "\n";

return 0;

}

Explanation DataPoint Structure: Represents a data point with a vector of features and a label. euclideanDistance Function: Computes the Euclidean distance between two DataPoint objects based on their feature vectors. knn Function: Performs K-Nearest Neighbors classification. Calculates the distance between the test point and each training data point. Sorts the distances and selects the …

Simulation of Machine Learning Algorithms Gaming Project in C++ Read More »

Simulation of Magnetic Fields Gaming Project in C++

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

#include <iostream>
#include <vector>
#include <cmath>

// Define a structure for a magnetic pole
struct MagneticPole {
    double x, y; // Position of the magnetic pole
    double strength; // Strength of the magnetic pole
};

// Define a structure for a magnetic field vector
struct MagneticFieldVector {
    double x, y; // Direction components
    double magnitude; // Magnitude of the field
};

// Function to calculate the magnetic field vector at a given point
MagneticFieldVector calculateField(const std::vector<MagneticPole>& poles, double px, double py) {
    MagneticFieldVector field = {0.0, 0.0, 0.0};

    for (const auto& pole : poles) {
        double dx = px - pole.x;
        double dy = py - pole.y;
        double distance = std::sqrt(dx * dx + dy * dy);
        if (distance > 0) {
            double fieldStrength = pole.strength / (distance * distance);
            field.x += fieldStrength * (dx / distance);
            field.y += fieldStrength * (dy / distance);
            field.magnitude += fieldStrength;
        }
    }
    
    return field;
}

// Function to display the magnetic field vector
void displayField(const MagneticFieldVector& field) {
    std::cout << "Magnetic Field Vector:\n";
    std::cout << "Direction: (" << field.x << ", " << field.y << ")\n";
    std::cout << "Magnitude: " << field.magnitude << "\n";
}

int main() {
    // Define magnetic poles
    std::vector<MagneticPole> poles = {
        {0.0, 0.0, 10.0}, // Pole at (0, 0) with strength 10
        {5.0, 5.0, 5.0}   // Pole at (5, 5) with strength 5
    };

    // Define a point to calculate the magnetic field
    double pointX = 3.0;
    double pointY = 3.0;

    // Calculate the magnetic field at the point
    MagneticFieldVector field = calculateField(poles, pointX, pointY);

    // Display the magnetic field vector
    displayField(field);

    return 0;
}

#include <iostream>

#include <vector>

#include <cmath>

// Define a structure for a magnetic pole

struct MagneticPole {

double x, y; // Position of the magnetic pole

double strength; // Strength of the magnetic pole

};

// Define a structure for a magnetic field vector

struct MagneticFieldVector {

double x, y; // Direction components

double magnitude; // Magnitude of the field

};

// Function to calculate the magnetic field vector at a given point

MagneticFieldVector calculateField(const std::vector<MagneticPole>& poles, double px, double py) {

MagneticFieldVector field = {0.0, 0.0, 0.0};

for (const auto& pole : poles) {

double dx = px - pole.x;

double dy = py - pole.y;

double distance = std::sqrt(dx * dx + dy * dy);

if (distance > 0) {

double fieldStrength = pole.strength / (distance * distance);

field.x += fieldStrength * (dx / distance);

field.y += fieldStrength * (dy / distance);

field.magnitude += fieldStrength;

}

return field;

}

// Function to display the magnetic field vector

void displayField(const MagneticFieldVector& field) {

std::cout << "Magnetic Field Vector:\n";

std::cout << "Direction: (" << field.x << ", " << field.y << ")\n";

std::cout << "Magnitude: " << field.magnitude << "\n";

}

int main() {

// Define magnetic poles

std::vector<MagneticPole> poles = {

{0.0, 0.0, 10.0}, // Pole at (0, 0) with strength 10

{5.0, 5.0, 5.0} // Pole at (5, 5) with strength 5

};

// Define a point to calculate the magnetic field

double pointX = 3.0;

double pointY = 3.0;

// Calculate the magnetic field at the point

MagneticFieldVector field = calculateField(poles, pointX, pointY);

// Display the magnetic field vector

displayField(field);

return 0;

}

Explanation MagneticPole Structure: Represents a magnetic pole with its position (x, y) and strength. MagneticFieldVector Structure: Represents a magnetic field vector with direction components (x, y) and magnitude. calculateField Function: Takes a vector of magnetic poles and a point (px, py) as input. Calculates the magnetic field vector at the point by summing the …

Simulation of Magnetic Fields Gaming Project in C++ Read More »

Simulation of L-Systems Gaming Project in C++

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

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

class LSystem {
public:
    LSystem(const std::string& axiom, const std::unordered_map<char, std::string>& rules)
        : currentString(axiom), productionRules(rules) {}

    void generate(int iterations) {
        for (int i = 0; i < iterations; ++i) {
            std::string nextString;
            for (char ch : currentString) {
                if (productionRules.find(ch) != productionRules.end()) {
                    nextString += productionRules.at(ch);
                } else {
                    nextString += ch;
                }
            }
            currentString = nextString;
        }
    }

    void display() const {
        std::cout << "L-System string: " << currentString << "\n";
    }

private:
    std::string currentString;
    std::unordered_map<char, std::string> productionRules;
};

int main() {
    // Define the axiom and production rules for the L-System
    std::string axiom = "F";
    std::unordered_map<char, std::string> rules = {
        {'F', "F+F-F-F+F"}
    };

    // Create an LSystem object
    LSystem lSystem(axiom, rules);

    // Generate the L-System string for a number of iterations
    int iterations = 4;
    lSystem.generate(iterations);

    // Display the generated L-System string
    lSystem.display();

    return 0;
}

#include <iostream>

#include <string>

#include <unordered_map>

#include <vector>

class LSystem {

public:

LSystem(const std::string& axiom, const std::unordered_map<char, std::string>& rules)

: currentString(axiom), productionRules(rules) {}

void generate(int iterations) {

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

std::string nextString;

for (char ch : currentString) {

if (productionRules.find(ch) != productionRules.end()) {

nextString += productionRules.at(ch);

} else {

nextString += ch;

}

currentString = nextString;

}

void display() const {

std::cout << "L-System string: " << currentString << "\n";

}

private:

std::string currentString;

std::unordered_map<char, std::string> productionRules;

};

int main() {

// Define the axiom and production rules for the L-System

std::string axiom = "F";

std::unordered_map<char, std::string> rules = {

{'F', "F+F-F-F+F"}

};

// Create an LSystem object

LSystem lSystem(axiom, rules);

// Generate the L-System string for a number of iterations

int iterations = 4;

lSystem.generate(iterations);

// Display the generated L-System string

lSystem.display();

return 0;

}

Explanation LSystem Class: Attributes: currentString: Holds the current state of the L-System string. productionRules: A map of production rules where each character maps to its replacement string. Methods: LSystem(const std::string& axiom, const std::unordered_map<char, std::string>& rules): Constructor initializes the L-System with an axiom and production rules. void generate(int iterations): Generates the L-System string for a …

Simulation of L-Systems Gaming Project in C++ Read More »

Simulation of Inventory Management Gaming Project in C++

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

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

class Item {
public:
    Item(const std::string& name, int quantity) : itemName(name), itemQuantity(quantity) {}

    std::string getName() const {
        return itemName;
    }

    int getQuantity() const {
        return itemQuantity;
    }

    void setQuantity(int quantity) {
        itemQuantity = quantity;
    }

    void display() const {
        std::cout << "Item: " << itemName << ", Quantity: " << itemQuantity << "\n";
    }

private:
    std::string itemName;
    int itemQuantity;
};

class Inventory {
public:
    void addItem(const Item& item) {
        auto it = std::find_if(items.begin(), items.end(), [&](const Item& i) {
            return i.getName() == item.getName();
        });
        if (it != items.end()) {
            it->setQuantity(it->getQuantity() + item.getQuantity());
        } else {
            items.push_back(item);
        }
    }

    void removeItem(const std::string& itemName, int quantity) {
        auto it = std::find_if(items.begin(), items.end(), [&](const Item& i) {
            return i.getName() == itemName;
        });
        if (it != items.end()) {
            int newQuantity = it->getQuantity() - quantity;
            if (newQuantity <= 0) {
                items.erase(it);
            } else {
                it->setQuantity(newQuantity);
            }
        } else {
            std::cout << "Item not found.\n";
        }
    }

    void displayInventory() const {
        std::cout << "Inventory:\n";
        for (const auto& item : items) {
            item.display();
        }
    }

private:
    std::vector<Item> items;
};

int main() {
    Inventory inventory;

    // Add items to inventory
    inventory.addItem(Item("Sword", 1));
    inventory.addItem(Item("Health Potion", 5));
    inventory.addItem(Item("Mana Potion", 3));

    // Display inventory
    inventory.displayInventory();

    // Remove items from inventory
    inventory.removeItem("Health Potion", 2);

    // Display inventory after removal
    inventory.displayInventory();

    return 0;
}

#include <iostream>

#include <vector>

#include <string>

#include <algorithm>

class Item {

public:

Item(const std::string& name, int quantity) : itemName(name), itemQuantity(quantity) {}

std::string getName() const {

return itemName;

}

int getQuantity() const {

return itemQuantity;

}

void setQuantity(int quantity) {

itemQuantity = quantity;

}

void display() const {

std::cout << "Item: " << itemName << ", Quantity: " << itemQuantity << "\n";

}

private:

std::string itemName;

int itemQuantity;

};

class Inventory {

public:

void addItem(const Item& item) {

auto it = std::find_if(items.begin(), items.end(), [&](const Item& i) {

return i.getName() == item.getName();

});

if (it != items.end()) {

it->setQuantity(it->getQuantity() + item.getQuantity());

} else {

items.push_back(item);

}

void removeItem(const std::string& itemName, int quantity) {

auto it = std::find_if(items.begin(), items.end(), [&](const Item& i) {

return i.getName() == itemName;

});

if (it != items.end()) {

int newQuantity = it->getQuantity() - quantity;

if (newQuantity <= 0) {

items.erase(it);

} else {

it->setQuantity(newQuantity);

}

} else {

std::cout << "Item not found.\n";

}

void displayInventory() const {

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

for (const auto& item : items) {

item.display();

}

private:

std::vector<Item> items;

};

int main() {

Inventory inventory;

// Add items to inventory

inventory.addItem(Item("Sword", 1));

inventory.addItem(Item("Health Potion", 5));

inventory.addItem(Item("Mana Potion", 3));

// Display inventory

inventory.displayInventory();

// Remove items from inventory

inventory.removeItem("Health Potion", 2);

// Display inventory after removal

inventory.displayInventory();

return 0;

}

Explanation Item Class: Represents an individual item with a name and quantity. Provides methods to get the name and quantity, set the quantity, and display the item. Inventory Class: Manages a collection of Item objects. The addItem() function adds items to the inventory. If an item already exists, it updates the quantity. The removeItem() …

Simulation of Inventory Management Gaming Project in C++ Read More »

Simulation of Internet of Things (IoT) Gaming Project in C++

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

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

class IoTDevice {
public:
    IoTDevice(const std::string& id) : deviceId(id) {}

    std::string getId() const {
        return deviceId;
    }

    virtual double getData() const = 0; // Pure virtual function

protected:
    std::string deviceId;
};

class TemperatureSensor : public IoTDevice {
public:
    TemperatureSensor(const std::string& id) : IoTDevice(id) {}

    double getData() const override {
        // Simulate temperature data between -10 and 35 degrees Celsius
        return -10 + static_cast<double>(rand()) / RAND_MAX * 45;
    }
};

class HumiditySensor : public IoTDevice {
public:
    HumiditySensor(const std::string& id) : IoTDevice(id) {}

    double getData() const override {
        // Simulate humidity data between 0 and 100 percent
        return static_cast<double>(rand()) / RAND_MAX * 100;
    }
};

class IoTServer {
public:
    void addDevice(IoTDevice* device) {
        devices.push_back(device);
    }

    void collectData() {
        std::cout << "Collecting data from IoT devices:\n";
        for (const auto& device : devices) {
            std::cout << "Device ID: " << device->getId() << ", Data: " << device->getData() << "\n";
        }
    }

private:
    std::vector<IoTDevice*> devices;
};

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

    IoTServer server;

    // Create and add devices to the server
    TemperatureSensor tempSensor1("Temp01");
    TemperatureSensor tempSensor2("Temp02");
    HumiditySensor humiditySensor1("Humidity01");

    server.addDevice(&tempSensor1);
    server.addDevice(&tempSensor2);
    server.addDevice(&humiditySensor1);

    // Collect and display data
    server.collectData();

    return 0;
}

#include <iostream>

#include <vector>

#include <string>

#include <cstdlib>

#include <ctime>

class IoTDevice {

public:

IoTDevice(const std::string& id) : deviceId(id) {}

std::string getId() const {

return deviceId;

}

virtual double getData() const = 0; // Pure virtual function

protected:

std::string deviceId;

};

class TemperatureSensor : public IoTDevice {

public:

TemperatureSensor(const std::string& id) : IoTDevice(id) {}

double getData() const override {

// Simulate temperature data between -10 and 35 degrees Celsius

return -10 + static_cast<double>(rand()) / RAND_MAX * 45;

}

};

class HumiditySensor : public IoTDevice {

public:

HumiditySensor(const std::string& id) : IoTDevice(id) {}

double getData() const override {

// Simulate humidity data between 0 and 100 percent

return static_cast<double>(rand()) / RAND_MAX * 100;

}

};

class IoTServer {

public:

void addDevice(IoTDevice* device) {

devices.push_back(device);

}

void collectData() {

std::cout << "Collecting data from IoT devices:\n";

for (const auto& device : devices) {

std::cout << "Device ID: " << device->getId() << ", Data: " << device->getData() << "\n";

}

private:

std::vector<IoTDevice*> devices;

};

int main() {

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

IoTServer server;

// Create and add devices to the server

TemperatureSensor tempSensor1("Temp01");

TemperatureSensor tempSensor2("Temp02");

HumiditySensor humiditySensor1("Humidity01");

server.addDevice(&tempSensor1);

server.addDevice(&tempSensor2);

server.addDevice(&humiditySensor1);

// Collect and display data

server.collectData();

return 0;

}

Explanation IoTDevice Class: A base class representing a generic IoT device with a deviceId and a pure virtual function getData(), which must be implemented by derived classes. TemperatureSensor Class: Inherits from IoTDevice. Implements getData() to simulate temperature readings between -10 and 35 degrees Celsius. HumiditySensor Class: Inherits from IoTDevice. Implements getData() to simulate humidity …

Simulation of Internet of Things (IoT) Gaming Project in C++ Read More »

Simulation of Image Recognition Gaming Project in C++

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

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

const int WIDTH = 5;
const int HEIGHT = 5;
const int THRESHOLD = 128;

class Image {
public:
    Image(const std::vector<std::vector<int>>& pixels) : pixels(pixels) {}

    void applyThreshold() {
        for (int i = 0; i < HEIGHT; ++i) {
            for (int j = 0; j < WIDTH; ++j) {
                pixels[i][j] = (pixels[i][j] >= THRESHOLD) ? 255 : 0;
            }
        }
    }

    void printImage() const {
        for (const auto& row : pixels) {
            for (int pixel : row) {
                std::cout << (pixel == 255 ? '#' : ' ') << ' ';
            }
            std::cout << '\n';
        }
    }

private:
    std::vector<std::vector<int>> pixels;
};

int main() {
    // Example grayscale image (5x5)
    std::vector<std::vector<int>> grayscaleImage = {
        { 10, 50, 150, 200, 250 },
        { 30, 70, 120, 180, 220 },
        { 40, 90, 130, 190, 240 },
        { 60, 100, 140, 170, 210 },
        { 80, 110, 160, 180, 230 }
    };

    Image image(grayscaleImage);

    std::cout << "Original Image:\n";
    image.printImage();

    image.applyThreshold();

    std::cout << "\nThresholded Image:\n";
    image.printImage();

    return 0;
}

#include <iostream>

#include <vector>

#include <algorithm>

const int WIDTH = 5;

const int HEIGHT = 5;

const int THRESHOLD = 128;

class Image {

public:

Image(const std::vector<std::vector<int>>& pixels) : pixels(pixels) {}

void applyThreshold() {

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

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

pixels[i][j] = (pixels[i][j] >= THRESHOLD) ? 255 : 0;

}

void printImage() const {

for (const auto& row : pixels) {

for (int pixel : row) {

std::cout << (pixel == 255 ? '#' : ' ') << ' ';

}

std::cout << '\n';

}

private:

std::vector<std::vector<int>> pixels;

};

int main() {

// Example grayscale image (5x5)

std::vector<std::vector<int>> grayscaleImage = {

{ 10, 50, 150, 200, 250 },

{ 30, 70, 120, 180, 220 },

{ 40, 90, 130, 190, 240 },

{ 60, 100, 140, 170, 210 },

{ 80, 110, 160, 180, 230 }

};

Image image(grayscaleImage);

std::cout << "Original Image:\n";

image.printImage();

image.applyThreshold();

std::cout << "\nThresholded Image:\n";

image.printImage();

return 0;

}

Explanation Class Definition (Image): Private Members: pixels: A 2D vector representing the grayscale image, where each element is a pixel intensity (0 to 255). Public Methods: Image(const std::vector<std::vector<int>>& pixels): Constructor initializes the image with given pixel values. void applyThreshold(): Applies a threshold to the image. Pixels with intensity greater than or equal to THRESHOLD …

Simulation of Image Recognition Gaming Project in C++ Read More »

Simulation of Human Resource Management Gaming Project in C++

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

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

class Employee {
public:
    Employee(std::string name, int performance) : name(name), performance(performance) {}

    std::string getName() const {
        return name;
    }

    int getPerformance() const {
        return performance;
    }

    void setPerformance(int newPerformance) {
        performance = newPerformance;
    }

private:
    std::string name;
    int performance;
};

class HRSystem {
public:
    void addEmployee(const Employee& employee) {
        employees.push_back(employee);
    }

    void evaluatePerformance() {
        for (auto& employee : employees) {
            int newPerformance = employee.getPerformance() + (std::rand() % 21 - 10); // Random change between -10 and +10
            employee.setPerformance(std::clamp(newPerformance, 0, 100)); // Ensure performance is between 0 and 100
        }
    }

    void printEmployees() const {
        for (const auto& employee : employees) {
            std::cout << "Name: " << employee.getName() << ", Performance: " << employee.getPerformance() << '\n';
        }
    }

private:
    std::vector<Employee> employees;
};

int main() {
    std::srand(static_cast<unsigned>(std::time(0)));

    HRSystem hr;

    // Adding employees
    hr.addEmployee(Employee("Alice", 80));
    hr.addEmployee(Employee("Bob", 70));
    hr.addEmployee(Employee("Charlie", 90));

    std::cout << "Initial employee performance:\n";
    hr.printEmployees();

    int months = 6;
    for (int i = 0; i < months; ++i) {
        hr.evaluatePerformance();
        std::cout << "\nPerformance after month " << (i + 1) << ":\n";
        hr.printEmployees();
    }

    return 0;
}

#include <iostream>

#include <vector>

#include <string>

#include <algorithm>

class Employee {

public:

Employee(std::string name, int performance) : name(name), performance(performance) {}

std::string getName() const {

return name;

}

int getPerformance() const {

return performance;

}

void setPerformance(int newPerformance) {

performance = newPerformance;

}

private:

std::string name;

int performance;

};

class HRSystem {

public:

void addEmployee(const Employee& employee) {

employees.push_back(employee);

}

void evaluatePerformance() {

for (auto& employee : employees) {

int newPerformance = employee.getPerformance() + (std::rand() % 21 - 10); // Random change between -10 and +10

employee.setPerformance(std::clamp(newPerformance, 0, 100)); // Ensure performance is between 0 and 100

}

void printEmployees() const {

for (const auto& employee : employees) {

std::cout << "Name: " << employee.getName() << ", Performance: " << employee.getPerformance() << '\n';

}

private:

std::vector<Employee> employees;

};

int main() {

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

HRSystem hr;

// Adding employees

hr.addEmployee(Employee("Alice", 80));

hr.addEmployee(Employee("Bob", 70));

hr.addEmployee(Employee("Charlie", 90));

std::cout << "Initial employee performance:\n";

hr.printEmployees();

int months = 6;

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

hr.evaluatePerformance();

std::cout << "\nPerformance after month " << (i + 1) << ":\n";

hr.printEmployees();

}

return 0;

}

Explanation Class Definitions: Employee Class: Private Members: name: The name of the employee. performance: The performance rating of the employee (0 to 100). Public Methods: Employee(std::string name, int performance): Constructor initializes the employee’s name and performance rating. std::string getName() const: Returns the employee’s name. int getPerformance() const: Returns the employee’s performance rating. void setPerformance(int …

Simulation of Human Resource Management Gaming Project in C++ Read More »