C++ Projects – Page 12 – Projects Inventory

Simulation of Boids Algorithm Gaming Project in C++

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

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

// Constants
const float WIDTH = 800.0f;
const float HEIGHT = 600.0f;
const int BOID_COUNT = 100;
const float MAX_SPEED = 5.0f;
const float MAX_FORCE = 0.1f;
const float NEIGHBOR_RADIUS = 50.0f;
const float SEPARATION_RADIUS = 20.0f;

// Vector2 class for 2D vector operations
class Vector2 {
public:
    float x, y;

    Vector2(float x = 0, float y = 0) : x(x), y(y) {}

    Vector2 operator+(const Vector2& v) const {
        return Vector2(x + v.x, y + v.y);
    }

    Vector2 operator-(const Vector2& v) const {
        return Vector2(x - v.x, y - v.y);
    }

    Vector2 operator*(float scalar) const {
        return Vector2(x * scalar, y * scalar);
    }

    Vector2& operator+=(const Vector2& v) {
        x += v.x;
        y += v.y;
        return *this;
    }

    Vector2& operator-=(const Vector2& v) {
        x -= v.x;
        y -= v.y;
        return *this;
    }

    Vector2& operator*=(float scalar) {
        x *= scalar;
        y *= scalar;
        return *this;
    }

    float length() const {
        return std::sqrt(x * x + y * y);
    }

    Vector2 normalize() const {
        float len = length();
        if (len > 0) {
            return *this * (1.0f / len);
        }
        return *this;
    }
};

// Boid class
class Boid {
public:
    Vector2 position;
    Vector2 velocity;
    Vector2 acceleration;

    Boid(float x, float y) : position(x, y), velocity(rand() % 2 - 1, rand() % 2 - 1), acceleration(0, 0) {}

    void update() {
        velocity += acceleration;
        if (velocity.length() > MAX_SPEED) {
            velocity = velocity.normalize() * MAX_SPEED;
        }
        position += velocity;
        acceleration *= 0;
        wrapAround();
    }

    void applyForce(const Vector2& force) {
        acceleration += force;
    }

    void wrapAround() {
        if (position.x < 0) position.x += WIDTH;
        if (position.x > WIDTH) position.x -= WIDTH;
        if (position.y < 0) position.y += HEIGHT;
        if (position.y > HEIGHT) position.y -= HEIGHT;
    }
};

// Main simulation function
void simulate(std::vector<Boid>& boids) {
    for (auto& boid : boids) {
        Vector2 alignment(0, 0);
        Vector2 cohesion(0, 0);
        Vector2 separation(0, 0);
        int neighborCount = 0;

        for (const auto& other : boids) {
            if (&boid == &other) continue;
            Vector2 diff = boid.position - other.position;
            float distance = diff.length();

            if (distance < NEIGHBOR_RADIUS) {
                alignment += other.velocity;
                cohesion += other.position;
                if (distance < SEPARATION_RADIUS) {
                    separation += diff.normalize() / distance;
                }
                neighborCount++;
            }
        }

        if (neighborCount > 0) {
            alignment = alignment * (1.0f / neighborCount);
            cohesion = (cohesion * (1.0f / neighborCount) - boid.position).normalize();
            separation = separation.normalize();
        }

        alignment = alignment.normalize() * MAX_SPEED - boid.velocity;
        cohesion = cohesion.normalize() * MAX_SPEED - boid.velocity;
        separation = separation.normalize() * MAX_SPEED - boid.velocity;

        alignment *= 1.0f;
        cohesion *= 1.0f;
        separation *= 1.5f;

        boid.applyForce(alignment);
        boid.applyForce(cohesion);
        boid.applyForce(separation);

        boid.update();
    }
}

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

    std::vector<Boid> boids;
    for (int i = 0; i < BOID_COUNT; ++i) {
        boids.emplace_back(rand() % static_cast<int>(WIDTH), rand() % static_cast<int>(HEIGHT));
    }

    while (true) {
        simulate(boids);

        // Here you would typically add rendering code to visualize the boids
    }

    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

143

144

145

146

147

148

149

150

151

152

153

154

155

156

157

#include <iostream>

#include <vector>

#include <cmath>

#include <cstdlib>

#include <ctime>

// Constants

const float WIDTH = 800.0f;

const float HEIGHT = 600.0f;

const int BOID_COUNT = 100;

const float MAX_SPEED = 5.0f;

const float MAX_FORCE = 0.1f;

const float NEIGHBOR_RADIUS = 50.0f;

const float SEPARATION_RADIUS = 20.0f;

// Vector2 class for 2D vector operations

