C++ Projects – Page 6 – Projects Inventory

Simulation of Robot Motion Gaming Project in C++

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

#include <iostream>

// Class to represent a robot
class Robot {
public:
    Robot(int x = 0, int y = 0) : x(x), y(y) {}

    // Move the robot based on the given direction
    void move(char direction) {
        switch (direction) {
            case 'U': // Move up
                y++;
                break;
            case 'D': // Move down
                y--;
                break;
            case 'L': // Move left
                x--;
                break;
            case 'R': // Move right
                x++;
                break;
            default:
                std::cout << "Invalid direction! Use 'U', 'D', 'L', or 'R'.\n";
        }
    }

    // Print the current position of the robot
    void printPosition() const {
        std::cout << "Robot position: (" << x << ", " << y << ")\n";
    }

private:
    int x, y; // Coordinates of the robot
};

int main() {
    Robot robot; // Create a robot at the origin (0, 0)

    char command;
    std::cout << "Control the robot with 'U' (up), 'D' (down), 'L' (left), 'R' (right).\n";
    std::cout << "Enter 'Q' to quit.\n";

    while (true) {
        robot.printPosition();

        std::cout << "Enter command: ";
        std::cin >> command;

        if (command == 'Q' || command == 'q') {
            break;
        }

        robot.move(command);
    }

    std::cout << "Simulation ended.\n";
    robot.printPosition();

    return 0;
}

#include <iostream>

// Class to represent a robot

class Robot {

public:

Robot(int x = 0, int y = 0) : x(x), y(y) {}

// Move the robot based on the given direction

void move(char direction) {

switch (direction) {

case 'U': // Move up

y++;

break;

case 'D': // Move down

y--;

break;

case 'L': // Move left

x--;

break;

case 'R': // Move right

x++;

break;

default:

std::cout << "Invalid direction! Use 'U', 'D', 'L', or 'R'.\n";

}

// Print the current position of the robot

void printPosition() const {

std::cout << "Robot position: (" << x << ", " << y << ")\n";

}

private:

int x, y; // Coordinates of the robot

};

int main() {

Robot robot; // Create a robot at the origin (0, 0)

char command;

std::cout << "Control the robot with 'U' (up), 'D' (down), 'L' (left), 'R' (right).\n";

std::cout << "Enter 'Q' to quit.\n";

while (true) {

robot.printPosition();

std::cout << "Enter command: ";

std::cin >> command;

if (command == 'Q' || command == 'q') {

break;

}

robot.move(command);

}

std::cout << "Simulation ended.\n";

robot.printPosition();

return 0;

}

Explanation Robot Class: Attributes: x, y: Coordinates of the robot on a 2D grid. Methods: move(char direction): Updates the robot’s position based on the direction command. ‘U’: Moves the robot up by incrementing the y-coordinate. ‘D’: Moves the robot down by decrementing the y-coordinate. ‘L’: Moves the robot left by decrementing the x-coordinate. ‘R’: …

Simulation of Robot Motion Gaming Project in C++ Read More »

Simulation of Routing Algorithms Gaming Project in C++

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

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

const int INF = INT_MAX;

// Class to represent a graph
class Graph {
public:
    Graph(int vertices) : adj(vertices, std::vector<std::pair<int, int>>()) {}

    // Add an edge to the graph
    void addEdge(int u, int v, int w) {
        adj[u].emplace_back(v, w);
        adj[v].emplace_back(u, w); // For undirected graph
    }

