Projects Inventory – Page 95 – Projects Inventory Management Systems and Source Codes PHP, C#, C, Android and many others

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 »

Functional requirements of Smart Attendance Tracking System with non-functional

Leave a Comment / Functional Non Functional Requirements of Projects / By Projects Inventory

Functional Requirements for a Smart Attendance Tracking System User Registration and Management: User Profiles: Allow users (students, employees) to create and manage their profiles. Role-Based Access: Implement role-based access control for different types of users (e.g., administrators, teachers, employees). Attendance Tracking: Check-In/Check-Out: Provide mechanisms for users to check in and out of a location, either …

Functional requirements of Smart Attendance Tracking System with non-functional Read More »

Functional requirements of Smart Agriculture System with non-functional

Leave a Comment / Functional Non Functional Requirements of Projects / By Projects Inventory

Functional Requirements for a Smart Agriculture System Crop Monitoring: Sensor Integration: Integrate with sensors for monitoring soil moisture, temperature, humidity, and crop health. Real-Time Data Collection: Collect and display real-time data on crop and soil conditions. Irrigation Management: Automated Irrigation: Control irrigation systems based on sensor data and predefined schedules. Water Usage Optimization: Optimize water …

Functional requirements of Smart Agriculture System with non-functional 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 »

Functional requirements of Security Management System with non-functional

Leave a Comment / Functional Non Functional Requirements of Projects / By Projects Inventory

Functional Requirements for a Security Management System User Authentication and Authorization: User Registration: Allow users to create accounts with secure credentials. Login and Authentication: Implement secure login mechanisms, including multi-factor authentication (MFA). Role-Based Access Control: Define and manage user roles and permissions for accessing different system features. Surveillance and Monitoring: Camera Integration: Integrate with security …

Functional requirements of Security Management System with non-functional Read More »

Simulation of Sentiment Analysis Gaming Project in C++

Leave a Comment / Uncategorized / By Projects Inventory

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

// 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 analyze sentiment based on keywords
std::string analyzeSentiment(const std::string& text) {
    // Define positive and negative keywords
    std::vector<std::string> positiveKeywords = {"happy", "joy", "love", "excellent", "good", "great"};
    std::vector<std::string> negativeKeywords = {"sad", "hate", "terrible", "poor", "bad", "horrible"};
    
    int positiveScore = 0;
    int negativeScore = 0;

    // Convert text to lowercase for case-insensitive comparison
    std::string lowerText = toLowerCase(text);

    // Count occurrences of positive and negative keywords
    for (const auto& word : positiveKeywords) {
        if (lowerText.find(word) != std::string::npos) {
            positiveScore++;
        }
    }
    for (const auto& word : negativeKeywords) {
        if (lowerText.find(word) != std::string::npos) {
            negativeScore++;
        }
    }

    // Determine sentiment based on scores
    if (positiveScore > negativeScore) {
        return "Positive";
    } else if (negativeScore > positiveScore) {
        return "Negative";
    } else {
        return "Neutral";
    }
}

int main() {
    std::string inputText;

    // Get user input
    std::cout << "Enter a sentence for sentiment analysis: ";
    std::getline(std::cin, inputText);

    // Analyze sentiment
    std::string sentiment = analyzeSentiment(inputText);

    // Display result
    std::cout << "Sentiment Analysis Result: " << sentiment << std::endl;

    return 0;
}

#include <iostream>

#include <string>

#include <vector>

#include <algorithm>

// 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 analyze sentiment based on keywords

std::string analyzeSentiment(const std::string& text) {

// Define positive and negative keywords

std::vector<std::string> positiveKeywords = {"happy", "joy", "love", "excellent", "good", "great"};

std::vector<std::string> negativeKeywords = {"sad", "hate", "terrible", "poor", "bad", "horrible"};

int positiveScore = 0;

int negativeScore = 0;

// Convert text to lowercase for case-insensitive comparison

std::string lowerText = toLowerCase(text);

// Count occurrences of positive and negative keywords

for (const auto& word : positiveKeywords) {

if (lowerText.find(word) != std::string::npos) {

positiveScore++;

}

for (const auto& word : negativeKeywords) {

if (lowerText.find(word) != std::string::npos) {

negativeScore++;

}

// Determine sentiment based on scores

if (positiveScore > negativeScore) {

return "Positive";

} else if (negativeScore > positiveScore) {

return "Negative";

} else {

return "Neutral";

}

int main() {

std::string inputText;

// Get user input

std::cout << "Enter a sentence for sentiment analysis: ";

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

// Analyze sentiment

std::string sentiment = analyzeSentiment(inputText);

// Display result

std::cout << "Sentiment Analysis Result: " << sentiment << std::endl;

return 0;

}

Explanation Function toLowerCase(const std::string& str): Purpose: Converts a string to lowercase to ensure case-insensitive comparison. Implementation: Uses the std::transform function to convert all characters in the string to lowercase. Function analyzeSentiment(const std::string& text): Purpose: Analyzes the sentiment of the input text based on predefined keywords. Keywords: Positive Keywords: Words associated with positive sentiment. Negative …

Simulation of Sentiment Analysis 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 »

Functional requirements of Secure File Sharing System with non-functional

Leave a Comment / Functional Non Functional Requirements of Projects / By Projects Inventory

Functional Requirements for a Secure File Sharing System User Authentication and Authorization: User Registration: Allow users to create accounts with secure credentials. Login and Authentication: Implement secure login mechanisms (e.g., username/password, two-factor authentication). Role-Based Access Control: Define and enforce permissions based on user roles (e.g., administrators, users). File Upload and Download: File Upload: Enable users …

Functional requirements of Secure File Sharing System with non-functional 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 »