C++ Projects – Page 7 – Projects Inventory

Simulation of Stock Market Trends Gaming Project in C++

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

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

// Class to represent a stock
class Stock {
public:
    Stock(const std::string& name, double initialPrice)
        : name(name), price(initialPrice) {}

    // Method to update the stock price with random fluctuations
    void updatePrice() {
        // Generate a random percentage change between -5% and +5%
        double percentageChange = (rand() % 10001 - 5000) / 100.0;
        double change = price * (percentageChange / 100.0);
        price += change;

        // Ensure the price doesn't drop below zero
        if (price < 0) price = 0;
    }

    // Method to print the stock information
    void printInfo() const {
        std::cout << std::fixed << std::setprecision(2)
                  << name << " | Price: $" << price << std::endl;
    }

private:
    std::string name;
    double price;
};

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

    // Create a list of stocks
    std::vector<Stock> stocks = {
        Stock("AAPL", 150.00),
        Stock("GOOGL", 2800.00),
        Stock("AMZN", 3400.00)
    };

    const int simulationSteps = 10; // Number of simulation steps

    for (int step = 0; step < simulationSteps; ++step) {
        std::cout << "Step " << (step + 1) << ":\n";
        
        // Update and print the information for each stock
        for (auto& stock : stocks) {
            stock.updatePrice();
            stock.printInfo();
        }

        std::cout << std::endl;
        std::this_thread::sleep_for(std::chrono::seconds(1)); // Simulate time passing
    }

    return 0;
}

#include <iostream>

#include <vector>

#include <cstdlib>

#include <ctime>

#include <iomanip>

// Class to represent a stock

class Stock {

public:

Stock(const std::string& name, double initialPrice)

: name(name), price(initialPrice) {}

// Method to update the stock price with random fluctuations

void updatePrice() {

// Generate a random percentage change between -5% and +5%

double percentageChange = (rand() % 10001 - 5000) / 100.0;

double change = price * (percentageChange / 100.0);

price += change;

// Ensure the price doesn't drop below zero

if (price < 0) price = 0;

}

// Method to print the stock information

void printInfo() const {

std::cout << std::fixed << std::setprecision(2)

<< name << " | Price: $" << price << std::endl;

}

private:

std::string name;

double price;

};

int main() {

srand(time(0)); // Seed the random number generator

// Create a list of stocks

std::vector<Stock> stocks = {

Stock("AAPL", 150.00),

Stock("GOOGL", 2800.00),

Stock("AMZN", 3400.00)

};

const int simulationSteps = 10; // Number of simulation steps

for (int step = 0; step < simulationSteps; ++step) {

std::cout << "Step " << (step + 1) << ":\n";

// Update and print the information for each stock

for (auto& stock : stocks) {

stock.updatePrice();

stock.printInfo();

}

std::cout << std::endl;

std::this_thread::sleep_for(std::chrono::seconds(1)); // Simulate time passing

}

return 0;

}

Explanation Stock Class: Attributes: name: Name of the stock. price: Current price of the stock. Methods: updatePrice(): Updates the stock price with a random percentage change between -5% and +5%. Ensures the price does not go below zero. printInfo(): Prints the current stock name and price, formatted to two decimal places. Main Function: Random …

Simulation of Stock Market Trends Gaming Project in C++ Read More »

Simulation of Supply Chain Management Gaming Project in C++

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

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

// Class to represent a product
class Product {
public:
    Product(const std::string& name, int quantity) 
        : name(name), quantity(quantity) {}

    // Method to get product information
    void getInfo() const {
        std::cout << name << ": " << quantity << " units\n";
    }

    // Method to adjust the quantity
    void adjustQuantity(int amount) {
        quantity += amount;
    }

    // Method to check if there's enough stock
    bool hasStock(int amount) const {
        return quantity >= amount;
    }

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

// Class to represent a supplier
class Supplier {
public:
    Supplier(const std::string& name) : name(name) {}

    // Method to supply products to a warehouse
    void supply(Product& product, int amount) {
        std::cout << name << " supplies " << amount << " units of " << product.getName() << "\n";
        product.adjustQuantity(amount);
    }

private:
    std::string name;
};

// Class to represent a warehouse
class Warehouse {
public:
    Warehouse(const std::string& name) : name(name) {}

    // Method to store products
    void store(Product& product, int amount) {
        std::cout << name << " stores " << amount << " units of " << product.getName() << "\n";
        product.adjustQuantity(amount);
    }

    // Method to dispatch products to a retailer
    void dispatch(Product& product, int amount) {
        if (product.hasStock(amount)) {
            std::cout << name << " dispatches " << amount << " units of " << product.getName() << "\n";
            product.adjustQuantity(-amount);
        } else {
            std::cout << name << " does not have enough stock to dispatch " << amount << " units of " << product.getName() << "\n";
        }
    }

private:
    std::string name;
};

// Class to represent a retailer
class Retailer {
public:
    Retailer(const std::string& name) : name(name) {}