    // Function to perform Dijkstra's algorithm from a source vertex
    std::vector<int> dijkstra(int src) {
        int V = adj.size();
        std::vector<int> dist(V, INF);
        std::vector<bool> visited(V, false);
        std::priority_queue<std::pair<int, int>, std::vector<std::pair<int, int>>, std::greater<>> pq;

        dist[src] = 0;
        pq.emplace(0, src);

        while (!pq.empty()) {
            int u = pq.top().second;
            pq.pop();

            if (visited[u]) continue;
            visited[u] = true;

            for (const auto& edge : adj[u]) {
                int v = edge.first;
                int weight = edge.second;

                if (!visited[v] && dist[u] + weight < dist[v]) {
                    dist[v] = dist[u] + weight;
                    pq.emplace(dist[v], v);
                }
            }
        }

        return dist;
    }

private:
    std::vector<std::vector<std::pair<int, int>>> adj;
};

int main() {
    int V = 5; // Number of vertices
    Graph g(V);

    // Adding edges (u, v, weight)
    g.addEdge(0, 1, 10);
    g.addEdge(0, 4, 3);
    g.addEdge(1, 2, 2);
    g.addEdge(1, 4, 4);
    g.addEdge(2, 3, 9);
    g.addEdge(3, 4, 7);

    int src = 0; // Starting vertex
    std::vector<int> distances = g.dijkstra(src);

    std::cout << "Vertex\tDistance from Source\n";
    for (int i = 0; i < distances.size(); ++i) {
        std::cout << i << "\t\t" << (distances[i] == INF ? "INF" : std::to_string(distances[i])) << "\n";
    }

    return 0;
}

#include <iostream>

#include <vector>

#include <climits>

#include <queue>

const int INF = INT_MAX;

// Class to represent a graph

class Graph {

public:

Graph(int vertices) : adj(vertices, std::vector<std::pair<int, int>>()) {}

// Add an edge to the graph

void addEdge(int u, int v, int w) {

adj[u].emplace_back(v, w);

adj[v].emplace_back(u, w); // For undirected graph

}

// Function to perform Dijkstra's algorithm from a source vertex

std::vector<int> dijkstra(int src) {

int V = adj.size();

std::vector<int> dist(V, INF);

std::vector<bool> visited(V, false);

std::priority_queue<std::pair<int, int>, std::vector<std::pair<int, int>>, std::greater<>> pq;

dist[src] = 0;

pq.emplace(0, src);

while (!pq.empty()) {

int u = pq.top().second;

pq.pop();

if (visited[u]) continue;

visited[u] = true;

for (const auto& edge : adj[u]) {

int v = edge.first;

int weight = edge.second;

if (!visited[v] && dist[u] + weight < dist[v]) {

dist[v] = dist[u] + weight;

pq.emplace(dist[v], v);

}

return dist;

}

private:

std::vector<std::vector<std::pair<int, int>>> adj;

};

int main() {

int V = 5; // Number of vertices

Graph g(V);

// Adding edges (u, v, weight)

g.addEdge(0, 1, 10);

g.addEdge(0, 4, 3);

g.addEdge(1, 2, 2);

g.addEdge(1, 4, 4);

g.addEdge(2, 3, 9);

g.addEdge(3, 4, 7);

int src = 0; // Starting vertex

std::vector<int> distances = g.dijkstra(src);

std::cout << "Vertex\tDistance from Source\n";

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

std::cout << i << "\t\t" << (distances[i] == INF ? "INF" : std::to_string(distances[i])) << "\n";

}

return 0;

}

Explanation Graph Class: Attributes: adj: Adjacency list representation of the graph. Each vertex has a list of pairs representing adjacent vertices and edge weights. Methods: addEdge(int u, int v, int w): Adds an undirected edge between vertices u and v with weight w. dijkstra(int src): Computes the shortest paths from source vertex src using …

Simulation of Routing Algorithms Gaming Project in C++ Read More »

Simulation of Satellite Orbit Gaming Project in C++

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

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

// Constants
const double PI = 3.141592653589793;
const double ORBIT_RADIUS = 1000.0; // Radius of the orbit in kilometers
const double ORBIT_PERIOD = 3600.0; // Orbit period in seconds (e.g., 1 hour)

// Function to calculate the satellite's position based on time
void calculatePosition(double time, double& x, double& y) {
    double angularVelocity = 2 * PI / ORBIT_PERIOD;
    double angle = angularVelocity * time;
    x = ORBIT_RADIUS * std::cos(angle);
    y = ORBIT_RADIUS * std::sin(angle);
}

int main() {
    // Simulation parameters
    double startTime = 0.0; // Start time in seconds
    double endTime = 7200.0; // End time in seconds (e.g., 2 hours)
    double timeStep = 600.0; // Time step in seconds (e.g., 10 minutes)

    std::cout << "Time (s)\tX Position (km)\tY Position (km)\n";
    std::cout << "----------------------------------------------\n";

    // Run the simulation
    for (double time = startTime; time <= endTime; time += timeStep) {
        double x, y;
        calculatePosition(time, x, y);
        std::cout << std::fixed << std::setprecision(2) << time << "\t\t"
                  << std::fixed << std::setprecision(2) << x << "\t\t"
                  << std::fixed << std::setprecision(2) << y << "\n";
    }

    return 0;
}

#include <iostream>

#include <cmath>

#include <iomanip>

// Constants

const double PI = 3.141592653589793;

const double ORBIT_RADIUS = 1000.0; // Radius of the orbit in kilometers

const double ORBIT_PERIOD = 3600.0; // Orbit period in seconds (e.g., 1 hour)

// Function to calculate the satellite's position based on time

void calculatePosition(double time, double& x, double& y) {

double angularVelocity = 2 * PI / ORBIT_PERIOD;

double angle = angularVelocity * time;

x = ORBIT_RADIUS * std::cos(angle);

y = ORBIT_RADIUS * std::sin(angle);

}

int main() {

// Simulation parameters

double startTime = 0.0; // Start time in seconds

double endTime = 7200.0; // End time in seconds (e.g., 2 hours)

double timeStep = 600.0; // Time step in seconds (e.g., 10 minutes)

std::cout << "Time (s)\tX Position (km)\tY Position (km)\n";

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

// Run the simulation

for (double time = startTime; time <= endTime; time += timeStep) {

double x, y;

calculatePosition(time, x, y);

std::cout << std::fixed << std::setprecision(2) << time << "\t\t"

<< std::fixed << std::setprecision(2) << x << "\t\t"

<< std::fixed << std::setprecision(2) << y << "\n";

}

return 0;

}

Explanation Constants: PI: Mathematical constant π. ORBIT_RADIUS: Radius of the satellite’s orbit around the planet in kilometers. ORBIT_PERIOD: Time taken for one complete orbit in seconds (e.g., 1 hour). Function calculatePosition(double time, double& x, double& y): Purpose: Calculates the satellite’s position in its orbit at a given time. Parameters: time: Current time in seconds. …

Simulation of Satellite Orbit Gaming Project in C++ Read More »

Simulation of Simple Harmonic Motion Gaming Project in C++

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

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

// Constants for the simulation
const double PI = 3.141592653589793;
const double AMPLITUDE = 1.0; // Maximum displacement from equilibrium
const double FREQUENCY = 1.0; // Frequency of oscillation in Hz
const double PHASE = 0.0;     // Phase shift in radians

// Function to calculate the position in Simple Harmonic Motion
double calculatePosition(double time) {
    return AMPLITUDE * std::sin(2 * PI * FREQUENCY * time + PHASE);
}

int main() {
    // Simulation parameters
    double startTime = 0.0; // Start time in seconds
    double endTime = 10.0;  // End time in seconds
    double timeStep = 0.1;  // Time step for the simulation

    std::cout << "Time (s)\tPosition\n";
    std::cout << "-----------------------\n";

    // Run the simulation
    for (double time = startTime; time <= endTime; time += timeStep) {
        double position = calculatePosition(time);
        std::cout << std::fixed << std::setprecision(2) << time << "\t\t" 
                  << std::fixed << std::setprecision(2) << position << "\n";
    }

    return 0;
}

#include <iostream>

#include <cmath>

#include <iomanip>

// Constants for the simulation

const double PI = 3.141592653589793;

const double AMPLITUDE = 1.0; // Maximum displacement from equilibrium

const double FREQUENCY = 1.0; // Frequency of oscillation in Hz

const double PHASE = 0.0; // Phase shift in radians

// Function to calculate the position in Simple Harmonic Motion

double calculatePosition(double time) {

return AMPLITUDE * std::sin(2 * PI * FREQUENCY * time + PHASE);

}

int main() {

// Simulation parameters

double startTime = 0.0; // Start time in seconds

double endTime = 10.0; // End time in seconds

double timeStep = 0.1; // Time step for the simulation

std::cout << "Time (s)\tPosition\n";

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

// Run the simulation

for (double time = startTime; time <= endTime; time += timeStep) {

double position = calculatePosition(time);

std::cout << std::fixed << std::setprecision(2) << time << "\t\t"

<< std::fixed << std::setprecision(2) << position << "\n";

}

return 0;

}

Explanation Constants: PI: Mathematical constant π. AMPLITUDE: Maximum displacement of the object from its equilibrium position. FREQUENCY: The frequency of oscillation in Hertz (Hz). PHASE: Phase shift in radians, affecting the initial position of the oscillation. Function calculatePosition(double time): Purpose: Calculates the position of the object at a given time based on Simple Harmonic …

Simulation of Simple Harmonic Motion Gaming Project in C++ Read More »

Simulation of Simple Traffic Light Gaming Project in C++

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

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

// Enum to represent traffic light states
enum class LightState {
    RED,
    YELLOW,
    GREEN
};

// Class to represent a traffic light
class TrafficLight {
public:
    TrafficLight() : currentState(LightState::RED) {}