class Vector2 {

public:

float x, y;

Vector2(float x = 0, float y = 0) : x(x), y(y) {}

Vector2 operator+(const Vector2& v) const {

return Vector2(x + v.x, y + v.y);

}

Vector2 operator-(const Vector2& v) const {

return Vector2(x - v.x, y - v.y);

}

Vector2 operator*(float scalar) const {

return Vector2(x * scalar, y * scalar);

}

Vector2& operator+=(const Vector2& v) {

x += v.x;

y += v.y;

return *this;

}

Vector2& operator-=(const Vector2& v) {

x -= v.x;

y -= v.y;

return *this;

}

Vector2& operator*=(float scalar) {

x *= scalar;

y *= scalar;

return *this;

}

float length() const {

return std::sqrt(x * x + y * y);

}

Vector2 normalize() const {

float len = length();

if (len > 0) {

return *this * (1.0f / len);

}

return *this;

}

};

// Boid class

class Boid {

public:

Vector2 position;

Vector2 velocity;

Vector2 acceleration;

Boid(float x, float y) : position(x, y), velocity(rand() % 2 - 1, rand() % 2 - 1), acceleration(0, 0) {}

void update() {

velocity += acceleration;

if (velocity.length() > MAX_SPEED) {

velocity = velocity.normalize() * MAX_SPEED;

}

position += velocity;

acceleration *= 0;

wrapAround();

}

void applyForce(const Vector2& force) {

acceleration += force;

}

void wrapAround() {

if (position.x < 0) position.x += WIDTH;

if (position.x > WIDTH) position.x -= WIDTH;

if (position.y < 0) position.y += HEIGHT;

if (position.y > HEIGHT) position.y -= HEIGHT;

}

};

// Main simulation function

void simulate(std::vector<Boid>& boids) {

for (auto& boid : boids) {

Vector2 alignment(0, 0);

Vector2 cohesion(0, 0);

Vector2 separation(0, 0);

int neighborCount = 0;

for (const auto& other : boids) {

if (&boid == &other) continue;

Vector2 diff = boid.position - other.position;

float distance = diff.length();

if (distance < NEIGHBOR_RADIUS) {

alignment += other.velocity;

cohesion += other.position;

if (distance < SEPARATION_RADIUS) {

separation += diff.normalize() / distance;

}

neighborCount++;

}

if (neighborCount > 0) {

alignment = alignment * (1.0f / neighborCount);

cohesion = (cohesion * (1.0f / neighborCount) - boid.position).normalize();

separation = separation.normalize();

}

alignment = alignment.normalize() * MAX_SPEED - boid.velocity;

cohesion = cohesion.normalize() * MAX_SPEED - boid.velocity;

separation = separation.normalize() * MAX_SPEED - boid.velocity;

alignment *= 1.0f;

cohesion *= 1.0f;

separation *= 1.5f;

boid.applyForce(alignment);

boid.applyForce(cohesion);

boid.applyForce(separation);

boid.update();

}

int main() {

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

std::vector<Boid> boids;

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

boids.emplace_back(rand() % static_cast<int>(WIDTH), rand() % static_cast<int>(HEIGHT));

}

while (true) {

simulate(boids);

// Here you would typically add rendering code to visualize the boids

}

return 0;

}

Explanation: Vector2 Class: Implements basic 2D vector operations like addition, subtraction, scaling, and normalization. Boid Class: Represents a single boid with position, velocity, and acceleration. The update() method updates the boid’s position based on its velocity and wraps around the screen edges. simulate Function: Simulates the behavior of all boids. For each boid, it …

Simulation of Boids Algorithm Gaming Project in C++ Read More »

Simulation of Blockchain Technology Gaming Project in C++

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

#include <iostream>
#include <vector>
#include <string>
#include <sstream>
#include <iomanip>
#include <openssl/sha.h> // For SHA256 hashing

using namespace std;

// Function to calculate SHA256 hash of a string
string sha256(const string& input) {
    unsigned char hash[SHA256_DIGEST_LENGTH];
    SHA256_CTX sha256;
    SHA256_Init(&sha256);
    SHA256_Update(&sha256, input.c_str(), input.size());
    SHA256_Final(hash, &sha256);
    
    stringstream ss;
    for (int i = 0; i < SHA256_DIGEST_LENGTH; ++i) {
        ss << hex << setw(2) << setfill('0') << (int)hash[i];
    }
    return ss.str();
}

// Block class
class Block {
public:
    string previousHash;
    string hash;
    string data;
    long timestamp;

    Block(string data, string previousHash = "")
        : data(data), previousHash(previousHash), timestamp(time(nullptr)) {
        hash = calculateHash();
    }

    string calculateHash() const {
        stringstream ss;
        ss << timestamp << previousHash << data;
        return sha256(ss.str());
    }
};

// Blockchain class
class Blockchain {
private:
    vector<Block> chain;

public:
    Blockchain() {
        // Create the genesis block
        chain.push_back(Block("Genesis Block"));
    }

    void addBlock(const Block& newBlock) {
        chain.push_back(newBlock);
    }

    void printChain() const {
        for (const auto& block : chain) {
            cout << "Block Index: " << (&block - &chain[0]) << endl;
            cout << "Timestamp: " << block.timestamp << endl;
            cout << "Data: " << block.data << endl;
            cout << "Hash: " << block.hash << endl;
            cout << "Previous Hash: " << block.previousHash << endl;
            cout << "------------------------" << endl;
        }
    }
};

int main() {
    Blockchain blockchain;

    blockchain.addBlock(Block("Block 1 Data", blockchain.chain.back().hash));
    blockchain.addBlock(Block("Block 2 Data", blockchain.chain.back().hash));
    blockchain.addBlock(Block("Block 3 Data", blockchain.chain.back().hash));

    cout << "Blockchain contents:" << endl;
    blockchain.printChain();

    return 0;
}

#include <iostream>

#include <vector>

#include <string>

#include <sstream>

#include <iomanip>

#include <openssl/sha.h> // For SHA256 hashing

using namespace std;

// Function to calculate SHA256 hash of a string

string sha256(const string& input) {

unsigned char hash[SHA256_DIGEST_LENGTH];

SHA256_CTX sha256;

SHA256_Init(&sha256);

SHA256_Update(&sha256, input.c_str(), input.size());

SHA256_Final(hash, &sha256);

stringstream ss;

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

ss << hex << setw(2) << setfill('0') << (int)hash[i];

}

return ss.str();

}

