C++ Projects – Page 9 – Projects Inventory

Simulation of Doppler Effect Gaming Project in C++

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

#include <iostream>
#include <cmath>

class DopplerEffect {
public:
    DopplerEffect(double sourceFrequency, double speedOfSound)
        : sourceFrequency(sourceFrequency), speedOfSound(speedOfSound) {}

    // Calculates the observed frequency when the source and observer are moving
    double calculateObservedFrequency(double observerSpeed, double sourceSpeed) const {
        // Doppler effect formula:
        // f' = f * (v + vo) / (v + vs)
        // Where:
        // f' is the observed frequency
        // f is the source frequency
        // v is the speed of sound
        // vo is the speed of the observer (positive if moving towards the source)
        // vs is the speed of the source (positive if moving away from the observer)

        double observedFrequency = sourceFrequency * (speedOfSound + observerSpeed) / (speedOfSound + sourceSpeed);
        return observedFrequency;
    }

private:
    double sourceFrequency; // Frequency of the source in Hz
    double speedOfSound;    // Speed of sound in the medium (e.g., air) in m/s
};

int main() {
    double sourceFrequency = 440.0; // Frequency of the source (e.g., a sound wave) in Hz
    double speedOfSound = 343.0;    // Speed of sound in air at 20°C in m/s

    DopplerEffect doppler(sourceFrequency, speedOfSound);

    // User input for observer's and source's speeds
    double observerSpeed, sourceSpeed;
    std::cout << "Enter the speed of the observer (m/s, positive if moving towards the source): ";
    std::cin >> observerSpeed;
    std::cout << "Enter the speed of the source (m/s, positive if moving away from the observer): ";
    std::cin >> sourceSpeed;

    double observedFrequency = doppler.calculateObservedFrequency(observerSpeed, sourceSpeed);
    std::cout << "Observed Frequency: " << observedFrequency << " Hz" << std::endl;

    return 0;
}

#include <iostream>

#include <cmath>

class DopplerEffect {

public:

DopplerEffect(double sourceFrequency, double speedOfSound)

: sourceFrequency(sourceFrequency), speedOfSound(speedOfSound) {}

// Calculates the observed frequency when the source and observer are moving

double calculateObservedFrequency(double observerSpeed, double sourceSpeed) const {

// Doppler effect formula:

// f' = f * (v + vo) / (v + vs)

// Where:

// f' is the observed frequency

// f is the source frequency

// v is the speed of sound

// vo is the speed of the observer (positive if moving towards the source)

// vs is the speed of the source (positive if moving away from the observer)

double observedFrequency = sourceFrequency * (speedOfSound + observerSpeed) / (speedOfSound + sourceSpeed);

return observedFrequency;

}

private:

double sourceFrequency; // Frequency of the source in Hz

double speedOfSound; // Speed of sound in the medium (e.g., air) in m/s

};

int main() {

double sourceFrequency = 440.0; // Frequency of the source (e.g., a sound wave) in Hz

double speedOfSound = 343.0; // Speed of sound in air at 20°C in m/s

DopplerEffect doppler(sourceFrequency, speedOfSound);

// User input for observer's and source's speeds

double observerSpeed, sourceSpeed;

std::cout << "Enter the speed of the observer (m/s, positive if moving towards the source): ";

std::cin >> observerSpeed;

std::cout << "Enter the speed of the source (m/s, positive if moving away from the observer): ";

std::cin >> sourceSpeed;

double observedFrequency = doppler.calculateObservedFrequency(observerSpeed, sourceSpeed);

std::cout << "Observed Frequency: " << observedFrequency << " Hz" << std::endl;

return 0;

}

Explanation Header Files: <iostream>: For input and output operations. <cmath>: Included for completeness, though not used in this specific example. DopplerEffect Class: Constructor: Initializes the sourceFrequency and speedOfSound. The source frequency is the frequency of the wave emitted by the source, and the speed of sound is the propagation speed of the wave through …

Simulation of Doppler Effect Gaming Project in C++ Read More »

Simulation of Data Warehousing Gaming Project in C++

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

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

class DataWarehouse {
public:
    // Adds data to the warehouse
    void addData(const std::string& key, const std::string& value) {
        data[key] = value;
    }

    // Retrieves data from the warehouse
    std::string getData(const std::string& key) const {
        auto it = data.find(key);
        if (it != data.end()) {
            return it->second;
        } else {
            return "Data not found";
        }
    }

    // Displays all data in the warehouse
    void displayAllData() const {
        for (const auto& entry : data) {
            std::cout << "Key: " << entry.first << ", Value: " << entry.second << std::endl;
        }
    }

private:
    std::unordered_map<std::string, std::string> data;
};

int main() {
    DataWarehouse warehouse;

    // Add some data to the warehouse
    warehouse.addData("User1", "Alice");
    warehouse.addData("User2", "Bob");
    warehouse.addData("User3", "Charlie");

    // Retrieve and display specific data
    std::cout << "Retrieving User2: " << warehouse.getData("User2") << std::endl;

    // Display all data
    std::cout << "Displaying all data:" << std::endl;
    warehouse.displayAllData();

    return 0;
}

#include <iostream>

#include <vector>

#include <unordered_map>

#include <string>