    // Method to receive products from a warehouse
    void receive(Product& product, int amount) {
        std::cout << name << " receives " << amount << " units of " << product.getName() << "\n";
        product.adjustQuantity(amount);
    }

private:
    std::string name;
};

int main() {
    // Create products
    Product widget("Widget", 0);

    // Create entities in the supply chain
    Supplier supplier("Supplier A");
    Warehouse warehouse("Warehouse B");
    Retailer retailer("Retailer C");

    // Simulate the supply chain
    supplier.supply(widget, 100);
    warehouse.store(widget, 100);
    warehouse.dispatch(widget, 50);
    retailer.receive(widget, 50);
    warehouse.dispatch(widget, 60); // This will fail due to insufficient stock

    // Print final stock of the product
    widget.getInfo();

    return 0;
}

100

101

102

103

104

105

106

#include <iostream>

#include <vector>

#include <string>

// Class to represent a product

class Product {

public:

Product(const std::string& name, int quantity)

: name(name), quantity(quantity) {}

// Method to get product information

void getInfo() const {

std::cout << name << ": " << quantity << " units\n";

}

// Method to adjust the quantity

void adjustQuantity(int amount) {

quantity += amount;

}

// Method to check if there's enough stock

bool hasStock(int amount) const {

return quantity >= amount;

}

private:

std::string name;

int quantity;

};

// Class to represent a supplier

class Supplier {

public:

Supplier(const std::string& name) : name(name) {}

// Method to supply products to a warehouse

void supply(Product& product, int amount) {

std::cout << name << " supplies " << amount << " units of " << product.getName() << "\n";

product.adjustQuantity(amount);

}

private:

std::string name;

};

// Class to represent a warehouse

class Warehouse {

public:

Warehouse(const std::string& name) : name(name) {}

// Method to store products

void store(Product& product, int amount) {

std::cout << name << " stores " << amount << " units of " << product.getName() << "\n";

product.adjustQuantity(amount);

}

// Method to dispatch products to a retailer

void dispatch(Product& product, int amount) {

if (product.hasStock(amount)) {

std::cout << name << " dispatches " << amount << " units of " << product.getName() << "\n";

product.adjustQuantity(-amount);

} else {

std::cout << name << " does not have enough stock to dispatch " << amount << " units of " << product.getName() << "\n";

}

private:

std::string name;

};

// Class to represent a retailer

class Retailer {

public:

Retailer(const std::string& name) : name(name) {}

// Method to receive products from a warehouse

void receive(Product& product, int amount) {

std::cout << name << " receives " << amount << " units of " << product.getName() << "\n";

product.adjustQuantity(amount);

}

private:

std::string name;

};

int main() {

// Create products

Product widget("Widget", 0);

// Create entities in the supply chain

Supplier supplier("Supplier A");

Warehouse warehouse("Warehouse B");

Retailer retailer("Retailer C");

// Simulate the supply chain

supplier.supply(widget, 100);

warehouse.store(widget, 100);

warehouse.dispatch(widget, 50);

retailer.receive(widget, 50);

warehouse.dispatch(widget, 60); // This will fail due to insufficient stock

// Print final stock of the product

widget.getInfo();

return 0;

}

Explanation Product Class: Attributes: name: Name of the product. quantity: Quantity of the product. Methods: getInfo(): Prints the product’s name and quantity. adjustQuantity(int amount): Adjusts the quantity by the given amount. hasStock(int amount): Checks if there’s enough stock. Supplier Class: Attributes: name: Name of the supplier. Methods: supply(Product& product, int amount): Supplies products to …

Simulation of Supply Chain Management Gaming Project in C++ Read More »

Simulation of TCP/IP Protocol Gaming Project in C++

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

// server.cpp
#include <iostream>
#include <cstring>    // For memset
#include <sys/socket.h>
#include <netinet/in.h>
#include <unistd.h>

const int PORT = 8080;
const int BUFFER_SIZE = 1024;

int main() {
    // Create a socket
    int server_fd = socket(AF_INET, SOCK_STREAM, 0);
    if (server_fd == 0) {
        std::cerr << "Socket creation failed\n";
        return -1;
    }

    // Define the server address
    struct sockaddr_in address;
    int addrlen = sizeof(address);
    address.sin_family = AF_INET;
    address.sin_addr.s_addr = INADDR_ANY;
    address.sin_port = htons(PORT);

    // Bind the socket to the address
    if (bind(server_fd, (struct sockaddr*)&address, sizeof(address)) < 0) {
        std::cerr << "Bind failed\n";
        return -1;
    }

    // Listen for incoming connections
    if (listen(server_fd, 3) < 0) {
        std::cerr << "Listen failed\n";
        return -1;
    }

    // Accept a connection
    int new_socket = accept(server_fd, (struct sockaddr*)&address, (socklen_t*)&addrlen);
    if (new_socket < 0) {
        std::cerr << "Accept failed\n";
        return -1;
    }

    char buffer[BUFFER_SIZE] = {0};
    read(new_socket, buffer, BUFFER_SIZE);
    std::cout << "Received message: " << buffer << std::endl;

    // Close the socket
    close(new_socket);
    close(server_fd);

    return 0;
}

// server.cpp

#include <iostream>

#include <cstring> // For memset

#include <sys/socket.h>

#include <netinet/in.h>

#include <unistd.h>

const int PORT = 8080;

const int BUFFER_SIZE = 1024;

int main() {

// Create a socket

int server_fd = socket(AF_INET, SOCK_STREAM, 0);

if (server_fd == 0) {

std::cerr << "Socket creation failed\n";

return -1;

}

// Define the server address

struct sockaddr_in address;

int addrlen = sizeof(address);

address.sin_family = AF_INET;

address.sin_addr.s_addr = INADDR_ANY;

address.sin_port = htons(PORT);

// Bind the socket to the address

if (bind(server_fd, (struct sockaddr*)&address, sizeof(address)) < 0) {

std::cerr << "Bind failed\n";

return -1;

}

// Listen for incoming connections

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

std::cerr << "Listen failed\n";

return -1;

}

// Accept a connection

int new_socket = accept(server_fd, (struct sockaddr*)&address, (socklen_t*)&addrlen);

if (new_socket < 0) {

std::cerr << "Accept failed\n";

return -1;

}

char buffer[BUFFER_SIZE] = {0};

read(new_socket, buffer, BUFFER_SIZE);

std::cout << "Received message: " << buffer << std::endl;

// Close the socket

close(new_socket);

close(server_fd);

return 0;

}

Client cpp

// client.cpp
#include <iostream>
#include <cstring>    // For memset
#include <sys/socket.h>
#include <netinet/in.h>
#include <unistd.h>

const int PORT = 8080;
const int BUFFER_SIZE = 1024;

int main() {
    // Create a socket
    int sock = 0;
    struct sockaddr_in serv_addr;
    if ((sock = socket(AF_INET, SOCK_STREAM, 0)) < 0) {
        std::cerr << "Socket creation error\n";
        return -1;
    }

    // Define the server address
    serv_addr.sin_family = AF_INET;
    serv_addr.sin_port = htons(PORT);

    // Convert IPv4 address from text to binary form
    if (inet_pton(AF_INET, "127.0.0.1", &serv_addr.sin_addr) <= 0) {
        std::cerr << "Invalid address or address not supported\n";
        return -1;
    }

    // Connect to the server
    if (connect(sock, (struct sockaddr*)&serv_addr, sizeof(serv_addr)) < 0) {
        std::cerr << "Connection failed\n";
        return -1;
    }

    // Send a message
    const char* message = "Hello from client";
    send(sock, message, strlen(message), 0);
    std::cout << "Message sent\n";

    // Close the socket
    close(sock);

    return 0;
}

// client.cpp

#include <iostream>

#include <cstring> // For memset

#include <sys/socket.h>

#include <netinet/in.h>

#include <unistd.h>

const int PORT = 8080;

const int BUFFER_SIZE = 1024;

int main() {

// Create a socket

int sock = 0;

struct sockaddr_in serv_addr;

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

std::cerr << "Socket creation error\n";

return -1;

}

// Define the server address

serv_addr.sin_family = AF_INET;

serv_addr.sin_port = htons(PORT);

// Convert IPv4 address from text to binary form

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

std::cerr << "Invalid address or address not supported\n";

return -1;

}