    // Method to update the state of the traffic light
    void update() {
        switch (currentState) {
            case LightState::RED:
                currentState = LightState::GREEN;
                break;
            case LightState::YELLOW:
                currentState = LightState::RED;
                break;
            case LightState::GREEN:
                currentState = LightState::YELLOW;
                break;
        }
    }

    // Method to print the current state of the traffic light
    void printStatus() const {
        switch (currentState) {
            case LightState::RED:
                std::cout << "Red Light\n";
                break;
            case LightState::YELLOW:
                std::cout << "Yellow Light\n";
                break;
            case LightState::GREEN:
                std::cout << "Green Light\n";
                break;
        }
    }

private:
    LightState currentState;
};

int main() {
    TrafficLight trafficLight;

    // Simulation parameters
    const int redDuration = 5; // Duration for red light in seconds
    const int yellowDuration = 2; // Duration for yellow light in seconds
    const int greenDuration = 4; // Duration for green light in seconds

    while (true) {
        // Print the current status
        trafficLight.printStatus();

        // Wait for the duration corresponding to the current light
        switch (trafficLight.currentState) {
            case LightState::RED:
                std::this_thread::sleep_for(std::chrono::seconds(redDuration));
                break;
            case LightState::YELLOW:
                std::this_thread::sleep_for(std::chrono::seconds(yellowDuration));
                break;
            case LightState::GREEN:
                std::this_thread::sleep_for(std::chrono::seconds(greenDuration));
                break;
        }

        // Update the traffic light to the next state
        trafficLight.update();
    }

    return 0;
}

#include <iostream>

#include <chrono>

#include <thread>

// Enum to represent traffic light states

enum class LightState {

RED,

YELLOW,

GREEN

};

// Class to represent a traffic light

class TrafficLight {

public:

TrafficLight() : currentState(LightState::RED) {}

// Method to update the state of the traffic light

void update() {

switch (currentState) {

case LightState::RED:

currentState = LightState::GREEN;

break;

case LightState::YELLOW:

currentState = LightState::RED;

break;

case LightState::GREEN:

currentState = LightState::YELLOW;

break;

}

// Method to print the current state of the traffic light

void printStatus() const {

switch (currentState) {

case LightState::RED:

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

break;

case LightState::YELLOW:

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

break;

case LightState::GREEN:

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

break;

}

private:

LightState currentState;

};

int main() {

TrafficLight trafficLight;

// Simulation parameters

const int redDuration = 5; // Duration for red light in seconds

const int yellowDuration = 2; // Duration for yellow light in seconds

const int greenDuration = 4; // Duration for green light in seconds

while (true) {

// Print the current status

trafficLight.printStatus();

// Wait for the duration corresponding to the current light

switch (trafficLight.currentState) {

case LightState::RED:

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

break;

case LightState::YELLOW:

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

break;

case LightState::GREEN:

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

break;

}

// Update the traffic light to the next state

trafficLight.update();

}

return 0;

}

Explanation LightState Enum: Purpose: Represents the possible states of the traffic light. States: RED, YELLOW, GREEN. TrafficLight Class: Attributes: currentState: The current state of the traffic light. Methods: update(): Changes the traffic light to the next state in the sequence: RED -> GREEN -> YELLOW -> RED. printStatus(): Prints the current state of the …

Simulation of Simple Traffic Light Gaming Project in C++ Read More »

Simulation of Smart Home Automation Gaming Project in C++

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

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

// Class to represent a smart device
class SmartDevice {
public:
    virtual void status() const = 0;
    virtual void toggle() = 0;
    virtual ~SmartDevice() {}
};

// Class to represent a smart light
class SmartLight : public SmartDevice {
public:
    SmartLight(const std::string& name) : name(name), isOn(false) {}

    void status() const override {
        std::cout << name << " Light is " << (isOn ? "On" : "Off") << std::endl;
    }

    void toggle() override {
        isOn = !isOn;
    }

private:
    std::string name;
    bool isOn;
};

// Class to represent a smart thermostat
class SmartThermostat : public SmartDevice {
public:
    SmartThermostat(double initialTemp) : temperature(initialTemp) {}

    void status() const override {
        std::cout << "Thermostat Temperature is " << temperature << "°C" << std::endl;
    }

    void toggle() override {
        // Placeholder for toggle functionality, not applicable for thermostat
        std::cout << "Thermostat temperature adjustment not supported in this simulation.\n";
    }

    void setTemperature(double newTemp) {
        temperature = newTemp;
    }

private:
    double temperature;
};

// Class to represent a smart security system
class SmartSecurity : public SmartDevice {
public:
    SmartSecurity() : isArmed(false) {}

    void status() const override {
        std::cout << "Security System is " << (isArmed ? "Armed" : "Disarmed") << std::endl;
    }

    void toggle() override {
        isArmed = !isArmed;
    }

private:
    bool isArmed;
};

int main() {
    // Create smart devices
    SmartLight livingRoomLight("Living Room");
    SmartThermostat thermostat(22.0);
    SmartSecurity securitySystem;

    // List of devices
    std::vector<SmartDevice*> devices = { &livingRoomLight, &thermostat, &securitySystem };

    int choice;
    do {
        std::cout << "\nSmart Home Automation System\n";
        std::cout << "1. Toggle Light\n";
        std::cout << "2. Set Thermostat Temperature\n";
        std::cout << "3. Toggle Security System\n";
        std::cout << "4. Show Status\n";
        std::cout << "5. Exit\n";
        std::cout << "Enter your choice: ";
        std::cin >> choice;

        switch (choice) {
            case 1:
                livingRoomLight.toggle();
                break;
            case 2: {
                double newTemp;
                std::cout << "Enter new temperature: ";
                std::cin >> newTemp;
                thermostat.setTemperature(newTemp);
                break;
            }
            case 3:
                securitySystem.toggle();
                break;
            case 4:
                for (const auto& device : devices) {
                    device->status();
                }
                break;
            case 5:
                std::cout << "Exiting system.\n";
                break;
            default:
                std::cout << "Invalid choice. Please try again.\n";
        }
    } while (choice != 5);

    return 0;
}

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

#include <iostream>

#include <string>

#include <vector>

// Class to represent a smart device

class SmartDevice {

public:

virtual void status() const = 0;

virtual void toggle() = 0;

virtual ~SmartDevice() {}

};

// Class to represent a smart light

class SmartLight : public SmartDevice {

public:

SmartLight(const std::string& name) : name(name), isOn(false) {}

void status() const override {

std::cout << name << " Light is " << (isOn ? "On" : "Off") << std::endl;

}

void toggle() override {

isOn = !isOn;

}

private:

std::string name;

bool isOn;

};

// Class to represent a smart thermostat

class SmartThermostat : public SmartDevice {

public:

SmartThermostat(double initialTemp) : temperature(initialTemp) {}

void status() const override {

std::cout << "Thermostat Temperature is " << temperature << "°C" << std::endl;

}

void toggle() override {

// Placeholder for toggle functionality, not applicable for thermostat

std::cout << "Thermostat temperature adjustment not supported in this simulation.\n";

}

void setTemperature(double newTemp) {

temperature = newTemp;

}

private:

double temperature;

};

// Class to represent a smart security system

class SmartSecurity : public SmartDevice {

public:

SmartSecurity() : isArmed(false) {}

void status() const override {

std::cout << "Security System is " << (isArmed ? "Armed" : "Disarmed") << std::endl;

}

void toggle() override {

isArmed = !isArmed;

}

private:

bool isArmed;

};

int main() {

// Create smart devices

SmartLight livingRoomLight("Living Room");

SmartThermostat thermostat(22.0);

SmartSecurity securitySystem;

// List of devices

std::vector<SmartDevice*> devices = { &livingRoomLight, &thermostat, &securitySystem };

int choice;

do {

std::cout << "\nSmart Home Automation System\n";

std::cout << "1. Toggle Light\n";

std::cout << "2. Set Thermostat Temperature\n";

std::cout << "3. Toggle Security System\n";

std::cout << "4. Show Status\n";

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

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

std::cin >> choice;

switch (choice) {

case 1:

livingRoomLight.toggle();

break;

case 2: {

double newTemp;

std::cout << "Enter new temperature: ";

std::cin >> newTemp;

thermostat.setTemperature(newTemp);

break;

}

case 3:

securitySystem.toggle();

break;

case 4:

for (const auto& device : devices) {

device->status();

}

break;

case 5:

std::cout << "Exiting system.\n";

break;

default:

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

}

} while (choice != 5);

return 0;

}

Explanation SmartDevice Class: Attributes: Abstract base class for all smart devices. Methods: status(): Pure virtual function to display the status of the device. toggle(): Pure virtual function to toggle the device’s state. SmartLight Class: Attributes: name: Name of the light. isOn: State of the light (on/off). Methods: status(): Prints whether the light is on …

Simulation of Smart Home Automation Gaming Project in C++ Read More »

Simulation of Solar Panel Efficiency Gaming Project in C++

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

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

// Constants
const double MAX_SUNLIGHT_INTENSITY = 1000.0; // Max sunlight intensity in watts per square meter
const double PANEL_EFFICIENCY = 0.18; // Efficiency of the solar panel

// Class to represent a solar panel
class SolarPanel {
public:
    SolarPanel(double area, double angle)
        : area(area), angle(angle) {}

    // Method to update the angle of the solar panel
    void setAngle(double newAngle) {
        angle = newAngle;
    }

    // Method to calculate the energy output based on sunlight intensity and panel angle
    double calculateEnergyOutput(double sunlightIntensity) const {
        // Simplified model where energy output is affected by the cosine of the angle
        double effectiveIntensity = sunlightIntensity * cos(angle * M_PI / 180.0);
        effectiveIntensity = std::max(0.0, effectiveIntensity); // No negative intensity
        return effectiveIntensity * area * PANEL_EFFICIENCY;
    }

    // Method to print the current state of the solar panel
    void printInfo(double sunlightIntensity) const {
        double energyOutput = calculateEnergyOutput(sunlightIntensity);
        std::cout << "Panel Area: " << std::fixed << std::setprecision(2)
                  << area << " m²\n"
                  << "Panel Angle: " << angle << " degrees\n"
                  << "Sunlight Intensity: " << sunlightIntensity << " W/m²\n"
                  << "Energy Output: " << energyOutput << " watts\n";
    }

private:
    double area;  // Area of the solar panel in square meters
    double angle; // Angle of the solar panel in degrees
};

int main() {
    // Create a solar panel with a given area and initial angle
    SolarPanel panel(1.0, 30.0); // 1 square meter panel, 30 degrees angle

    // Simulation parameters
    double sunlightIntensity = MAX_SUNLIGHT_INTENSITY; // Initial sunlight intensity
    double angleStep = 10.0; // Step to change the angle
    int simulationSteps = 10; // Number of simulation steps

    // Run the simulation
    for (int step = 0; step < simulationSteps; ++step) {
        std::cout << "Step " << (step + 1) << ":\n";
        panel.printInfo(sunlightIntensity);

        // Update panel angle for the next step
        panel.setAngle(panel.getAngle() + angleStep);
        sunlightIntensity *= 0.9; // Simulate decreasing sunlight intensity over time
        std::cout << std::endl;
    }

    return 0;
}

#include <iostream>

#include <cmath>

#include <iomanip>

// Constants

const double MAX_SUNLIGHT_INTENSITY = 1000.0; // Max sunlight intensity in watts per square meter

const double PANEL_EFFICIENCY = 0.18; // Efficiency of the solar panel

// Class to represent a solar panel

class SolarPanel {

public:

SolarPanel(double area, double angle)

: area(area), angle(angle) {}

// Method to update the angle of the solar panel

void setAngle(double newAngle) {

angle = newAngle;

}

// Method to calculate the energy output based on sunlight intensity and panel angle

double calculateEnergyOutput(double sunlightIntensity) const {

// Simplified model where energy output is affected by the cosine of the angle

double effectiveIntensity = sunlightIntensity * cos(angle * M_PI / 180.0);

effectiveIntensity = std::max(0.0, effectiveIntensity); // No negative intensity

return effectiveIntensity * area * PANEL_EFFICIENCY;

}

// Method to print the current state of the solar panel

void printInfo(double sunlightIntensity) const {

double energyOutput = calculateEnergyOutput(sunlightIntensity);

std::cout << "Panel Area: " << std::fixed << std::setprecision(2)

<< area << " m²\n"

<< "Panel Angle: " << angle << " degrees\n"

<< "Sunlight Intensity: " << sunlightIntensity << " W/m²\n"

<< "Energy Output: " << energyOutput << " watts\n";

}

private:

double area; // Area of the solar panel in square meters

double angle; // Angle of the solar panel in degrees

};

int main() {

// Create a solar panel with a given area and initial angle

SolarPanel panel(1.0, 30.0); // 1 square meter panel, 30 degrees angle

// Simulation parameters

double sunlightIntensity = MAX_SUNLIGHT_INTENSITY; // Initial sunlight intensity

double angleStep = 10.0; // Step to change the angle

int simulationSteps = 10; // Number of simulation steps

// Run the simulation

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

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

panel.printInfo(sunlightIntensity);

// Update panel angle for the next step

panel.setAngle(panel.getAngle() + angleStep);

sunlightIntensity *= 0.9; // Simulate decreasing sunlight intensity over time

std::cout << std::endl;

}

return 0;

}

Explanation SolarPanel Class: Attributes: area: The area of the solar panel (in square meters). angle: The angle of the solar panel relative to the sunlight (in degrees). Methods: setAngle(double newAngle): Sets a new angle for the solar panel. calculateEnergyOutput(double sunlightIntensity): Calculates the energy output based on the sunlight intensity and the panel’s angle. The …

Simulation of Solar Panel Efficiency Gaming Project in C++ Read More »

Simulation of Solar System Gaming Project in C++

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

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

const double PI = 3.14159265358979323846;
const double DEG_TO_RAD = PI / 180.0;

// Class to represent a celestial body
class CelestialBody {
public:
    CelestialBody(const std::string& name, double distanceFromSun, double orbitalPeriod)
        : name(name), distanceFromSun(distanceFromSun), orbitalPeriod(orbitalPeriod), angle(0.0) {}