class DataWarehouse {

public:

// Adds data to the warehouse

void addData(const std::string& key, const std::string& value) {

data[key] = value;

}

// Retrieves data from the warehouse

std::string getData(const std::string& key) const {

auto it = data.find(key);

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

return it->second;

} else {

return "Data not found";

}

// Displays all data in the warehouse

void displayAllData() const {

for (const auto& entry : data) {

std::cout << "Key: " << entry.first << ", Value: " << entry.second << std::endl;

}

private:

std::unordered_map<std::string, std::string> data;

};

int main() {

DataWarehouse warehouse;

// Add some data to the warehouse

warehouse.addData("User1", "Alice");

warehouse.addData("User2", "Bob");

warehouse.addData("User3", "Charlie");

// Retrieve and display specific data

std::cout << "Retrieving User2: " << warehouse.getData("User2") << std::endl;

// Display all data

std::cout << "Displaying all data:" << std::endl;

warehouse.displayAllData();

return 0;

}

Explanation Header Files: <iostream>: For input and output operations. <vector>: Although not used in this example, it’s included for potential extensions. <unordered_map>: To store key-value pairs efficiently. <string>: For handling string operations. DataWarehouse Class: addData(): Adds a key-value pair to the data warehouse. The key is a unique identifier, and the value is the …

Simulation of Data Warehousing Gaming Project in C++ Read More »

Simulation of Data Mining Techniques Gaming Project in C++

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

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

struct Point {
    double x, y;
    int clusterId; // Cluster assignment

    Point(double x = 0, double y = 0) : x(x), y(y), clusterId(-1) {}
};

class KMeans {
public:
    KMeans(int k, int maxIterations) : k(k), maxIterations(maxIterations) {
        std::srand(std::time(0));
    }

    void fit(std::vector<Point>& points) {
        // Initialize centroids randomly
        initializeCentroids(points);

        for (int iteration = 0; iteration < maxIterations; ++iteration) {
            bool changed = false;

            // Assign points to the nearest centroid
            for (auto& point : points) {
                int newClusterId = findClosestCentroid(point);
                if (point.clusterId != newClusterId) {
                    point.clusterId = newClusterId;
                    changed = true;
                }
            }

            // Recalculate centroids
            recalculateCentroids(points);

            if (!changed) break; // Stop if no change in cluster assignments
        }
    }

    void printResults(const std::vector<Point>& points) const {
        for (int i = 0; i < k; ++i) {
            std::cout << "Cluster " << i + 1 << " (Centroid: "
                      << centroids[i].x << ", " << centroids[i].y << "):\n";
            for (const auto& point : points) {
                if (point.clusterId == i) {
                    std::cout << "  (" << point.x << ", " << point.y << ")\n";
                }
            }
        }
    }

private:
    int k;
    int maxIterations;
    std::vector<Point> centroids;

    void initializeCentroids(const std::vector<Point>& points) {
        centroids.clear();
        std::vector<int> indices(points.size());
        for (int i = 0; i < points.size(); ++i) indices[i] = i;
        std::random_shuffle(indices.begin(), indices.end());
        for (int i = 0; i < k; ++i) {
            centroids.push_back(points[indices[i]]);
        }
    }

    int findClosestCentroid(const Point& point) const {
        int closestId = 0;
        double minDistance = std::numeric_limits<double>::max();
        for (int i = 0; i < k; ++i) {
            double distance = euclideanDistance(point, centroids[i]);
            if (distance < minDistance) {
                minDistance = distance;
                closestId = i;
            }
        }
        return closestId;
    }

    void recalculateCentroids(const std::vector<Point>& points) {
        std::vector<Point> newCentroids(k, Point());
        std::vector<int> counts(k, 0);

        for (const auto& point : points) {
            int id = point.clusterId;
            newCentroids[id].x += point.x;
            newCentroids[id].y += point.y;
            counts[id]++;
        }

        for (int i = 0; i < k; ++i) {
            if (counts[i] > 0) {
                newCentroids[i].x /= counts[i];
                newCentroids[i].y /= counts[i];
            }
            centroids[i] = newCentroids[i];
        }
    }