// Block class

class Block {

public:

string previousHash;

string hash;

string data;

long timestamp;

Block(string data, string previousHash = "")

: data(data), previousHash(previousHash), timestamp(time(nullptr)) {

hash = calculateHash();

}

string calculateHash() const {

stringstream ss;

ss << timestamp << previousHash << data;

return sha256(ss.str());

}

};

// Blockchain class

class Blockchain {

private:

vector<Block> chain;

public:

Blockchain() {

// Create the genesis block

chain.push_back(Block("Genesis Block"));

}

void addBlock(const Block& newBlock) {

chain.push_back(newBlock);

}

void printChain() const {

for (const auto& block : chain) {

cout << "Block Index: " << (&block - &chain[0]) << endl;

cout << "Timestamp: " << block.timestamp << endl;

cout << "Data: " << block.data << endl;

cout << "Hash: " << block.hash << endl;

cout << "Previous Hash: " << block.previousHash << endl;

cout << "------------------------" << endl;

}

};

int main() {

Blockchain blockchain;

blockchain.addBlock(Block("Block 1 Data", blockchain.chain.back().hash));

blockchain.addBlock(Block("Block 2 Data", blockchain.chain.back().hash));

blockchain.addBlock(Block("Block 3 Data", blockchain.chain.back().hash));

cout << "Blockchain contents:" << endl;

blockchain.printChain();

return 0;

}

Explanation Headers: <iostream>: For input and output operations. <vector>: For using the std::vector container. <string>: For using the std::string class. <sstream>: For string stream operations. <iomanip>: For formatting output. <openssl/sha.h>: For SHA256 hashing. (You need OpenSSL library installed.) Function sha256: Parameters: const string& input: The input string to hash. Functionality: Computes the SHA256 hash …

Simulation of Blockchain Technology Gaming Project in C++ Read More »

Simulation of Big Data Processing Gaming Project in C++

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

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

using namespace std;

// Function to generate a large dataset of random integers
vector<int> generateDataset(size_t size, int minValue, int maxValue) {
    vector<int> dataset(size);
    for (size_t i = 0; i < size; ++i) {
        dataset[i] = minValue + rand() % (maxValue - minValue + 1);
    }
    return dataset;
}

// Function to calculate the mean of a dataset
double calculateMean(const vector<int>& dataset) {
    double sum = 0;
    for (int value : dataset) {
        sum += value;
    }
    return sum / dataset.size();
}

// Function to calculate the standard deviation of a dataset
double calculateStandardDeviation(const vector<int>& dataset, double mean) {
    double sum = 0;
    for (int value : dataset) {
        sum += (value - mean) * (value - mean);
    }
    return sqrt(sum / dataset.size());
}

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

    size_t datasetSize = 1000000; // Size of the dataset
    int minValue = 0; // Minimum value in the dataset
    int maxValue = 100; // Maximum value in the dataset

    // Generate the dataset
    vector<int> dataset = generateDataset(datasetSize, minValue, maxValue);

    // Calculate mean and standard deviation
    double mean = calculateMean(dataset);
    double stdDev = calculateStandardDeviation(dataset, mean);

    // Print results
    cout << "Dataset Size: " << datasetSize << endl;
    cout << "Mean: " << mean << endl;
    cout << "Standard Deviation: " << stdDev << endl;

    return 0;
}

#include <iostream>

#include <vector>

#include <cmath>

#include <cstdlib>

#include <ctime>

using namespace std;

// Function to generate a large dataset of random integers

vector<int> generateDataset(size_t size, int minValue, int maxValue) {

vector<int> dataset(size);

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

dataset[i] = minValue + rand() % (maxValue - minValue + 1);

}

return dataset;

}

// Function to calculate the mean of a dataset