    // Method to update the position of the celestial body
    void updatePosition(double time) {
        double angularVelocity = 360.0 / orbitalPeriod; // degrees per unit time
        angle = fmod(angularVelocity * time, 360.0); // Update angle based on time
        x = distanceFromSun * cos(angle * DEG_TO_RAD);
        y = distanceFromSun * sin(angle * DEG_TO_RAD);
    }

    // Method to print the celestial body's information
    void printInfo() const {
        std::cout << name << " is at (" << std::fixed << std::setprecision(2)
                  << x << ", " << y << ") from the Sun.\n";
    }

private:
    std::string name;
    double distanceFromSun; // Distance from the Sun
    double orbitalPeriod;   // Orbital period in arbitrary time units
    double angle;           // Current angle in degrees
    double x, y;            // Cartesian coordinates
};

int main() {
    // Create celestial bodies
    std::vector<CelestialBody> celestialBodies = {
        CelestialBody("Mercury", 57.9, 88.0),
        CelestialBody("Venus", 108.2, 225.0),
        CelestialBody("Earth", 149.6, 365.0),
        CelestialBody("Mars", 227.9, 687.0)
    };

    // Simulation parameters
    double simulationTime = 0.0;
    double timeStep = 1.0; // Time step for the simulation

    // Run the simulation
    for (int step = 0; step < 10; ++step) {
        std::cout << "Time: " << simulationTime << "\n";
        for (auto& body : celestialBodies) {
            body.updatePosition(simulationTime);
            body.printInfo();
        }
        std::cout << std::endl;
        simulationTime += timeStep;
    }

    return 0;
}

#include <iostream>

#include <cmath>

#include <vector>

#include <iomanip>

const double PI = 3.14159265358979323846;

const double DEG_TO_RAD = PI / 180.0;

// Class to represent a celestial body

class CelestialBody {

public:

CelestialBody(const std::string& name, double distanceFromSun, double orbitalPeriod)

: name(name), distanceFromSun(distanceFromSun), orbitalPeriod(orbitalPeriod), angle(0.0) {}

// Method to update the position of the celestial body

void updatePosition(double time) {

double angularVelocity = 360.0 / orbitalPeriod; // degrees per unit time

angle = fmod(angularVelocity * time, 360.0); // Update angle based on time

x = distanceFromSun * cos(angle * DEG_TO_RAD);

y = distanceFromSun * sin(angle * DEG_TO_RAD);

}

// Method to print the celestial body's information

void printInfo() const {

std::cout << name << " is at (" << std::fixed << std::setprecision(2)

<< x << ", " << y << ") from the Sun.\n";

}

private:

std::string name;

double distanceFromSun; // Distance from the Sun

double orbitalPeriod; // Orbital period in arbitrary time units

double angle; // Current angle in degrees

double x, y; // Cartesian coordinates

};

int main() {

// Create celestial bodies

std::vector<CelestialBody> celestialBodies = {

CelestialBody("Mercury", 57.9, 88.0),

CelestialBody("Venus", 108.2, 225.0),

CelestialBody("Earth", 149.6, 365.0),

CelestialBody("Mars", 227.9, 687.0)

};

// Simulation parameters

double simulationTime = 0.0;

double timeStep = 1.0; // Time step for the simulation

// Run the simulation

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

std::cout << "Time: " << simulationTime << "\n";

for (auto& body : celestialBodies) {

body.updatePosition(simulationTime);

body.printInfo();

}

std::cout << std::endl;

simulationTime += timeStep;

}

return 0;

}

Explanation CelestialBody Class: Attributes: name: Name of the celestial body (e.g., planet). distanceFromSun: Average distance from the Sun (in arbitrary units). orbitalPeriod: Time taken to complete one orbit (in arbitrary time units). angle: Current angle of the body in its orbit. x, y: Cartesian coordinates of the body. Methods: updatePosition(double time): Updates the position …

Simulation of Solar System Gaming Project in C++ Read More »

Simulation of Space Exploration Gaming Project in C++

Leave a Comment / C++ Projects, Keywords Ideas for Youtube and Blogs / By Projects Inventory

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

// Class to represent a spacecraft
class Spacecraft {
public:
    Spacecraft(const std::string& name, double x, double y)
        : name(name), x(x), y(y), distanceTraveled(0.0) {}