// Connect to the server

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

std::cerr << "Connection failed\n";

return -1;

}

// Send a message

const char* message = "Hello from client";

send(sock, message, strlen(message), 0);

std::cout << "Message sent\n";

// Close the socket

close(sock);

return 0;

}

Explanation Server (server.cpp): Socket Creation: socket(AF_INET, SOCK_STREAM, 0): Creates a TCP socket. AF_INET: Address family for IPv4. SOCK_STREAM: Specifies a TCP socket. Bind Socket: bind(): Binds the socket to the specified address and port. Listen and Accept: listen(): Marks the socket as passive and ready to accept incoming connections. accept(): Waits …

Simulation of TCP/IP Protocol Gaming Project in C++ Read More »

Simulation of Time Management Gaming Project in C++

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

#include <iostream>
#include <vector>
#include <string>
#include <thread>
#include <chrono>

// Task class to represent a task with a name and duration
class Task {
public:
    Task(const std::string& name, int duration)
        : name(name), duration(duration), timeLeft(duration) {}

    // Update the task by one time unit
    void update() {
        if (timeLeft > 0) {
            --timeLeft;
        }
    }

    // Check if the task is complete
    bool isComplete() const {
        return timeLeft <= 0;
    }

    // Print the task status
    void printStatus() const {
        std::cout << "Task: " << name
                  << " | Time Left: " << timeLeft << "s"
                  << (isComplete() ? " (Complete)" : "") << std::endl;
    }

private:
    std::string name;
    int duration;
    int timeLeft;
};

// Function to simulate time management with tasks
void simulateTimeManagement(std::vector<Task>& tasks) {
    while (true) {
        bool allComplete = true;

        for (auto& task : tasks) {
            task.update();
            task.printStatus();
            if (!task.isComplete()) {
                allComplete = false;
            }
        }

        if (allComplete) {
            std::cout << "All tasks are complete!" << std::endl;
            break;
        }

        std::this_thread::sleep_for(std::chrono::seconds(1)); // Simulate time passing
        std::cout << std::endl;
    }
}

int main() {
    // Create tasks with name and duration
    std::vector<Task> tasks = {
        Task("Task 1", 5),
        Task("Task 2", 3),
        Task("Task 3", 7)
    };

    std::cout << "Time Management Simulation\n";
    simulateTimeManagement(tasks);

    return 0;
}