double calculateMean(const vector<int>& dataset) {

double sum = 0;

for (int value : dataset) {

sum += value;

}

return sum / dataset.size();

}

// Function to calculate the standard deviation of a dataset

double calculateStandardDeviation(const vector<int>& dataset, double mean) {

double sum = 0;

for (int value : dataset) {

sum += (value - mean) * (value - mean);

}

return sqrt(sum / dataset.size());

}

int main() {

srand(static_cast<unsigned>(time(0))); // Seed for random number generation

size_t datasetSize = 1000000; // Size of the dataset

int minValue = 0; // Minimum value in the dataset

int maxValue = 100; // Maximum value in the dataset

// Generate the dataset

vector<int> dataset = generateDataset(datasetSize, minValue, maxValue);

// Calculate mean and standard deviation

double mean = calculateMean(dataset);

double stdDev = calculateStandardDeviation(dataset, mean);

// Print results

cout << "Dataset Size: " << datasetSize << endl;

cout << "Mean: " << mean << endl;

cout << "Standard Deviation: " << stdDev << endl;

return 0;

}

Explanation Headers: <iostream>: For input and output operations. <vector>: For using the std::vector container. <cmath>: For mathematical functions like sqrt(). <cstdlib>: For rand() and srand() functions. <ctime>: For time() function to seed the random number generator. Function generateDataset: Parameters: size: Number of elements in the dataset. minValue and maxValue: Range of random integers. Functionality: …

Simulation of Big Data Processing Gaming Project in C++ Read More »

Simulation of Autonomous Vehicles Gaming Project in C++

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

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

using namespace std;

// Directions for movement (right, down, left, up)
const int dx[] = {0, 1, 0, -1};
const int dy[] = {1, 0, -1, 0};

// AutonomousVehicle class
class AutonomousVehicle {
private:
    int x, y; // Current position
    int goalX, goalY; // Goal position
    vector<vector<char>> grid;

public:
    AutonomousVehicle(int startX, int startY, int goalX, int goalY, const vector<vector<char>>& grid)
        : x(startX), y(startY), goalX(goalX), goalY(goalY), grid(grid) {}

    void move() {
        // Move towards the goal position
        if (x < goalX) x += 1; // Move right
        else if (x > goalX) x -= 1; // Move left
        
        if (y < goalY) y += 1; // Move down
        else if (y > goalY) y -= 1; // Move up

        // Simulate obstacle avoidance (if there's an obstacle at the new position)
        if (grid[y][x] == '#') {
            // Randomly choose a different direction if there's an obstacle
            int dir = rand() % 4;
            x += dx[dir];
            y += dy[dir];
        }
    }

    bool hasReachedGoal() const {
        return x == goalX && y == goalY;
    }

    void printPosition() const {
        cout << "Vehicle position: (" << x << ", " << y << ")" << endl;
    }
};

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

    int width = 10;
    int height = 10;

    // Initialize the grid with empty spaces
    vector<vector<char>> grid(height, vector<char>(width, '.'));

    // Add some obstacles to the grid
    grid[3][3] = '#';
    grid[4][3] = '#';
    grid[5][3] = '#';

    // Initialize the vehicle
    AutonomousVehicle vehicle(0, 0, 9, 9, grid);

    // Simulation loop
    while (!vehicle.hasReachedGoal()) {
        cout << "Current state:" << endl;
        vehicle.printPosition();
        vehicle.move();
        cout << "Moving..." << endl;
        cout << endl;
    }

    cout << "Goal reached!" << endl;

    return 0;
}

#include <iostream>

#include <vector>

#include <cstdlib>

#include <ctime>

using namespace std;

// Directions for movement (right, down, left, up)

const int dx[] = {0, 1, 0, -1};

const int dy[] = {1, 0, -1, 0};

// AutonomousVehicle class