    // Method to launch the spacecraft
    void launch() {
        std::cout << name << " has launched into space!\n";
    }

    // Method to travel to a new position
    void travel(double newX, double newY) {
        double distance = std::sqrt(std::pow(newX - x, 2) + std::pow(newY - y, 2));
        x = newX;
        y = newY;
        distanceTraveled += distance;
        std::cout << name << " traveled to (" << std::fixed << std::setprecision(2) 
                  << x << ", " << y << "). Distance traveled: " << distance << " units.\n";
    }

    // Method to land the spacecraft
    void land() {
        std::cout << name << " has landed at (" << std::fixed << std::setprecision(2)
                  << x << ", " << y << "). Total distance traveled: " << distanceTraveled << " units.\n";
    }

private:
    std::string name;
    double x, y; // Current position
    double distanceTraveled;
};

int main() {
    // Create a spacecraft
    Spacecraft spacecraft("Voyager", 0.0, 0.0);

    // Simulate the space exploration
    spacecraft.launch();
    spacecraft.travel(100.0, 150.0); // Travel to a new position
    spacecraft.travel(-50.0, 200.0); // Travel to another position
    spacecraft.land();

    return 0;
}

#include <iostream>

#include <cmath>

#include <iomanip>

// Class to represent a spacecraft

class Spacecraft {

public:

Spacecraft(const std::string& name, double x, double y)

: name(name), x(x), y(y), distanceTraveled(0.0) {}

// Method to launch the spacecraft

void launch() {

std::cout << name << " has launched into space!\n";

}

// Method to travel to a new position

void travel(double newX, double newY) {

double distance = std::sqrt(std::pow(newX - x, 2) + std::pow(newY - y, 2));

x = newX;

y = newY;

distanceTraveled += distance;

std::cout << name << " traveled to (" << std::fixed << std::setprecision(2)

<< x << ", " << y << "). Distance traveled: " << distance << " units.\n";

}

// Method to land the spacecraft

void land() {

std::cout << name << " has landed at (" << std::fixed << std::setprecision(2)

<< x << ", " << y << "). Total distance traveled: " << distanceTraveled << " units.\n";

}

private:

std::string name;

double x, y; // Current position

double distanceTraveled;

};

int main() {

// Create a spacecraft

Spacecraft spacecraft("Voyager", 0.0, 0.0);

// Simulate the space exploration

spacecraft.launch();

spacecraft.travel(100.0, 150.0); // Travel to a new position

spacecraft.travel(-50.0, 200.0); // Travel to another position

spacecraft.land();

return 0;

}

Explanation Spacecraft Class: Attributes: name: Name of the spacecraft. x, y: Current coordinates of the spacecraft. distanceTraveled: Total distance traveled by the spacecraft. Methods: launch(): Prints a message indicating that the spacecraft has launched. travel(double newX, double newY): Updates the spacecraft’s position to the new coordinates, calculates the distance traveled from the current position …

Simulation of Space Exploration Gaming Project in C++ Read More »

Simulation of Speech Processing Algorithms Gaming Project in C++

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

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

// Function to convert a string to lowercase
std::string toLowerCase(const std::string& str) {
    std::string lowerStr = str;
    std::transform(lowerStr.begin(), lowerStr.end(), lowerStr.begin(), ::tolower);
    return lowerStr;
}

// Function to simulate keyword detection in speech data
bool detectKeyword(const std::string& speech, const std::vector<std::string>& keywords) {
    std::string lowerSpeech = toLowerCase(speech);
    for (const auto& keyword : keywords) {
        if (lowerSpeech.find(toLowerCase(keyword)) != std::string::npos) {
            return true; // Keyword detected
        }
    }
    return false; // No keywords detected
}

// Function to simulate basic frequency analysis of words in speech data
void frequencyAnalysis(const std::string& speech) {
    std::string lowerSpeech = toLowerCase(speech);
    std::string word;
    std::map<std::string, int> wordCount;

    for (char c : lowerSpeech) {
        if (isalpha(c) || c == ' ') {
            word += c;
        } else if (c == ' ') {
            if (!word.empty()) {
                wordCount[word]++;
                word.clear();
            }
        }
    }
    if (!word.empty()) {
        wordCount[word]++;
    }

    std::cout << "Word Frequency Analysis:\n";
    for (const auto& [word, count] : wordCount) {
        std::cout << word << ": " << count << "\n";
    }
}

int main() {
    // Example speech data
    std::string speech = "Hello, welcome to the simulation of speech processing algorithms. This simulation processes speech data.";

    // Keywords to detect
    std::vector<std::string> keywords = {"simulation", "speech"};

    // Detect keywords in speech
    if (detectKeyword(speech, keywords)) {
        std::cout << "Keyword detected in speech!\n";
    } else {
        std::cout << "No keywords detected in speech.\n";
    }

    // Perform frequency analysis
    frequencyAnalysis(speech);

    return 0;
}

#include <iostream>

#include <string>

#include <vector>

#include <algorithm>

#include <cctype>

// Function to convert a string to lowercase

std::string toLowerCase(const std::string& str) {

std::string lowerStr = str;

std::transform(lowerStr.begin(), lowerStr.end(), lowerStr.begin(), ::tolower);

return lowerStr;

}

// Function to simulate keyword detection in speech data

bool detectKeyword(const std::string& speech, const std::vector<std::string>& keywords) {

std::string lowerSpeech = toLowerCase(speech);

for (const auto& keyword : keywords) {

if (lowerSpeech.find(toLowerCase(keyword)) != std::string::npos) {

return true; // Keyword detected

}

return false; // No keywords detected

}

// Function to simulate basic frequency analysis of words in speech data

void frequencyAnalysis(const std::string& speech) {

std::string lowerSpeech = toLowerCase(speech);

std::string word;

std::map<std::string, int> wordCount;

for (char c : lowerSpeech) {

if (isalpha(c) || c == ' ') {

word += c;

} else if (c == ' ') {

if (!word.empty()) {

wordCount[word]++;

word.clear();

}

if (!word.empty()) {

wordCount[word]++;

}

std::cout << "Word Frequency Analysis:\n";

for (const auto& [word, count] : wordCount) {

std::cout << word << ": " << count << "\n";

}

int main() {

// Example speech data

std::string speech = "Hello, welcome to the simulation of speech processing algorithms. This simulation processes speech data.";

// Keywords to detect

std::vector<std::string> keywords = {"simulation", "speech"};

// Detect keywords in speech

if (detectKeyword(speech, keywords)) {

std::cout << "Keyword detected in speech!\n";

} else {

std::cout << "No keywords detected in speech.\n";

}

// Perform frequency analysis

frequencyAnalysis(speech);

return 0;

}

Explanation Helper Functions: toLowerCase Function: Converts a given string to lowercase to facilitate case-insensitive comparisons. detectKeyword Function: Checks if any of the specified keywords are present in the speech data. Converts both the speech and keywords to lowercase for a case-insensitive search. frequencyAnalysis Function: Analyzes the frequency of each word in the speech data. …

Simulation of Speech Processing Algorithms Gaming Project in C++ Read More »