#include <iostream>

#include <vector>

#include <string>

#include <thread>

#include <chrono>

// Task class to represent a task with a name and duration

class Task {

public:

Task(const std::string& name, int duration)

: name(name), duration(duration), timeLeft(duration) {}

// Update the task by one time unit

void update() {

if (timeLeft > 0) {

--timeLeft;

}

// Check if the task is complete

bool isComplete() const {

return timeLeft <= 0;

}

// Print the task status

void printStatus() const {

std::cout << "Task: " << name

<< " | Time Left: " << timeLeft << "s"

<< (isComplete() ? " (Complete)" : "") << std::endl;

}

private:

std::string name;

int duration;

int timeLeft;

};

// Function to simulate time management with tasks

void simulateTimeManagement(std::vector<Task>& tasks) {

while (true) {

bool allComplete = true;

for (auto& task : tasks) {

task.update();

task.printStatus();

if (!task.isComplete()) {

allComplete = false;

}

if (allComplete) {

std::cout << "All tasks are complete!" << std::endl;

break;

}

std::this_thread::sleep_for(std::chrono::seconds(1)); // Simulate time passing

std::cout << std::endl;

}

int main() {

// Create tasks with name and duration

std::vector<Task> tasks = {

Task("Task 1", 5),

Task("Task 2", 3),

Task("Task 3", 7)

};

std::cout << "Time Management Simulation\n";

simulateTimeManagement(tasks);

return 0;

}

Explanation Task Class: Attributes: name: Name of the task. duration: Total duration of the task in seconds. timeLeft: Remaining time for the task. Methods: update(): Reduces the timeLeft by one unit if the task is not complete. isComplete(): Checks if the task is complete. printStatus(): Prints the current status of the task, including time …

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

Simulation of Traffic Flow Gaming Project in C++

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

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

// Constants
const int ROAD_LENGTH = 20; // Length of the road segment
const int INITIAL_CARS = 5; // Initial number of cars on the road
const int CAR_SPEED = 1;    // Speed at which cars move (in units per time step)
const int SIMULATION_STEPS = 50; // Number of simulation steps

// Function to initialize the road with cars
void initializeRoad(std::vector<int>& road) {
    for (int i = 0; i < INITIAL_CARS; ++i) {
        road[i] = 1; // Place cars on the road
    }
}

// Function to print the road state
void printRoad(const std::vector<int>& road) {
    for (int pos : road) {
        std::cout << (pos == 1 ? 'C' : '.'); // 'C' for car, '.' for empty space
    }
    std::cout << std::endl;
}

// Function to simulate traffic flow
void simulateTrafficFlow(std::vector<int>& road) {
    for (int step = 0; step < SIMULATION_STEPS; ++step) {
        std::vector<int> newRoad(ROAD_LENGTH, 0);

        // Move cars
        for (int i = 0; i < ROAD_LENGTH; ++i) {
            if (road[i] == 1) {
                int newPos = i + CAR_SPEED;
                if (newPos < ROAD_LENGTH) {
                    newRoad[newPos] = 1;
                }
            }
        }

        road = newRoad;
        printRoad(road);
        std::this_thread::sleep_for(std::chrono::milliseconds(500)); // Simulate time delay
    }
}

int main() {
    std::vector<int> road(ROAD_LENGTH, 0); // Initialize the road with empty spaces
    initializeRoad(road); // Place initial cars on the road

    std::cout << "Traffic Flow Simulation\n";
    simulateTrafficFlow(road);

    return 0;
}

#include <iostream>

#include <vector>

#include <cstdlib>

#include <ctime>

#include <thread>

#include <chrono>

// Constants

const int ROAD_LENGTH = 20; // Length of the road segment

const int INITIAL_CARS = 5; // Initial number of cars on the road

const int CAR_SPEED = 1; // Speed at which cars move (in units per time step)

const int SIMULATION_STEPS = 50; // Number of simulation steps

// Function to initialize the road with cars

void initializeRoad(std::vector<int>& road) {

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

road[i] = 1; // Place cars on the road

}

// Function to print the road state

void printRoad(const std::vector<int>& road) {

for (int pos : road) {

std::cout << (pos == 1 ? 'C' : '.'); // 'C' for car, '.' for empty space

}

std::cout << std::endl;

}

// Function to simulate traffic flow

void simulateTrafficFlow(std::vector<int>& road) {

for (int step = 0; step < SIMULATION_STEPS; ++step) {

std::vector<int> newRoad(ROAD_LENGTH, 0);

// Move cars

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

if (road[i] == 1) {

int newPos = i + CAR_SPEED;

if (newPos < ROAD_LENGTH) {

newRoad[newPos] = 1;

}

road = newRoad;

printRoad(road);

std::this_thread::sleep_for(std::chrono::milliseconds(500)); // Simulate time delay

}

int main() {

std::vector<int> road(ROAD_LENGTH, 0); // Initialize the road with empty spaces

initializeRoad(road); // Place initial cars on the road

std::cout << "Traffic Flow Simulation\n";

simulateTrafficFlow(road);

return 0;

}

Explanation Constants: ROAD_LENGTH: The length of the road segment. INITIAL_CARS: The number of cars placed on the road initially. CAR_SPEED: The speed at which cars move (in units per time step). SIMULATION_STEPS: Number of steps to simulate. initializeRoad Function: Initializes the road with cars. Places cars at the beginning of the road. printRoad Function: …

Simulation of Traffic Flow Gaming Project in C++ Read More »

Simulation of Traffic Signal Control Gaming Project in C++

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

#include <iostream>
#include <chrono>
#include <thread>

// Constants for traffic light durations
const int GREEN_DURATION = 10; // Duration of green light in seconds
const int YELLOW_DURATION = 3;  // Duration of yellow light in seconds
const int RED_DURATION = 7;     // Duration of red light in seconds

// Function to simulate traffic signal control
void simulateTrafficSignal() {
    while (true) {
        std::cout << "Green light\n";
        std::this_thread::sleep_for(std::chrono::seconds(GREEN_DURATION));

        std::cout << "Yellow light\n";
        std::this_thread::sleep_for(std::chrono::seconds(YELLOW_DURATION));

        std::cout << "Red light\n";
        std::this_thread::sleep_for(std::chrono::seconds(RED_DURATION));
    }
}

int main() {
    std::cout << "Traffic Signal Control Simulation\n";
    simulateTrafficSignal();
    return 0;
}

#include <iostream>

#include <chrono>

#include <thread>

// Constants for traffic light durations

const int GREEN_DURATION = 10; // Duration of green light in seconds

const int YELLOW_DURATION = 3; // Duration of yellow light in seconds

const int RED_DURATION = 7; // Duration of red light in seconds

// Function to simulate traffic signal control

void simulateTrafficSignal() {

while (true) {

std::cout << "Green light\n";

std::this_thread::sleep_for(std::chrono::seconds(GREEN_DURATION));

std::cout << "Yellow light\n";

std::this_thread::sleep_for(std::chrono::seconds(YELLOW_DURATION));

std::cout << "Red light\n";

std::this_thread::sleep_for(std::chrono::seconds(RED_DURATION));

}

int main() {

std::cout << "Traffic Signal Control Simulation\n";

simulateTrafficSignal();

return 0;

}

Explanation Constants: GREEN_DURATION: The duration of the green light phase in seconds. YELLOW_DURATION: The duration of the yellow light phase in seconds. RED_DURATION: The duration of the red light phase in seconds. simulateTrafficSignal Function: Continuously simulates the traffic signal cycles. Green Light: Prints “Green light” and waits for GREEN_DURATION seconds. Yellow Light: Prints “Yellow …

Simulation of Traffic Signal Control Gaming Project in C++ Read More »

Simulation of Virtual Memory Gaming Project in C++

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

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

// Constants
const int PAGE_SIZE = 4; // Number of pages in memory
const int NUM_PAGES = 10; // Total number of pages in the virtual memory

// Class to simulate a virtual memory system
class VirtualMemory {
public:
    VirtualMemory(int pageSize) : pageSize(pageSize) {}

    // Access a page
    void accessPage(int pageNumber) {
        if (pageTable.find(pageNumber) == pageTable.end()) {
            // Page fault: page not in memory
            if (memory.size() >= pageSize) {
                // Memory is full, need to evict a page
                int evictPage = pageQueue.front();
                pageQueue.pop();
                pageTable.erase(evictPage);
                std::cout << "Page " << evictPage << " evicted from memory.\n";
            }
            // Load the page into memory
            memory.push_back(pageNumber);
            pageTable[pageNumber] = memory.size() - 1;
            pageQueue.push(pageNumber);
            std::cout << "Page " << pageNumber << " loaded into memory.\n";
        } else {
            // Page hit: page is already in memory
            std::cout << "Page " << pageNumber << " is already in memory.\n";
        }
    }

    // Print current memory state
    void printMemory() const {
        std::cout << "Current memory state: ";
        for (int page : memory) {
            std::cout << page << " ";
        }
        std::cout << std::endl;
    }

private:
    int pageSize;
    std::vector<int> memory;
    std::unordered_map<int, int> pageTable; // Maps page number to its position in memory
    std::queue<int> pageQueue; // Keeps track of page replacement order
};

int main() {
    VirtualMemory vm(PAGE_SIZE);

    // Simulate accessing pages
    std::vector<int> pageRequests = {1, 2, 3, 4, 1, 5, 6, 2, 7, 8, 9, 10, 5, 3};

    for (int pageNumber : pageRequests) {
        vm.accessPage(pageNumber);
        vm.printMemory();
    }

    return 0;
}

#include <iostream>

#include <vector>

#include <queue>

#include <unordered_map>

// Constants

const int PAGE_SIZE = 4; // Number of pages in memory

const int NUM_PAGES = 10; // Total number of pages in the virtual memory

// Class to simulate a virtual memory system

class VirtualMemory {

public:

VirtualMemory(int pageSize) : pageSize(pageSize) {}

// Access a page

void accessPage(int pageNumber) {

if (pageTable.find(pageNumber) == pageTable.end()) {

// Page fault: page not in memory

if (memory.size() >= pageSize) {

// Memory is full, need to evict a page

int evictPage = pageQueue.front();

pageQueue.pop();

pageTable.erase(evictPage);

std::cout << "Page " << evictPage << " evicted from memory.\n";

}

// Load the page into memory

memory.push_back(pageNumber);

pageTable[pageNumber] = memory.size() - 1;

pageQueue.push(pageNumber);

std::cout << "Page " << pageNumber << " loaded into memory.\n";

} else {

// Page hit: page is already in memory

std::cout << "Page " << pageNumber << " is already in memory.\n";

}

// Print current memory state

void printMemory() const {

std::cout << "Current memory state: ";

for (int page : memory) {

std::cout << page << " ";

}

std::cout << std::endl;

}

private:

int pageSize;

std::vector<int> memory;

std::unordered_map<int, int> pageTable; // Maps page number to its position in memory

std::queue<int> pageQueue; // Keeps track of page replacement order

};

int main() {

VirtualMemory vm(PAGE_SIZE);

// Simulate accessing pages

std::vector<int> pageRequests = {1, 2, 3, 4, 1, 5, 6, 2, 7, 8, 9, 10, 5, 3};

for (int pageNumber : pageRequests) {

vm.accessPage(pageNumber);

vm.printMemory();

}

return 0;

}

Explanation Constants: PAGE_SIZE: The maximum number of pages that can be held in memory at a time. NUM_PAGES: Total number of unique pages in virtual memory. VirtualMemory Class: Attributes: pageSize: Maximum capacity of pages in memory. memory: Vector to store pages currently in memory. pageTable: Maps page numbers to their positions in memory for …

Simulation of Virtual Memory Gaming Project in C++ Read More »

Simulation of Virtual Reality (VR) Gaming Project in C++

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

#include <iostream>
#include <conio.h> // For _kbhit() and _getch()

// Constants for movement speed
const float MOVE_SPEED = 0.5f;

// Function to print the current position of the object
void printPosition(float x, float y, float z) {
    std::cout << "Object Position - X: " << x << ", Y: " << y << ", Z: " << z << std::endl;
}

// Function to handle user input and move the object
void handleInput(float& x, float& y, float& z) {
    if (_kbhit()) {
        char ch = _getch(); // Get the user input

        switch (ch) {
            case 'w': // Move forward
                z -= MOVE_SPEED;
                break;
            case 's': // Move backward
                z += MOVE_SPEED;
                break;
            case 'a': // Move left
                x -= MOVE_SPEED;
                break;
            case 'd': // Move right
                x += MOVE_SPEED;
                break;
            case 'q': // Move up
                y += MOVE_SPEED;
                break;
            case 'e': // Move down
                y -= MOVE_SPEED;
                break;
            case 'x': // Exit the simulation
                std::exit(0);
                break;
        }
    }
}

int main() {
    // Initial position of the virtual object
    float x = 0.0f;
    float y = 0.0f;
    float z = 0.0f;

    std::cout << "Virtual Reality Simulation\n";
    std::cout << "Controls:\n";
    std::cout << "W: Move Forward\n";
    std::cout << "S: Move Backward\n";
    std::cout << "A: Move Left\n";
    std::cout << "D: Move Right\n";
    std::cout << "Q: Move Up\n";
    std::cout << "E: Move Down\n";
    std::cout << "X: Exit Simulation\n";

    while (true) {
        printPosition(x, y, z);
        handleInput(x, y, z);
    }

    return 0;
}

#include <iostream>

#include <conio.h> // For _kbhit() and _getch()

// Constants for movement speed

const float MOVE_SPEED = 0.5f;

// Function to print the current position of the object

void printPosition(float x, float y, float z) {

std::cout << "Object Position - X: " << x << ", Y: " << y << ", Z: " << z << std::endl;

}

// Function to handle user input and move the object

void handleInput(float& x, float& y, float& z) {

if (_kbhit()) {

char ch = _getch(); // Get the user input

switch (ch) {

case 'w': // Move forward

z -= MOVE_SPEED;

break;

case 's': // Move backward

z += MOVE_SPEED;

break;

case 'a': // Move left

x -= MOVE_SPEED;

break;

case 'd': // Move right

x += MOVE_SPEED;

break;

case 'q': // Move up

y += MOVE_SPEED;

break;

case 'e': // Move down

y -= MOVE_SPEED;

break;

case 'x': // Exit the simulation

std::exit(0);

break;

}

int main() {

// Initial position of the virtual object

float x = 0.0f;

float y = 0.0f;

float z = 0.0f;

std::cout << "Virtual Reality Simulation\n";

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

std::cout << "W: Move Forward\n";

std::cout << "S: Move Backward\n";

std::cout << "A: Move Left\n";

std::cout << "D: Move Right\n";

std::cout << "Q: Move Up\n";

std::cout << "E: Move Down\n";

std::cout << "X: Exit Simulation\n";

while (true) {

printPosition(x, y, z);

handleInput(x, y, z);

}

return 0;

}

Explanation Constants: MOVE_SPEED: Defines how much the object moves per key press. printPosition Function: Outputs the current position of the virtual object in 3D space. handleInput Function: Handles user input to move the object. Uses _kbhit() and _getch() from <conio.h> to check for and get keyboard input. Moves the object based on the pressed …

Simulation of Virtual Reality (VR) Gaming Project in C++ Read More »

Simulation of Water Ripple Effect Gaming Project in C++

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

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

// Constants
const int GRID_SIZE = 20; // Size of the grid (GRID_SIZE x GRID_SIZE)
const double DAMPING_FACTOR = 0.98; // Damping factor for ripple effect
const double RIPPLE_STRENGTH = 10.0; // Initial strength of the ripple
const int RIPPLE_RADIUS = 5; // Radius of the ripple effect
const int NUM_STEPS = 30; // Number of simulation steps

// Function to initialize the grid
void initializeGrid(std::vector<std::vector<double>>& grid) {
    for (int i = 0; i < GRID_SIZE; ++i) {
        for (int j = 0; j < GRID_SIZE; ++j) {
            grid[i][j] = 0.0;
        }
    }
}

// Function to create a ripple effect
void createRipple(std::vector<std::vector<double>>& grid, int centerX, int centerY, double strength) {
    for (int i = 0; i < GRID_SIZE; ++i) {
        for (int j = 0; j < GRID_SIZE; ++j) {
            double distance = std::sqrt((i - centerX) * (i - centerX) + (j - centerY) * (j - centerY));
            if (distance < RIPPLE_RADIUS) {
                grid[i][j] += strength * (1.0 - distance / RIPPLE_RADIUS);
            }
        }
    }
}

// Function to update the grid
void updateGrid(std::vector<std::vector<double>>& grid) {
    std::vector<std::vector<double>> newGrid = grid;
    for (int i = 1; i < GRID_SIZE - 1; ++i) {
        for (int j = 1; j < GRID_SIZE - 1; ++j) {
            newGrid[i][j] = (grid[i - 1][j] + grid[i + 1][j] + grid[i][j - 1] + grid[i][j + 1]) / 4.0;
            newGrid[i][j] *= DAMPING_FACTOR;
        }
    }
    grid = newGrid;
}

// Function to print the grid
void printGrid(const std::vector<std::vector<double>>& grid) {
    for (const auto& row : grid) {
        for (double value : row) {
            std::cout << std::setw(6) << std::fixed << std::setprecision(2) << value << " ";
        }
        std::cout << "\n";
    }
    std::cout << "\n";
}

int main() {
    // Create a grid for the simulation
    std::vector<std::vector<double>> grid(GRID_SIZE, std::vector<double>(GRID_SIZE, 0.0));
    
    // Initialize the grid
    initializeGrid(grid);
    
    // Create an initial ripple effect
    createRipple(grid, GRID_SIZE / 2, GRID_SIZE / 2, RIPPLE_STRENGTH);

    std::cout << "Initial Ripple Effect:\n";
    printGrid(grid);

    // Simulate the ripple effect over time
    for (int step = 0; step < NUM_STEPS; ++step) {
        updateGrid(grid);
        std::cout << "Step " << step + 1 << ":\n";
        printGrid(grid);
    }

    return 0;
}

#include <iostream>

#include <vector>

#include <cmath>

#include <iomanip>

// Constants

const int GRID_SIZE = 20; // Size of the grid (GRID_SIZE x GRID_SIZE)

const double DAMPING_FACTOR = 0.98; // Damping factor for ripple effect

const double RIPPLE_STRENGTH = 10.0; // Initial strength of the ripple

const int RIPPLE_RADIUS = 5; // Radius of the ripple effect

const int NUM_STEPS = 30; // Number of simulation steps

// Function to initialize the grid

void initializeGrid(std::vector<std::vector<double>>& grid) {

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

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

grid[i][j] = 0.0;

}

// Function to create a ripple effect

void createRipple(std::vector<std::vector<double>>& grid, int centerX, int centerY, double strength) {

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

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

double distance = std::sqrt((i - centerX) * (i - centerX) + (j - centerY) * (j - centerY));

if (distance < RIPPLE_RADIUS) {

grid[i][j] += strength * (1.0 - distance / RIPPLE_RADIUS);

}

// Function to update the grid

void updateGrid(std::vector<std::vector<double>>& grid) {

std::vector<std::vector<double>> newGrid = grid;

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

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

newGrid[i][j] = (grid[i - 1][j] + grid[i + 1][j] + grid[i][j - 1] + grid[i][j + 1]) / 4.0;

newGrid[i][j] *= DAMPING_FACTOR;

}

grid = newGrid;

}

// Function to print the grid

void printGrid(const std::vector<std::vector<double>>& grid) {

for (const auto& row : grid) {

for (double value : row) {

std::cout << std::setw(6) << std::fixed << std::setprecision(2) << value << " ";

}

std::cout << "\n";

}

std::cout << "\n";

}

int main() {

// Create a grid for the simulation

std::vector<std::vector<double>> grid(GRID_SIZE, std::vector<double>(GRID_SIZE, 0.0));

// Initialize the grid

initializeGrid(grid);

// Create an initial ripple effect

createRipple(grid, GRID_SIZE / 2, GRID_SIZE / 2, RIPPLE_STRENGTH);

std::cout << "Initial Ripple Effect:\n";

printGrid(grid);

// Simulate the ripple effect over time

for (int step = 0; step < NUM_STEPS; ++step) {

updateGrid(grid);

std::cout << "Step " << step + 1 << ":\n";

printGrid(grid);

}

return 0;

}

Explanation Constants: GRID_SIZE: Size of the grid representing the water surface. DAMPING_FACTOR: Factor by which the ripple strength decreases each step. RIPPLE_STRENGTH: Initial strength of the ripple. RIPPLE_RADIUS: Radius of the ripple effect. NUM_STEPS: Number of simulation steps to run. initializeGrid Function: Initializes the grid with all zero values, representing a flat water surface. …

Simulation of Water Ripple Effect Gaming Project in C++ Read More »

Simulation of Weather Patterns Gaming Project in C++

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

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

// Constants
const double INITIAL_TEMPERATURE = 20.0; // Initial temperature in degrees Celsius
const double TEMPERATURE_VARIATION = 5.0; // Max variation in temperature per day
const double INITIAL_PRECIPITATION = 0.0; // Initial precipitation in mm
const double PRECIPITATION_CHANCE = 0.3; // Chance of precipitation per day
const double MAX_PRECIPITATION = 20.0; // Max precipitation amount per day
const int NUM_DAYS = 30; // Number of days to simulate

// Function to generate a random double between min and max
double randomDouble(double min, double max) {
    return min + static_cast<double>(rand()) / (static_cast<double>(RAND_MAX / (max - min)));
}

// Function to simulate weather patterns
void simulateWeather(double initialTemperature, double temperatureVariation, double initialPrecipitation, 
                     double precipitationChance, double maxPrecipitation, int numDays) {
    double temperature = initialTemperature;
    double precipitation = initialPrecipitation;

    std::cout << "Day    Temperature (°C)   Precipitation (mm)\n";
    for (int day = 1; day <= numDays; ++day) {
        // Random temperature variation
        double tempVariation = randomDouble(-temperatureVariation, temperatureVariation);
        temperature += tempVariation;
        
        // Random precipitation event
        double dailyPrecipitation = (randomDouble(0.0, 1.0) < precipitationChance) ?
            randomDouble(0.0, maxPrecipitation) : 0.0;
        precipitation = dailyPrecipitation;
        
        // Output the weather for the day
        std::cout << day << "       " << temperature << "                " << precipitation << "\n";
    }
}

int main() {
    // Seed the random number generator
    srand(static_cast<unsigned>(time(0)));

    // Simulate weather for a given number of days
    simulateWeather(INITIAL_TEMPERATURE, TEMPERATURE_VARIATION, INITIAL_PRECIPITATION, 
                    PRECIPITATION_CHANCE, MAX_PRECIPITATION, NUM_DAYS);

    return 0;
}

#include <iostream>

#include <cstdlib>

#include <ctime>

// Constants

const double INITIAL_TEMPERATURE = 20.0; // Initial temperature in degrees Celsius

const double TEMPERATURE_VARIATION = 5.0; // Max variation in temperature per day

const double INITIAL_PRECIPITATION = 0.0; // Initial precipitation in mm

const double PRECIPITATION_CHANCE = 0.3; // Chance of precipitation per day

const double MAX_PRECIPITATION = 20.0; // Max precipitation amount per day

const int NUM_DAYS = 30; // Number of days to simulate

// Function to generate a random double between min and max

double randomDouble(double min, double max) {

return min + static_cast<double>(rand()) / (static_cast<double>(RAND_MAX / (max - min)));

}

// Function to simulate weather patterns

void simulateWeather(double initialTemperature, double temperatureVariation, double initialPrecipitation,

double precipitationChance, double maxPrecipitation, int numDays) {

double temperature = initialTemperature;

double precipitation = initialPrecipitation;

std::cout << "Day Temperature (°C) Precipitation (mm)\n";

for (int day = 1; day <= numDays; ++day) {

// Random temperature variation

double tempVariation = randomDouble(-temperatureVariation, temperatureVariation);

temperature += tempVariation;

// Random precipitation event

double dailyPrecipitation = (randomDouble(0.0, 1.0) < precipitationChance) ?

randomDouble(0.0, maxPrecipitation) : 0.0;

precipitation = dailyPrecipitation;

// Output the weather for the day

std::cout << day << " " << temperature << " " << precipitation << "\n";

}

int main() {

// Seed the random number generator

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

// Simulate weather for a given number of days

simulateWeather(INITIAL_TEMPERATURE, TEMPERATURE_VARIATION, INITIAL_PRECIPITATION,

PRECIPITATION_CHANCE, MAX_PRECIPITATION, NUM_DAYS);

return 0;

}

Explanation Constants: INITIAL_TEMPERATURE: Starting temperature in degrees Celsius. TEMPERATURE_VARIATION: Maximum daily variation in temperature. INITIAL_PRECIPITATION: Starting precipitation amount in millimeters. PRECIPITATION_CHANCE: Probability of precipitation occurring on any given day. MAX_PRECIPITATION: Maximum amount of precipitation that can occur in a day. NUM_DAYS: Number of days to simulate. randomDouble Function: Generates a random double between min …

Simulation of Weather Patterns Gaming Project in C++ Read More »