    double euclideanDistance(const Point& a, const Point& b) const {
        return std::sqrt((a.x - b.x) * (a.x - b.x) + (a.y - b.y) * (a.y - b.y));
    }
};

int main() {
    std::vector<Point> points = {
        {1.0, 2.0}, {1.5, 1.8}, {5.0, 8.0}, {8.0, 8.0},
        {1.0, 0.6}, {9.0, 11.0}, {8.0, 2.0}, {10.0, 2.0},
        {9.0, 3.0}
    };

    int k = 3; // Number of clusters
    int maxIterations = 100;

    KMeans kmeans(k, maxIterations);
    kmeans.fit(points);
    kmeans.printResults(points);

    return 0;
}

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

#include <iostream>

#include <vector>

#include <cmath>

#include <limits>

#include <cstdlib>

#include <ctime>

struct Point {

double x, y;

int clusterId; // Cluster assignment

Point(double x = 0, double y = 0) : x(x), y(y), clusterId(-1) {}

};

class KMeans {

public:

KMeans(int k, int maxIterations) : k(k), maxIterations(maxIterations) {

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

}

void fit(std::vector<Point>& points) {

// Initialize centroids randomly

initializeCentroids(points);

for (int iteration = 0; iteration < maxIterations; ++iteration) {

bool changed = false;

// Assign points to the nearest centroid

for (auto& point : points) {

int newClusterId = findClosestCentroid(point);

if (point.clusterId != newClusterId) {

point.clusterId = newClusterId;

changed = true;

}

// Recalculate centroids

recalculateCentroids(points);

if (!changed) break; // Stop if no change in cluster assignments

}

void printResults(const std::vector<Point>& points) const {

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

std::cout << "Cluster " << i + 1 << " (Centroid: "

<< centroids[i].x << ", " << centroids[i].y << "):\n";

for (const auto& point : points) {

if (point.clusterId == i) {

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

}

private:

int k;

int maxIterations;

std::vector<Point> centroids;

void initializeCentroids(const std::vector<Point>& points) {

centroids.clear();

std::vector<int> indices(points.size());

for (int i = 0; i < points.size(); ++i) indices[i] = i;

std::random_shuffle(indices.begin(), indices.end());

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

centroids.push_back(points[indices[i]]);

}

int findClosestCentroid(const Point& point) const {

int closestId = 0;

double minDistance = std::numeric_limits<double>::max();

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

double distance = euclideanDistance(point, centroids[i]);

if (distance < minDistance) {

minDistance = distance;

closestId = i;

}

return closestId;

}

void recalculateCentroids(const std::vector<Point>& points) {

std::vector<Point> newCentroids(k, Point());

std::vector<int> counts(k, 0);

for (const auto& point : points) {

int id = point.clusterId;

newCentroids[id].x += point.x;

newCentroids[id].y += point.y;

counts[id]++;

}

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

if (counts[i] > 0) {

newCentroids[i].x /= counts[i];

newCentroids[i].y /= counts[i];

}

centroids[i] = newCentroids[i];

}

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

return std::sqrt((a.x - b.x) * (a.x - b.x) + (a.y - b.y) * (a.y - b.y));

}

};

int main() {

std::vector<Point> points = {

{1.0, 2.0}, {1.5, 1.8}, {5.0, 8.0}, {8.0, 8.0},

{1.0, 0.6}, {9.0, 11.0}, {8.0, 2.0}, {10.0, 2.0},

{9.0, 3.0}

};

int k = 3; // Number of clusters

int maxIterations = 100;

KMeans kmeans(k, maxIterations);

kmeans.fit(points);

kmeans.printResults(points);

return 0;

}

Explanation Header Files: <iostream>: For input and output operations. <vector>: For storing and manipulating collections of Point objects. <cmath>: For mathematical functions like std::sqrt(). <limits>: To use std::numeric_limits for initializing the minimum distance. <cstdlib>: For random number generation. <ctime>: For seeding the random number generator. Point Struct: Represents a data point with x and …

Simulation of Data Mining Techniques Gaming Project in C++ Read More »

Simulation of Data Link Layer Protocols Gaming Project in C++

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

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

class Frame {
public:
    Frame(const std::string& data) : data(data) {
        checksum = calculateChecksum(data);
    }

    std::string getData() const { return data; }
    int getChecksum() const { return checksum; }

    bool isCorrupted() const {
        return calculateChecksum(data) != checksum;
    }

private:
    std::string data;
    int checksum;

    int calculateChecksum(const std::string& data) const {
        int sum = 0;
        for (char c : data) {
            sum += static_cast<int>(c);
        }
        return sum % 256; // Simple checksum (mod 256)
    }
};

class DataLinkLayer {
public:
    void sendFrame(const Frame& frame) {
        std::cout << "Sending frame with data: " << frame.getData() << std::endl;
        receivedFrame = frame;
    }

    void receiveFrame() {
        if (receivedFrame.isCorrupted()) {
            std::cout << "Error: Frame is corrupted." << std::endl;
        } else {
            std::cout << "Frame received successfully with data: " << receivedFrame.getData() << std::endl;
        }
    }

private:
    Frame receivedFrame{"default"};
};

int main() {
    std::srand(std::time(0));

    DataLinkLayer linkLayer;

    // Simulate sending a frame
    std::string data = "Hello, Data Link Layer!";
    Frame frame(data);
    linkLayer.sendFrame(frame);

    // Simulate potential corruption
    if (std::rand() % 2) {
        // Simulate corruption by altering data
        std::string corruptedData = data;
        corruptedData[0] = (corruptedData[0] == 'H') ? 'X' : 'H'; // Simple corruption example
        Frame corruptedFrame(corruptedData);
        linkLayer.sendFrame(corruptedFrame);
    }

    // Receive and check the frame
    linkLayer.receiveFrame();

    return 0;
}

#include <iostream>

#include <vector>

#include <string>

#include <cstdlib>

#include <ctime>

class Frame {

public:

Frame(const std::string& data) : data(data) {

checksum = calculateChecksum(data);

}

std::string getData() const { return data; }

int getChecksum() const { return checksum; }

bool isCorrupted() const {

return calculateChecksum(data) != checksum;

}

private:

std::string data;

int checksum;

int calculateChecksum(const std::string& data) const {

int sum = 0;

for (char c : data) {

sum += static_cast<int>(c);

}

return sum % 256; // Simple checksum (mod 256)

}

};

class DataLinkLayer {

public:

void sendFrame(const Frame& frame) {

std::cout << "Sending frame with data: " << frame.getData() << std::endl;

receivedFrame = frame;

}

void receiveFrame() {

if (receivedFrame.isCorrupted()) {

std::cout << "Error: Frame is corrupted." << std::endl;

} else {

std::cout << "Frame received successfully with data: " << receivedFrame.getData() << std::endl;

}

private:

Frame receivedFrame{"default"};

};

int main() {

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

DataLinkLayer linkLayer;

// Simulate sending a frame

std::string data = "Hello, Data Link Layer!";

Frame frame(data);

linkLayer.sendFrame(frame);

// Simulate potential corruption

if (std::rand() % 2) {

// Simulate corruption by altering data

std::string corruptedData = data;

corruptedData[0] = (corruptedData[0] == 'H') ? 'X' : 'H'; // Simple corruption example

Frame corruptedFrame(corruptedData);

linkLayer.sendFrame(corruptedFrame);

}

// Receive and check the frame

linkLayer.receiveFrame();

return 0;

}

Explanation Header Files: <iostream>: For input and output operations. <vector>: Used here just for completeness in case of extension. <string>: To handle string operations. <cstdlib>: For functions like std::rand(). <ctime>: For seeding the random number generator. Frame Class: Constructor: Initializes a frame with data and calculates its checksum. getData(): Returns the data of the …

Simulation of Data Link Layer Protocols Gaming Project in C++ Read More »

Simulation of Data Analytics Gaming Project in C++

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

#include <iostream>
#include <vector>
#include <cstdlib>
#include <ctime>
#include <numeric>
#include <algorithm>

class DataAnalytics {
public:
    DataAnalytics(int size) : dataSize(size) {
        // Initialize random number generator
        std::srand(std::time(0));
    }

    void generateData() {
        data.clear();
        for (int i = 0; i < dataSize; ++i) {
            data.push_back(std::rand() % 100 + 1); // Random data between 1 and 100
        }
    }

    void displayData() const {
        std::cout << "Generated Data: ";
        for (int value : data) {
            std::cout << value << " ";
        }
        std::cout << std::endl;
    }

    double calculateMean() const {
        double sum = std::accumulate(data.begin(), data.end(), 0.0);
        return sum / dataSize;
    }

    double calculateMedian() {
        std::vector<int> sortedData = data;
        std::sort(sortedData.begin(), sortedData.end());
        if (dataSize % 2 == 0) {
            return (sortedData[dataSize / 2 - 1] + sortedData[dataSize / 2]) / 2.0;
        } else {
            return sortedData[dataSize / 2];
        }
    }

    int calculateMode() {
        std::unordered_map<int, int> frequency;
        for (int value : data) {
            frequency[value]++;
        }

        int mode = data[0];
        int maxCount = 0;
        for (const auto& pair : frequency) {
            if (pair.second > maxCount) {
                maxCount = pair.second;
                mode = pair.first;
            }
        }
        return mode;
    }

private:
    int dataSize;
    std::vector<int> data;
};

int main() {
    const int dataSize = 10;
    DataAnalytics analytics(dataSize);

    analytics.generateData();
    analytics.displayData();

    std::cout << "Mean: " << analytics.calculateMean() << std::endl;
    std::cout << "Median: " << analytics.calculateMedian() << std::endl;
    std::cout << "Mode: " << analytics.calculateMode() << std::endl;

    return 0;
}

#include <iostream>

#include <vector>

#include <cstdlib>

#include <ctime>

#include <numeric>

#include <algorithm>

class DataAnalytics {

public:

DataAnalytics(int size) : dataSize(size) {

// Initialize random number generator

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

}

void generateData() {

data.clear();

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

data.push_back(std::rand() % 100 + 1); // Random data between 1 and 100

}

void displayData() const {

std::cout << "Generated Data: ";

for (int value : data) {

std::cout << value << " ";

}

std::cout << std::endl;

}

double calculateMean() const {

double sum = std::accumulate(data.begin(), data.end(), 0.0);

return sum / dataSize;

}

double calculateMedian() {

std::vector<int> sortedData = data;

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

if (dataSize % 2 == 0) {

return (sortedData[dataSize / 2 - 1] + sortedData[dataSize / 2]) / 2.0;

} else {

return sortedData[dataSize / 2];

}

int calculateMode() {

std::unordered_map<int, int> frequency;

for (int value : data) {

frequency[value]++;

}

int mode = data[0];

int maxCount = 0;

for (const auto& pair : frequency) {

if (pair.second > maxCount) {

maxCount = pair.second;

mode = pair.first;

}

return mode;

}

private:

int dataSize;

std::vector<int> data;

};

int main() {

const int dataSize = 10;

DataAnalytics analytics(dataSize);

analytics.generateData();

analytics.displayData();

std::cout << "Mean: " << analytics.calculateMean() << std::endl;

std::cout << "Median: " << analytics.calculateMedian() << std::endl;

std::cout << "Mode: " << analytics.calculateMode() << std::endl;

return 0;

}

Explanation Header Files: <iostream>: For input and output operations. <vector>: To use the std::vector container for storing data. <cstdlib>: For functions like std::rand() and std::srand(). <ctime>: For the std::time() function to seed the random number generator. <numeric>: For std::accumulate() used in calculating the mean. <algorithm>: For std::sort() used in sorting the data. DataAnalytics Class: …

Simulation of Data Analytics Gaming Project in C++ Read More »

Snake Game Gaming Project in C++

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

#include <iostream>
#include <conio.h>
#include <windows.h>
#include <deque>

using namespace std;

const int WIDTH = 20;
const int HEIGHT = 17;
const char SNAKE_HEAD = '@';
const char SNAKE_BODY = 'o';
const char FOOD = '*';
const char EMPTY = ' ';

enum Direction { STOP = 0, LEFT, RIGHT, UP, DOWN };

class SnakeGame {
private:
    bool gameOver;
    Direction dir;
    int score;
    pair<int, int> food;
    deque<pair<int, int>> snake;
    
    void setup() {
        gameOver = false;
        dir = STOP;
        score = 0;
        snake.clear();
        snake.push_front({WIDTH / 2, HEIGHT / 2});
        generateFood();
    }

    void generateFood() {
        food = {rand() % WIDTH, rand() % HEIGHT};
    }

    void draw() {
        system("cls"); // Clear the screen
        for (int y = 0; y < HEIGHT; ++y) {
            for (int x = 0; x < WIDTH; ++x) {
                if (x == 0 || x == WIDTH - 1 || y == 0 || y == HEIGHT - 1) {
                    cout << '#'; // Draw walls
                } else if (x == food.first && y == food.second) {
                    cout << FOOD; // Draw food
                } else {
                    bool printed = false;
                    for (auto segment : snake) {
                        if (segment.first == x && segment.second == y) {
                            cout << (segment == snake.front() ? SNAKE_HEAD : SNAKE_BODY);
                            printed = true;
                            break;
                        }
                    }
                    if (!printed) {
                        cout << EMPTY; // Draw empty space
                    }
                }
            }
            cout << endl;
        }
        cout << "Score: " << score << endl;
    }

    void input() {
        if (_kbhit()) {
            switch (_getch()) {
                case 'a': if (dir != RIGHT) dir = LEFT; break;
                case 'd': if (dir != LEFT) dir = RIGHT; break;
                case 'w': if (dir != DOWN) dir = UP; break;
                case 's': if (dir != UP) dir = DOWN; break;
                case 'x': gameOver = true; break;
            }
        }
    }

    void logic() {
        pair<int, int> head = snake.front();
        switch (dir) {
            case LEFT:  head.first--; break;
            case RIGHT: head.first++; break;
            case UP:    head.second--; break;
            case DOWN:  head.second++; break;
        }

        if (head.first < 1 || head.first >= WIDTH - 1 || head.second < 1 || head.second >= HEIGHT - 1) {
            gameOver = true; // Collision with wall
        }

        for (auto segment : snake) {
            if (segment == head) {
                gameOver = true; // Collision with itself
            }
        }

        if (head == food) {
            score += 10;
            snake.push_front(food);
            generateFood();
        } else {
            snake.push_front(head);
            snake.pop_back();
        }
    }

public:
    SnakeGame() {
        setup();
    }

    void run() {
        while (!gameOver) {
            draw();
            input();
            logic();
            Sleep(100); // Slow down the loop
        }
        cout << "Game Over!" << endl;
    }
};

int main() {
    SnakeGame game;
    game.run();
    return 0;
}

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

#include <iostream>

#include <conio.h>

#include <windows.h>

#include <deque>

using namespace std;

const int WIDTH = 20;

const int HEIGHT = 17;

const char SNAKE_HEAD = '@';

const char SNAKE_BODY = 'o';

const char FOOD = '*';

const char EMPTY = ' ';

enum Direction { STOP = 0, LEFT, RIGHT, UP, DOWN };

class SnakeGame {

private:

bool gameOver;

Direction dir;

int score;

pair<int, int> food;

deque<pair<int, int>> snake;

void setup() {

gameOver = false;

dir = STOP;

score = 0;

snake.clear();

snake.push_front({WIDTH / 2, HEIGHT / 2});

generateFood();

}

void generateFood() {

food = {rand() % WIDTH, rand() % HEIGHT};

}

void draw() {

system("cls"); // Clear the screen

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

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

if (x == 0 || x == WIDTH - 1 || y == 0 || y == HEIGHT - 1) {

cout << '#'; // Draw walls

} else if (x == food.first && y == food.second) {

cout << FOOD; // Draw food

} else {

bool printed = false;

for (auto segment : snake) {

if (segment.first == x && segment.second == y) {

cout << (segment == snake.front() ? SNAKE_HEAD : SNAKE_BODY);

printed = true;

break;

}

if (!printed) {

cout << EMPTY; // Draw empty space

}

cout << endl;

}

cout << "Score: " << score << endl;

}

void input() {

if (_kbhit()) {

switch (_getch()) {

case 'a': if (dir != RIGHT) dir = LEFT; break;

case 'd': if (dir != LEFT) dir = RIGHT; break;

case 'w': if (dir != DOWN) dir = UP; break;

case 's': if (dir != UP) dir = DOWN; break;

case 'x': gameOver = true; break;

}

void logic() {

pair<int, int> head = snake.front();

switch (dir) {

case LEFT: head.first--; break;

case RIGHT: head.first++; break;

case UP: head.second--; break;

case DOWN: head.second++; break;

}

if (head.first < 1 || head.first >= WIDTH - 1 || head.second < 1 || head.second >= HEIGHT - 1) {

gameOver = true; // Collision with wall

}

for (auto segment : snake) {

if (segment == head) {

gameOver = true; // Collision with itself

}

if (head == food) {

score += 10;

snake.push_front(food);

generateFood();

} else {

snake.push_front(head);

snake.pop_back();

}

public:

SnakeGame() {

setup();

}

void run() {

while (!gameOver) {

draw();

input();

logic();

Sleep(100); // Slow down the loop

}

cout << "Game Over!" << endl;

}

};

int main() {

SnakeGame game;

game.run();

return 0;

}

Explanation Class Definition: SnakeGame manages the game state and logic. Private members include game status (gameOver), direction of movement (dir), score (score), food location (food), and the snake (snake). Initialization (setup()): Initializes the game state, sets the snake’s initial position, and generates the first piece of food. Drawing (draw()): Clears the console and prints …

Snake Game Gaming Project in C++ Read More »

Sorting Algorithms (Bubble, Selection, Insertion, Merge, Quick) Gaming Project in C++

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

#include <iostream>
#include <vector>

// Bubble Sort
void bubbleSort(std::vector<int>& arr) {
    size_t n = arr.size();
    for (size_t i = 0; i < n - 1; ++i) {
        for (size_t j = 0; j < n - i - 1; ++j) {
            if (arr[j] > arr[j + 1]) {
                std::swap(arr[j], arr[j + 1]);
            }
        }
    }
}

// Selection Sort
void selectionSort(std::vector<int>& arr) {
    size_t n = arr.size();
    for (size_t i = 0; i < n - 1; ++i) {
        size_t minIdx = i;
        for (size_t j = i + 1; j < n; ++j) {
            if (arr[j] < arr[minIdx]) {
                minIdx = j;
            }
        }
        std::swap(arr[i], arr[minIdx]);
    }
}

// Insertion Sort
void insertionSort(std::vector<int>& arr) {
    size_t n = arr.size();
    for (size_t i = 1; i < n; ++i) {
        int key = arr[i];
        size_t j = i;
        while (j > 0 && arr[j - 1] > key) {
            arr[j] = arr[j - 1];
            --j;
        }
        arr[j] = key;
    }
}

// Merge Sort Helper Function
void merge(std::vector<int>& arr, int left, int mid, int right) {
    std::vector<int> temp(right - left + 1);
    int i = left, j = mid + 1, k = 0;
    while (i <= mid && j <= right) {
        if (arr[i] <= arr[j]) {
            temp[k++] = arr[i++];
        } else {
            temp[k++] = arr[j++];
        }
    }
    while (i <= mid) {
        temp[k++] = arr[i++];
    }
    while (j <= right) {
        temp[k++] = arr[j++];
    }
    for (i = left; i <= right; ++i) {
        arr[i] = temp[i - left];
    }
}

void mergeSort(std::vector<int>& arr, int left, int right) {
    if (left < right) {
        int mid = left + (right - left) / 2;
        mergeSort(arr, left, mid);
        mergeSort(arr, mid + 1, right);
        merge(arr, left, mid, right);
    }
}

// Quick Sort Helper Function
int partition(std::vector<int>& arr, int low, int high) {
    int pivot = arr[high];
    int i = low - 1;
    for (int j = low; j < high; ++j) {
        if (arr[j] < pivot) {
            ++i;
            std::swap(arr[i], arr[j]);
        }
    }
    std::swap(arr[i + 1], arr[high]);
    return i + 1;
}

void quickSort(std::vector<int>& arr, int low, int high) {
    if (low < high) {
        int pi = partition(arr, low, high);
        quickSort(arr, low, pi - 1);
        quickSort(arr, pi + 1, high);
    }
}

// Function to print an array
void printArray(const std::vector<int>& arr) {
    for (int num : arr) {
        std::cout << num << " ";
    }
    std::cout << std::endl;
}

int main() {
    std::vector<int> arr = {64, 34, 25, 12, 22, 11, 90};

    std::vector<int> arrCopy = arr;

    std::cout << "Original array: ";
    printArray(arr);

    std::cout << "Bubble Sort: ";
    bubbleSort(arr);
    printArray(arr);

    arr = arrCopy;

    std::cout << "Selection Sort: ";
    selectionSort(arr);
    printArray(arr);

    arr = arrCopy;

    std::cout << "Insertion Sort: ";
    insertionSort(arr);
    printArray(arr);

    arr = arrCopy;

    std::cout << "Merge Sort: ";
    mergeSort(arr, 0, arr.size() - 1);
    printArray(arr);

    arr = arrCopy;

    std::cout << "Quick Sort: ";
    quickSort(arr, 0, arr.size() - 1);
    printArray(arr);

    return 0;
}

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

139

140

141

142

#include <iostream>

#include <vector>

// Bubble Sort

void bubbleSort(std::vector<int>& arr) {

size_t n = arr.size();

for (size_t i = 0; i < n - 1; ++i) {

for (size_t j = 0; j < n - i - 1; ++j) {

if (arr[j] > arr[j + 1]) {

std::swap(arr[j], arr[j + 1]);

}

// Selection Sort

void selectionSort(std::vector<int>& arr) {

size_t n = arr.size();

for (size_t i = 0; i < n - 1; ++i) {

size_t minIdx = i;

for (size_t j = i + 1; j < n; ++j) {

if (arr[j] < arr[minIdx]) {

minIdx = j;

}

std::swap(arr[i], arr[minIdx]);

}

// Insertion Sort

void insertionSort(std::vector<int>& arr) {

size_t n = arr.size();

for (size_t i = 1; i < n; ++i) {

int key = arr[i];

size_t j = i;

while (j > 0 && arr[j - 1] > key) {

arr[j] = arr[j - 1];

--j;

}

arr[j] = key;

}

// Merge Sort Helper Function

void merge(std::vector<int>& arr, int left, int mid, int right) {

std::vector<int> temp(right - left + 1);

int i = left, j = mid + 1, k = 0;

while (i <= mid && j <= right) {

if (arr[i] <= arr[j]) {

temp[k++] = arr[i++];

} else {

temp[k++] = arr[j++];

}

while (i <= mid) {

temp[k++] = arr[i++];

}

while (j <= right) {

temp[k++] = arr[j++];

}

for (i = left; i <= right; ++i) {

arr[i] = temp[i - left];

}

void mergeSort(std::vector<int>& arr, int left, int right) {

if (left < right) {

int mid = left + (right - left) / 2;

mergeSort(arr, left, mid);

mergeSort(arr, mid + 1, right);

merge(arr, left, mid, right);

}

// Quick Sort Helper Function

int partition(std::vector<int>& arr, int low, int high) {

int pivot = arr[high];

int i = low - 1;

for (int j = low; j < high; ++j) {

if (arr[j] < pivot) {

++i;

std::swap(arr[i], arr[j]);

}

std::swap(arr[i + 1], arr[high]);

return i + 1;

}

void quickSort(std::vector<int>& arr, int low, int high) {

if (low < high) {

int pi = partition(arr, low, high);

quickSort(arr, low, pi - 1);

quickSort(arr, pi + 1, high);

}

// Function to print an array

void printArray(const std::vector<int>& arr) {

for (int num : arr) {

std::cout << num << " ";

}

std::cout << std::endl;

}

int main() {

std::vector<int> arr = {64, 34, 25, 12, 22, 11, 90};

std::vector<int> arrCopy = arr;

std::cout << "Original array: ";

printArray(arr);

std::cout << "Bubble Sort: ";

bubbleSort(arr);

printArray(arr);

arr = arrCopy;

std::cout << "Selection Sort: ";

selectionSort(arr);

printArray(arr);

arr = arrCopy;

std::cout << "Insertion Sort: ";

insertionSort(arr);

printArray(arr);

arr = arrCopy;

std::cout << "Merge Sort: ";

mergeSort(arr, 0, arr.size() - 1);

printArray(arr);

arr = arrCopy;

std::cout << "Quick Sort: ";

quickSort(arr, 0, arr.size() - 1);

printArray(arr);

return 0;

}

Explanation Bubble Sort: Repeatedly compares adjacent elements and swaps them if they are in the wrong order. Continues until no more swaps are needed. Selection Sort: Finds the minimum element from the unsorted portion and swaps it with the first unsorted element. Repeats this process for all elements. Insertion Sort: Builds the final sorted …

Sorting Algorithms (Bubble, Selection, Insertion, Merge, Quick) Gaming Project in C++ Read More »

Space Invaders Game Gaming Project in C++

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

#include <iostream>
#include <vector>
#include <conio.h>
#include <windows.h>

const int WIDTH = 20;
const int HEIGHT = 10;

class Game {
private:
    std::vector<std::vector<char>> screen;
    int playerX, playerY;
    bool gameOver;

public:
    Game() : playerX(WIDTH / 2), playerY(HEIGHT - 1), gameOver(false) {
        screen.resize(HEIGHT, std::vector<char>(WIDTH, ' '));
        screen[playerY][playerX] = '^';
    }

    void draw() {
        system("cls"); // Clear screen
        for (const auto& row : screen) {
            for (const auto& cell : row) {
                std::cout << cell;
            }
            std::cout << std::endl;
        }
    }

    void input() {
        if (_kbhit()) {
            char current = _getch();
            if (current == 'a' && playerX > 0) {
                screen[playerY][playerX] = ' ';
                playerX--;
                screen[playerY][playerX] = '^';
            } else if (current == 'd' && playerX < WIDTH - 1) {
                screen[playerY][playerX] = ' ';
                playerX++;
                screen[playerY][playerX] = '^';
            } else if (current == 'q') {
                gameOver = true;
            }
        }
    }

    void logic() {
        // Game logic would go here, such as moving enemies or detecting collisions.
        // For simplicity, this example doesn't include advanced logic.
    }

    void run() {
        while (!gameOver) {
            draw();
            input();
            logic();
            Sleep(100); // Sleep for a short period to control game speed
        }
    }
};

int main() {
    Game game;
    game.run();
    return 0;
}

#include <iostream>

#include <vector>

#include <conio.h>

#include <windows.h>

const int WIDTH = 20;

const int HEIGHT = 10;

class Game {

private:

std::vector<std::vector<char>> screen;

int playerX, playerY;

bool gameOver;

public:

Game() : playerX(WIDTH / 2), playerY(HEIGHT - 1), gameOver(false) {

screen.resize(HEIGHT, std::vector<char>(WIDTH, ' '));

screen[playerY][playerX] = '^';

}

void draw() {

system("cls"); // Clear screen

for (const auto& row : screen) {

for (const auto& cell : row) {

std::cout << cell;

}

std::cout << std::endl;

}

void input() {

if (_kbhit()) {

char current = _getch();

if (current == 'a' && playerX > 0) {

screen[playerY][playerX] = ' ';

playerX--;

screen[playerY][playerX] = '^';

} else if (current == 'd' && playerX < WIDTH - 1) {

screen[playerY][playerX] = ' ';

playerX++;

screen[playerY][playerX] = '^';

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

gameOver = true;

}

void logic() {

// Game logic would go here, such as moving enemies or detecting collisions.

// For simplicity, this example doesn't include advanced logic.

}

void run() {

while (!gameOver) {

draw();

input();

logic();

Sleep(100); // Sleep for a short period to control game speed

}

};

int main() {

Game game;

game.run();

return 0;

}

Explanation Class Definition: Game class manages the game state. screen is a 2D vector representing the game screen. playerX and playerY store the player’s position. gameOver is a flag to indicate if the game should end. Constructor: Initializes the screen with spaces and places the player at the bottom center of the screen. Member …

Space Invaders Game Gaming Project in C++ Read More »

Speech Recognition Gaming Project in C++

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

#include <iostream>
#include <string>
#include <unordered_map>
#include <algorithm>

class SpeechRecognition {
private:
    std::unordered_map<std::string, std::string> commands;

public:
    SpeechRecognition() {
        // Initialize with some commands
        commands["play"] = "Playing music";
        commands["stop"] = "Stopping music";
        commands["pause"] = "Pausing music";
        commands["resume"] = "Resuming music";
    }

    void recognizeSpeech(const std::string& input) const {
        std::string command = input;
        std::transform(command.begin(), command.end(), command.begin(), ::tolower); // Convert to lowercase

        auto it = commands.find(command);
        if (it != commands.end()) {
            std::cout << it->second << std::endl;
        } else {
            std::cout << "Command not recognized" << std::endl;
        }
    }
};

int main() {
    SpeechRecognition sr;

    std::cout << "Speak a command (e.g., play, stop, pause, resume):" << std::endl;

    while (true) {
        std::string input;
        std::getline(std::cin, input);

        if (input == "exit") {
            break;
        }

        sr.recognizeSpeech(input);
    }

    return 0;
}

#include <iostream>

#include <string>

#include <unordered_map>

#include <algorithm>

class SpeechRecognition {

private:

std::unordered_map<std::string, std::string> commands;

public:

SpeechRecognition() {

// Initialize with some commands

commands["play"] = "Playing music";

commands["stop"] = "Stopping music";

commands["pause"] = "Pausing music";

commands["resume"] = "Resuming music";

}

void recognizeSpeech(const std::string& input) const {

std::string command = input;

std::transform(command.begin(), command.end(), command.begin(), ::tolower); // Convert to lowercase

auto it = commands.find(command);

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

std::cout << it->second << std::endl;

} else {

std::cout << "Command not recognized" << std::endl;

}

};

int main() {

SpeechRecognition sr;

std::cout << "Speak a command (e.g., play, stop, pause, resume):" << std::endl;

while (true) {

std::string input;

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

if (input == "exit") {

break;

}

sr.recognizeSpeech(input);

}

return 0;

}

Explanation Class Definition: SpeechRecognition class simulates the functionality of speech recognition. It contains a private member commands, which is an unordered_map that maps recognized commands (strings) to their responses (also strings). Constructor: Initializes the commands map with a few predefined commands and their corresponding actions. Member Function: recognizeSpeech(const std::string& input) const: Converts the input …

Speech Recognition Gaming Project in C++ Read More »

Spreadsheet Application Gaming Project in C++

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

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

class Spreadsheet {
private:
    std::vector<std::vector<std::string>> data;
    size_t rows, cols;

public:
    Spreadsheet(size_t r, size_t c) : rows(r), cols(c) {
        data.resize(rows, std::vector<std::string>(cols, ""));
    }

    void setValue(size_t row, size_t col, const std::string& value) {
        if (row < rows && col < cols) {
            data[row][col] = value;
        } else {
            std::cerr << "Invalid cell coordinates!" << std::endl;
        }
    }

    std::string getValue(size_t row, size_t col) const {
        if (row < rows && col < cols) {
            return data[row][col];
        } else {
            std::cerr << "Invalid cell coordinates!" << std::endl;
            return "";
        }
    }

    void display() const {
        for (const auto& row : data) {
            for (const auto& cell : row) {
                std::cout << std::setw(10) << cell << " ";
            }
            std::cout << std::endl;
        }
    }
};

int main() {
    size_t rows, cols;
    std::cout << "Enter the number of rows and columns: ";
    std::cin >> rows >> cols;

    Spreadsheet sheet(rows, cols);

    while (true) {
        std::cout << "\n1. Set Value\n2. Get Value\n3. Display\n4. Exit\n";
        int choice;
        std::cin >> choice;

        if (choice == 1) {
            size_t r, c;
            std::string value;
            std::cout << "Enter row, column, and value: ";
            std::cin >> r >> c >> value;
            sheet.setValue(r, c, value);
        } else if (choice == 2) {
            size_t r, c;
            std::cout << "Enter row and column: ";
            std::cin >> r >> c;
            std::cout << "Value at (" << r << ", " << c << ") is " << sheet.getValue(r, c) << std::endl;
        } else if (choice == 3) {
            sheet.display();
        } else if (choice == 4) {
            break;
        } else {
            std::cout << "Invalid choice!" << std::endl;
        }
    }

    return 0;
}

#include <iostream>

#include <vector>

#include <string>

#include <iomanip>

class Spreadsheet {

private:

std::vector<std::vector<std::string>> data;

size_t rows, cols;

public:

Spreadsheet(size_t r, size_t c) : rows(r), cols(c) {

data.resize(rows, std::vector<std::string>(cols, ""));

}

void setValue(size_t row, size_t col, const std::string& value) {

if (row < rows && col < cols) {

data[row][col] = value;

} else {

std::cerr << "Invalid cell coordinates!" << std::endl;

}

std::string getValue(size_t row, size_t col) const {

if (row < rows && col < cols) {

return data[row][col];

} else {

std::cerr << "Invalid cell coordinates!" << std::endl;

return "";

}

void display() const {

for (const auto& row : data) {

for (const auto& cell : row) {

std::cout << std::setw(10) << cell << " ";

}

std::cout << std::endl;

}

};

int main() {

size_t rows, cols;

std::cout << "Enter the number of rows and columns: ";

std::cin >> rows >> cols;

Spreadsheet sheet(rows, cols);

while (true) {

std::cout << "\n1. Set Value\n2. Get Value\n3. Display\n4. Exit\n";

int choice;

std::cin >> choice;

if (choice == 1) {

size_t r, c;

std::string value;

std::cout << "Enter row, column, and value: ";

std::cin >> r >> c >> value;

sheet.setValue(r, c, value);

} else if (choice == 2) {

size_t r, c;

std::cout << "Enter row and column: ";

std::cin >> r >> c;

std::cout << "Value at (" << r << ", " << c << ") is " << sheet.getValue(r, c) << std::endl;

} else if (choice == 3) {

sheet.display();

} else if (choice == 4) {

break;

} else {

std::cout << "Invalid choice!" << std::endl;

}

return 0;

}

Explanation Class Definition: Spreadsheet class is used to manage a 2D grid of cells. It has private members data (a 2D vector of strings) to store cell values, and rows, cols to store the dimensions of the spreadsheet. Constructor: Initializes the data vector with empty strings and sets the dimensions. Member Functions: setValue(size_t row, …

Spreadsheet Application Gaming Project in C++ Read More »