class AutonomousVehicle {

private:

int x, y; // Current position

int goalX, goalY; // Goal position

vector<vector<char>> grid;

public:

AutonomousVehicle(int startX, int startY, int goalX, int goalY, const vector<vector<char>>& grid)

: x(startX), y(startY), goalX(goalX), goalY(goalY), grid(grid) {}

void move() {

// Move towards the goal position

if (x < goalX) x += 1; // Move right

else if (x > goalX) x -= 1; // Move left

if (y < goalY) y += 1; // Move down

else if (y > goalY) y -= 1; // Move up

// Simulate obstacle avoidance (if there's an obstacle at the new position)

if (grid[y][x] == '#') {

// Randomly choose a different direction if there's an obstacle

int dir = rand() % 4;

x += dx[dir];

y += dy[dir];

}

bool hasReachedGoal() const {

return x == goalX && y == goalY;

}

void printPosition() const {

cout << "Vehicle position: (" << x << ", " << y << ")" << endl;

}

};

int main() {

srand(static_cast<unsigned>(time(0))); // Seed for random number generation

int width = 10;

int height = 10;

// Initialize the grid with empty spaces

vector<vector<char>> grid(height, vector<char>(width, '.'));

// Add some obstacles to the grid

grid[3][3] = '#';

grid[4][3] = '#';

grid[5][3] = '#';

// Initialize the vehicle

AutonomousVehicle vehicle(0, 0, 9, 9, grid);

// Simulation loop

while (!vehicle.hasReachedGoal()) {

cout << "Current state:" << endl;

vehicle.printPosition();

vehicle.move();

cout << "Moving..." << endl;

cout << endl;

}

cout << "Goal reached!" << endl;

return 0;

}

Explanation Headers: <iostream>: For input and output operations. <vector>: For using the std::vector container. <cstdlib>: For rand() and srand() functions. <ctime>: For time() function to seed the random number generator. AutonomousVehicle Class: Attributes: x and y: Current position of the vehicle. goalX and goalY: Goal position for the vehicle to reach. grid: 2D grid …

Simulation of Autonomous Vehicles Gaming Project in C++ Read More »

Simulation of Augmented Reality (AR) Gaming Project in C++

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

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

using namespace std;

// Function to display the simulated camera feed with AR overlay
void displayARFeed(const vector<vector<char>>& feed, const vector<pair<int, int>>& objects) {
    // Create a copy of the feed to modify
    vector<vector<char>> display = feed;

    // Overlay virtual objects
    for (const auto& obj : objects) {
        int x = obj.first;
        int y = obj.second;
        if (x >= 0 && x < feed.size() && y >= 0 && y < feed[0].size()) {
            display[x][y] = '*'; // Mark virtual objects with '*'
        }
    }

    // Print the AR feed
    for (const auto& row : display) {
        for (const auto& cell : row) {
            cout << cell << ' ';
        }
        cout << endl;
    }
}

int main() {
    int width = 10;
    int height = 10;

    // Initialize the camera feed with empty space
    vector<vector<char>> feed(height, vector<char>(width, '.'));

    // Virtual objects (x, y positions)
    vector<pair<int, int>> objects = {{2, 3}, {5, 5}, {8, 7}};

    cout << "Simulated AR Camera Feed:" << endl;
    displayARFeed(feed, objects);

    return 0;
}

#include <iostream>

#include <vector>

#include <iomanip>

using namespace std;

// Function to display the simulated camera feed with AR overlay

void displayARFeed(const vector<vector<char>>& feed, const vector<pair<int, int>>& objects) {

// Create a copy of the feed to modify

vector<vector<char>> display = feed;

// Overlay virtual objects

for (const auto& obj : objects) {

int x = obj.first;

int y = obj.second;

if (x >= 0 && x < feed.size() && y >= 0 && y < feed[0].size()) {

display[x][y] = '*'; // Mark virtual objects with '*'

}

// Print the AR feed

for (const auto& row : display) {

for (const auto& cell : row) {

cout << cell << ' ';

}

cout << endl;

}

int main() {

int width = 10;

int height = 10;

// Initialize the camera feed with empty space

vector<vector<char>> feed(height, vector<char>(width, '.'));

// Virtual objects (x, y positions)

vector<pair<int, int>> objects = {{2, 3}, {5, 5}, {8, 7}};

cout << "Simulated AR Camera Feed:" << endl;

displayARFeed(feed, objects);

return 0;

}

Explanation Headers: <iostream>: For input and output operations. <vector>: For using the std::vector container. <iomanip>: For formatting (though not strictly necessary here). Function displayARFeed: Parameters: const vector<vector<char>>& feed: The camera feed represented as a 2D grid of characters. const vector<pair<int, int>>& objects: A list of positions for virtual objects to overlay on the feed. …

Simulation of Augmented Reality (AR) Gaming Project in C++ Read More »

Simulation of Artificial Neural Networks Gaming Project in C++

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

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

using namespace std;

// Sigmoid activation function
double sigmoid(double x) {
    return 1.0 / (1.0 + exp(-x));
}

// Derivative of the sigmoid function
double sigmoidDerivative(double x) {
    return x * (1.0 - x);
}

// Neural network class
class NeuralNetwork {
private:
    vector<vector<double>> weights;
    vector<double> biases;
    vector<double> outputs;

public:
    NeuralNetwork(int inputSize, int outputSize) {
        // Initialize weights and biases
        weights.resize(outputSize, vector<double>(inputSize));
        biases.resize(outputSize);
        outputs.resize(outputSize);

        srand(static_cast<unsigned>(time(0))); // Seed for random number generation

        for (int i = 0; i < outputSize; ++i) {
            biases[i] = static_cast<double>(rand()) / RAND_MAX; // Random bias
            for (int j = 0; j < inputSize; ++j) {
                weights[i][j] = static_cast<double>(rand()) / RAND_MAX; // Random weight
            }
        }
    }

    // Forward propagation
    void forward(const vector<double>& inputs) {
        for (size_t i = 0; i < weights.size(); ++i) {
            double activation = biases[i];
            for (size_t j = 0; j < weights[i].size(); ++j) {
                activation += weights[i][j] * inputs[j];
            }
            outputs[i] = sigmoid(activation);
        }
    }

    // Print the network outputs
    void printOutputs() const {
        cout << "Outputs: ";
        for (const double& output : outputs) {
            cout << output << " ";
        }
        cout << endl;
    }
};

int main() {
    int inputSize = 3;
    int outputSize = 1;
    NeuralNetwork nn(inputSize, outputSize);

    vector<double> inputs = {0.5, 0.3, 0.2}; // Example inputs

    cout << "Running neural network simulation..." << endl;

    nn.forward(inputs);
    nn.printOutputs();

    return 0;
}

#include <iostream>

#include <vector>

#include <cmath>

#include <cstdlib>

#include <ctime>

using namespace std;

// Sigmoid activation function

double sigmoid(double x) {

return 1.0 / (1.0 + exp(-x));

}

// Derivative of the sigmoid function

double sigmoidDerivative(double x) {

return x * (1.0 - x);

}

// Neural network class

class NeuralNetwork {

private:

vector<vector<double>> weights;

vector<double> biases;

vector<double> outputs;

public:

NeuralNetwork(int inputSize, int outputSize) {

// Initialize weights and biases

weights.resize(outputSize, vector<double>(inputSize));

biases.resize(outputSize);

outputs.resize(outputSize);

srand(static_cast<unsigned>(time(0))); // Seed for random number generation

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

biases[i] = static_cast<double>(rand()) / RAND_MAX; // Random bias

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

weights[i][j] = static_cast<double>(rand()) / RAND_MAX; // Random weight

}

// Forward propagation

void forward(const vector<double>& inputs) {

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

double activation = biases[i];

for (size_t j = 0; j < weights[i].size(); ++j) {

activation += weights[i][j] * inputs[j];

}

outputs[i] = sigmoid(activation);

}

// Print the network outputs

void printOutputs() const {

cout << "Outputs: ";

for (const double& output : outputs) {

cout << output << " ";

}

cout << endl;

}

};

int main() {

int inputSize = 3;

int outputSize = 1;

NeuralNetwork nn(inputSize, outputSize);

vector<double> inputs = {0.5, 0.3, 0.2}; // Example inputs

cout << "Running neural network simulation..." << endl;

nn.forward(inputs);

nn.printOutputs();

return 0;

}

Explanation Headers: <iostream>: For input and output operations. <vector>: For using the std::vector container. <cmath>: For mathematical functions like exp(). <cstdlib>: For rand() and srand() functions. <ctime>: For time() function to seed the random number generator. Activation Function: double sigmoid(double x): Computes the sigmoid activation function. double sigmoidDerivative(double x): Computes the derivative of the …

Simulation of Artificial Neural Networks Gaming Project in C++ Read More »

Simulation of Artificial Intelligence Concepts Gaming Project in C++

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

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

using namespace std;

// Enum for AI states
enum class State {
    Idle,
    Patrol,
    Chase
};

// AI class
class AI {
private:
    State currentState;
    int playerDistance;

public:
    AI() : currentState(State::Idle), playerDistance(100) {}

    void update() {
        // Update state based on player distance
        if (playerDistance < 20) {
            currentState = State::Chase;
        } else if (playerDistance < 50) {
            currentState = State::Patrol;
        } else {
            currentState = State::Idle;
        }

        // Print the current state
        switch (currentState) {
            case State::Idle:
                cout << "AI is idle." << endl;
                break;
            case State::Patrol:
                cout << "AI is patrolling." << endl;
                break;
            case State::Chase:
                cout << "AI is chasing the player!" << endl;
                break;
        }
    }

    void simulatePlayerMovement() {
        // Simulate player distance changing
        playerDistance = rand() % 100;
    }
};

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

    AI ai;
    int steps = 10;

    for (int i = 0; i < steps; ++i) {
        cout << "Step " << i + 1 << ":" << endl;
        ai.simulatePlayerMovement();
        ai.update();
        cout << endl;
    }

    return 0;
}

#include <iostream>

#include <cstdlib>

#include <ctime>

using namespace std;

// Enum for AI states

enum class State {

Idle,

Patrol,

Chase

};

// AI class

class AI {

private:

State currentState;

int playerDistance;

public:

AI() : currentState(State::Idle), playerDistance(100) {}

void update() {

// Update state based on player distance

if (playerDistance < 20) {

currentState = State::Chase;

} else if (playerDistance < 50) {

currentState = State::Patrol;

} else {

currentState = State::Idle;

}

// Print the current state

switch (currentState) {

case State::Idle:

cout << "AI is idle." << endl;

break;

case State::Patrol:

cout << "AI is patrolling." << endl;

break;

case State::Chase:

cout << "AI is chasing the player!" << endl;

break;

}

void simulatePlayerMovement() {

// Simulate player distance changing

playerDistance = rand() % 100;

}

};

int main() {

srand(static_cast<unsigned>(time(0))); // Seed for random number generation

AI ai;

int steps = 10;

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

cout << "Step " << i + 1 << ":" << endl;

ai.simulatePlayerMovement();

ai.update();

cout << endl;

}

return 0;

}

Explanation Headers: <iostream>: For input and output operations. <cstdlib>: For rand() and srand() functions. <ctime>: For time() function to seed the random number generator. Enum: enum class State: Defines the possible states for the AI (Idle, Patrol, Chase). AI Class: Attributes: currentState: Current state of the AI. playerDistance: Simulated distance to the player. Methods: …

Simulation of Artificial Intelligence Concepts Gaming Project in C++ Read More »

Simulation of Ant Colony Optimization Gaming Project in C++

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

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

using namespace std;

// Grid dimensions
const int WIDTH = 10;
const int HEIGHT = 10;

// Directions for movement (right, down, left, up)
const int dx[] = {0, 1, 0, -1};
const int dy[] = {1, 0, -1, 0};

// Ant class
class Ant {
public:
    int x, y;
    Ant(int startX, int startY) : x(startX), y(startY) {}
    void move() {
        int direction = rand() % 4;
        x += dx[direction];
        y += dy[direction];
        x = max(0, min(WIDTH - 1, x));
        y = max(0, min(HEIGHT - 1, y));
    }
};

// Main function
int main() {
    srand(static_cast<unsigned>(time(0))); // Seed for random number generation

    vector<Ant> ants;
    int numAnts = 10;
    int startX = 0, startY = 0;
    int goalX = WIDTH - 1, goalY = HEIGHT - 1;

    // Initialize ants
    for (int i = 0; i < numAnts; ++i) {
        ants.emplace_back(startX, startY);
    }

    // Simulation loop
    for (int step = 0; step < 100; ++step) {
        cout << "Step " << step + 1 << ":" << endl;
        for (auto& ant : ants) {
            ant.move();
            cout << "Ant at (" << ant.x << ", " << ant.y << ")" << endl;
        }

        // Check if any ant reached the goal
        bool goalReached = false;
        for (const auto& ant : ants) {
            if (ant.x == goalX && ant.y == goalY) {
                goalReached = true;
                break;
            }
        }

        if (goalReached) {
            cout << "An ant has reached the goal!" << endl;
            break;
        }

        cout << endl;
    }

    return 0;
}

#include <iostream>

#include <vector>

#include <cstdlib>

#include <ctime>

#include <algorithm>

using namespace std;

// Grid dimensions

const int WIDTH = 10;

const int HEIGHT = 10;

// Directions for movement (right, down, left, up)

const int dx[] = {0, 1, 0, -1};

const int dy[] = {1, 0, -1, 0};

// Ant class

class Ant {

public:

int x, y;

Ant(int startX, int startY) : x(startX), y(startY) {}

void move() {

int direction = rand() % 4;

x += dx[direction];

y += dy[direction];

x = max(0, min(WIDTH - 1, x));

y = max(0, min(HEIGHT - 1, y));

}

};

// Main function

int main() {

srand(static_cast<unsigned>(time(0))); // Seed for random number generation

vector<Ant> ants;

int numAnts = 10;

int startX = 0, startY = 0;

int goalX = WIDTH - 1, goalY = HEIGHT - 1;

// Initialize ants

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

ants.emplace_back(startX, startY);

}

// Simulation loop

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

cout << "Step " << step + 1 << ":" << endl;

for (auto& ant : ants) {

ant.move();

cout << "Ant at (" << ant.x << ", " << ant.y << ")" << endl;

}

// Check if any ant reached the goal

bool goalReached = false;

for (const auto& ant : ants) {

if (ant.x == goalX && ant.y == goalY) {

goalReached = true;

break;

}

if (goalReached) {

cout << "An ant has reached the goal!" << endl;

break;

}

cout << endl;

}

return 0;

}

Explanation Headers: <iostream>: For input and output operations. <vector>: For using the std::vector container to store ants. <cstdlib>: For rand() and srand() functions. <ctime>: For time() function to seed the random number generator. <algorithm>: For the max and min functions. Constants: WIDTH and HEIGHT: Dimensions of the grid. dx and dy: Arrays representing possible …

Simulation of Ant Colony Optimization Gaming Project in C++ Read More »

Simulation of Aircraft Flight Gaming Project in C++

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

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

using namespace std;

// Function to update aircraft position
void updatePosition(float& x, float& y, float throttle, float direction) {
    x += throttle * cos(direction); // Update x based on throttle and direction
    y += throttle * sin(direction); // Update y based on throttle and direction
}

int main() {
    float x = 0.0f; // Initial x position
    float y = 0.0f; // Initial y position
    float throttle = 0.0f; // Throttle (speed)
    float direction = 0.0f; // Direction in radians
    char command;

    cout << "Aircraft Flight Simulation" << endl;
    cout << "Use 'w' to increase throttle, 's' to decrease throttle" << endl;
    cout << "'a' to turn left, 'd' to turn right, and 'q' to quit" << endl;

    while (true) {
        cout << fixed << setprecision(2); // Set precision for position output
        cout << "Position: (" << x << ", " << y << ") | Throttle: " << throttle
             << " | Direction: " << direction << " radians" << endl;
        cout << "Enter command: ";
        cin >> command;

        switch (command) {
            case 'w': // Increase throttle
                throttle += 0.1f;
                break;
            case 's': // Decrease throttle
                throttle = max(0.0f, throttle - 0.1f); // Throttle can't be negative
                break;
            case 'a': // Turn left
                direction -= 0.1f; // Turn left by decreasing direction
                break;
            case 'd': // Turn right
                direction += 0.1f; // Turn right by increasing direction
                break;
            case 'q': // Quit simulation
                cout << "Quitting simulation..." << endl;
                return 0;
            default:
                cout << "Invalid command. Please try again." << endl;
                break;
        }

        // Update position based on throttle and direction
        updatePosition(x, y, throttle, direction);

        // Sleep to simulate real-time movement
        this_thread::sleep_for(chrono::milliseconds(100));
    }

    return 0;
}

#include <iostream>

#include <iomanip>

#include <thread>

#include <chrono>

using namespace std;

// Function to update aircraft position

void updatePosition(float& x, float& y, float throttle, float direction) {

x += throttle * cos(direction); // Update x based on throttle and direction

y += throttle * sin(direction); // Update y based on throttle and direction

}

int main() {

float x = 0.0f; // Initial x position

float y = 0.0f; // Initial y position

float throttle = 0.0f; // Throttle (speed)

float direction = 0.0f; // Direction in radians

char command;

cout << "Aircraft Flight Simulation" << endl;

cout << "Use 'w' to increase throttle, 's' to decrease throttle" << endl;

cout << "'a' to turn left, 'd' to turn right, and 'q' to quit" << endl;

while (true) {

cout << fixed << setprecision(2); // Set precision for position output

cout << "Position: (" << x << ", " << y << ") | Throttle: " << throttle

<< " | Direction: " << direction << " radians" << endl;

cout << "Enter command: ";

cin >> command;

switch (command) {

case 'w': // Increase throttle

throttle += 0.1f;

break;

case 's': // Decrease throttle

throttle = max(0.0f, throttle - 0.1f); // Throttle can't be negative

break;

case 'a': // Turn left

direction -= 0.1f; // Turn left by decreasing direction

break;

case 'd': // Turn right

direction += 0.1f; // Turn right by increasing direction

break;

case 'q': // Quit simulation

cout << "Quitting simulation..." << endl;

return 0;

default:

cout << "Invalid command. Please try again." << endl;

break;

}

// Update position based on throttle and direction

updatePosition(x, y, throttle, direction);

// Sleep to simulate real-time movement

this_thread::sleep_for(chrono::milliseconds(100));

}

return 0;

}

Explanation Headers: <iostream>: For input and output operations. <iomanip>: For formatting the output precision. <thread>: For using this_thread::sleep_for() to simulate real-time movement. <chrono>: For time duration used in sleep_for(). Function Definitions: void updatePosition(float& x, float& y, float throttle, float direction): Updates the position of the aircraft based on the throttle and direction. Parameters: x: …

Simulation of Aircraft Flight Gaming Project in C++ Read More »

Simulation of 3D Printing Process Gaming Project in C++

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

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

using namespace std;

// Function to simulate printing a layer
void printLayer(int layer) {
    cout << "Printing layer " << layer << "..." << endl;
    this_thread::sleep_for(chrono::milliseconds(500)); // Simulate time taken to print a layer
}

int main() {
    int totalLayers = 10; // Total number of layers to print

    cout << "Starting 3D printing simulation..." << endl;

    for (int i = 1; i <= totalLayers; ++i) {
        printLayer(i);
    }

    cout << "3D printing simulation completed." << endl;

    return 0;
}

#include <iostream>

#include <thread>

#include <chrono>

using namespace std;

// Function to simulate printing a layer

void printLayer(int layer) {

cout << "Printing layer " << layer << "..." << endl;

this_thread::sleep_for(chrono::milliseconds(500)); // Simulate time taken to print a layer

}

int main() {

int totalLayers = 10; // Total number of layers to print

cout << "Starting 3D printing simulation..." << endl;

for (int i = 1; i <= totalLayers; ++i) {

printLayer(i);

}

cout << "3D printing simulation completed." << endl;

return 0;

}

Explanation Headers: <iostream>: For input and output operations. <thread>: For using this_thread::sleep_for() to simulate time delays. <chrono>: For time duration used in sleep_for(). Function Definitions: void printLayer(int layer): Simulates the printing of a single layer. Prints the message indicating the current layer being printed. this_thread::sleep_for(chrono::milliseconds(500));: Simulates a delay of 500 milliseconds to represent the …

Simulation of 3D Printing Process Gaming Project in C++ Read More »