C++ Projects – Page 11 – Projects Inventory

Simulation of Computer Graphics Techniques Gaming Project in C++

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

#include <SDL2/SDL.h>
#include <iostream>

// Screen dimensions
const int SCREEN_WIDTH = 800;
const int SCREEN_HEIGHT = 600;

// Function to initialize SDL and create a window
SDL_Window* initWindow(SDL_Renderer** renderer) {
    if (SDL_Init(SDL_INIT_VIDEO) < 0) {
        std::cerr << "SDL could not initialize! SDL_Error: " << SDL_GetError() << std::endl;
        return nullptr;
    }

    SDL_Window* window = SDL_CreateWindow("SDL2 Graphics Simulation", SDL_WINDOWPOS_UNDEFINED, SDL_WINDOWPOS_UNDEFINED, SCREEN_WIDTH, SCREEN_HEIGHT, SDL_WINDOW_SHOWN);
    if (window == nullptr) {
        std::cerr << "Window could not be created! SDL_Error: " << SDL_GetError() << std::endl;
        SDL_Quit();
        return nullptr;
    }

    *renderer = SDL_CreateRenderer(window, -1, SDL_RENDERER_ACCELERATED);
    if (*renderer == nullptr) {
        std::cerr << "Renderer could not be created! SDL_Error: " << SDL_GetError() << std::endl;
        SDL_DestroyWindow(window);
        SDL_Quit();
        return nullptr;
    }

    return window;
}

// Main function
int main() {
    SDL_Renderer* renderer = nullptr;
    SDL_Window* window = initWindow(&renderer);
    if (window == nullptr) {
        return 1;
    }

    // Main loop flag
    bool quit = false;
    SDL_Event e;

    // Main loop
    while (!quit) {
        while (SDL_PollEvent(&e) != 0) {
            if (e.type == SDL_QUIT) {
                quit = true;
            }
        }

        // Clear screen
        SDL_SetRenderDrawColor(renderer, 255, 255, 255, 255); // White background
        SDL_RenderClear(renderer);

        // Draw a red rectangle
        SDL_SetRenderDrawColor(renderer, 255, 0, 0, 255); // Red color
        SDL_Rect fillRect = { 100, 100, 200, 150 };
        SDL_RenderFillRect(renderer, &fillRect);

        // Draw a blue circle
        SDL_SetRenderDrawColor(renderer, 0, 0, 255, 255); // Blue color
        int centerX = 400, centerY = 300, radius = 100;
        for (int y = -radius; y <= radius; y++) {
            for (int x = -radius; x <= radius; x++) {
                if (x*x + y*y <= radius*radius) {
                    SDL_RenderDrawPoint(renderer, centerX + x, centerY + y);
                }
            }
        }

        // Update screen
        SDL_RenderPresent(renderer);
    }

    // Clean up
    SDL_DestroyRenderer(renderer);
    SDL_DestroyWindow(window);
    SDL_Quit();

    return 0;
}

#include <SDL2/SDL.h>

#include <iostream>

// Screen dimensions

const int SCREEN_WIDTH = 800;

const int SCREEN_HEIGHT = 600;

// Function to initialize SDL and create a window

SDL_Window* initWindow(SDL_Renderer** renderer) {

if (SDL_Init(SDL_INIT_VIDEO) < 0) {

std::cerr << "SDL could not initialize! SDL_Error: " << SDL_GetError() << std::endl;

return nullptr;

}

SDL_Window* window = SDL_CreateWindow("SDL2 Graphics Simulation", SDL_WINDOWPOS_UNDEFINED, SDL_WINDOWPOS_UNDEFINED, SCREEN_WIDTH, SCREEN_HEIGHT, SDL_WINDOW_SHOWN);

if (window == nullptr) {

std::cerr << "Window could not be created! SDL_Error: " << SDL_GetError() << std::endl;

SDL_Quit();

return nullptr;

}

*renderer = SDL_CreateRenderer(window, -1, SDL_RENDERER_ACCELERATED);

if (*renderer == nullptr) {

std::cerr << "Renderer could not be created! SDL_Error: " << SDL_GetError() << std::endl;

SDL_DestroyWindow(window);

SDL_Quit();

return nullptr;

}

return window;

}

// Main function

int main() {

SDL_Renderer* renderer = nullptr;

SDL_Window* window = initWindow(&renderer);

if (window == nullptr) {

return 1;

}

// Main loop flag

bool quit = false;

SDL_Event e;

// Main loop

while (!quit) {

while (SDL_PollEvent(&e) != 0) {

if (e.type == SDL_QUIT) {

quit = true;

}

// Clear screen

SDL_SetRenderDrawColor(renderer, 255, 255, 255, 255); // White background

SDL_RenderClear(renderer);

// Draw a red rectangle

SDL_SetRenderDrawColor(renderer, 255, 0, 0, 255); // Red color

SDL_Rect fillRect = { 100, 100, 200, 150 };

SDL_RenderFillRect(renderer, &fillRect);

// Draw a blue circle

SDL_SetRenderDrawColor(renderer, 0, 0, 255, 255); // Blue color

int centerX = 400, centerY = 300, radius = 100;

for (int y = -radius; y <= radius; y++) {

for (int x = -radius; x <= radius; x++) {

if (x*x + y*y <= radius*radius) {

SDL_RenderDrawPoint(renderer, centerX + x, centerY + y);

}

// Update screen

SDL_RenderPresent(renderer);

}

// Clean up

SDL_DestroyRenderer(renderer);

SDL_DestroyWindow(window);

SDL_Quit();

return 0;

}

Explanation: Initialization: initWindow(SDL_Renderer** renderer): Initializes SDL, creates a window, and sets up a renderer. Handles errors and prints messages if initialization fails. Main Function: Creates a window and renderer using initWindow(). Enters the main loop where it handles events (e.g., window close) and updates the graphics. Clears the screen with a white color. Draws …

Simulation of Computer Graphics Techniques Gaming Project in C++ Read More »

Simulation of Compiler Design Gaming Project in C++

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

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

// Token types
enum class TokenType {
    Number,
    Plus,
    Minus,
    Multiply,
    Divide,
    End,
    Invalid
};

// Token class
class Token {
public:
    Token(TokenType type, std::string value) : type(type), value(value) {}

    TokenType getType() const {
        return type;
    }

    std::string getValue() const {
        return value;
    }

private:
    TokenType type;
    std::string value;
};

// Lexer class
class Lexer {
public:
    Lexer(const std::string& input) : input(input), index(0) {}

    Token nextToken() {
        while (index < input.size() && std::isspace(input[index])) {
            ++index;
        }

        if (index >= input.size()) {
            return Token(TokenType::End, "");
        }

        char current = input[index];

        if (std::isdigit(current)) {
            std::string number;
            while (index < input.size() && std::isdigit(input[index])) {
                number += input[index++];
            }
            return Token(TokenType::Number, number);
        }

        switch (current) {
            case '+': ++index; return Token(TokenType::Plus, "+");
            case '-': ++index; return Token(TokenType::Minus, "-");
            case '*': ++index; return Token(TokenType::Multiply, "*");
            case '/': ++index; return Token(TokenType::Divide, "/");
            default: return Token(TokenType::Invalid, std::string(1, current));
        }
    }

private:
    std::string input;
    size_t index;
};

// Parser class
class Parser {
public:
    Parser(Lexer& lexer) : lexer(lexer), currentToken(lexer.nextToken()) {}

    void parse() {
        while (currentToken.getType() != TokenType::End) {
            if (currentToken.getType() == TokenType::Number) {
                std::cout << "Number: " << currentToken.getValue() << std::endl;
            } else {
                std::cout << "Operator: " << currentToken.getValue() << std::endl;
            }
            currentToken = lexer.nextToken();
        }
    }

private:
    Lexer& lexer;
    Token currentToken;
};

// Main function
int main() {
    std::string input = "10 + 20 * 30 - 40 / 2";
    Lexer lexer(input);
    Parser parser(lexer);

    std::cout << "Parsing input: " << input << std::endl;
    parser.parse();

    return 0;
}

100

101

102

103

104

#include <iostream>

#include <vector>

#include <string>

#include <cctype>

// Token types

enum class TokenType {

Number,

Plus,

Minus,

Multiply,

Divide,

End,

Invalid

};

// Token class

class Token {

public:

Token(TokenType type, std::string value) : type(type), value(value) {}

TokenType getType() const {

return type;

}

std::string getValue() const {

return value;

}

private:

TokenType type;

std::string value;

};

// Lexer class

class Lexer {

public:

Lexer(const std::string& input) : input(input), index(0) {}

Token nextToken() {

while (index < input.size() && std::isspace(input[index])) {

++index;

}

if (index >= input.size()) {

return Token(TokenType::End, "");

}

char current = input[index];

if (std::isdigit(current)) {

std::string number;

while (index < input.size() && std::isdigit(input[index])) {

number += input[index++];

}

return Token(TokenType::Number, number);

}

switch (current) {

case '+': ++index; return Token(TokenType::Plus, "+");

case '-': ++index; return Token(TokenType::Minus, "-");

case '*': ++index; return Token(TokenType::Multiply, "*");

case '/': ++index; return Token(TokenType::Divide, "/");

default: return Token(TokenType::Invalid, std::string(1, current));

}

private:

std::string input;

size_t index;

};

// Parser class

class Parser {

public:

Parser(Lexer& lexer) : lexer(lexer), currentToken(lexer.nextToken()) {}

void parse() {

while (currentToken.getType() != TokenType::End) {

if (currentToken.getType() == TokenType::Number) {

std::cout << "Number: " << currentToken.getValue() << std::endl;

} else {

std::cout << "Operator: " << currentToken.getValue() << std::endl;

}

currentToken = lexer.nextToken();

}

private:

Lexer& lexer;

Token currentToken;

};

// Main function

int main() {

std::string input = "10 + 20 * 30 - 40 / 2";

Lexer lexer(input);

Parser parser(lexer);

std::cout << "Parsing input: " << input << std::endl;

parser.parse();

return 0;

}

Explanation: TokenType Enum: Defines various token types like Number, Plus, Minus, etc. Token Class: Represents a token with a type and value. Token(TokenType type, std::string value): Constructor to initialize the token. getType() const: Returns the type of the token. getValue() const: Returns the value of the token. Lexer Class: Lexer(const std::string& input): Constructor to …

Simulation of Compiler Design Gaming Project in C++ Read More »

Simulation of CNC Machine Operation Gaming Project in C++

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

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

// Command class
class Command {
public:
    Command(const std::string& type, double parameter)
        : type(type), parameter(parameter) {}

    std::string getType() const {
        return type;
    }

    double getParameter() const {
        return parameter;
    }

private:
    std::string type;    // Type of operation (e.g., "Cut", "Drill")
    double parameter;    // Parameter for the operation (e.g., depth, diameter)
};

// CNC Machine class
class CNCMachine {
public:
    void addCommand(const Command& command) {
        commands.push_back(command);
    }

    void executeCommands() {
        for (const auto& command : commands) {
            std::cout << "Executing " << command.getType() 
                      << " with parameter: " << std::fixed << std::setprecision(2)
                      << command.getParameter() << std::endl;
        }
        commands.clear();
    }

private:
    std::vector<Command> commands; // List of commands to be executed
};

// Main function
int main() {
    CNCMachine cncMachine;

    // Adding commands to the CNC machine
    cncMachine.addCommand(Command("Cut", 15.0));   // Cut operation with depth 15.0
    cncMachine.addCommand(Command("Drill", 5.0));  // Drill operation with diameter 5.0
    cncMachine.addCommand(Command("Cut", 10.0));   // Another Cut operation with depth 10.0

    // Executing all commands
    std::cout << "Starting CNC machine operations..." << std::endl;
    cncMachine.executeCommands();

    return 0;
}

#include <iostream>

#include <vector>

#include <string>

#include <iomanip>

// Command class

class Command {

public:

Command(const std::string& type, double parameter)

: type(type), parameter(parameter) {}

std::string getType() const {

return type;

}

double getParameter() const {

return parameter;

}

private:

std::string type; // Type of operation (e.g., "Cut", "Drill")

double parameter; // Parameter for the operation (e.g., depth, diameter)

};

// CNC Machine class

class CNCMachine {

public:

void addCommand(const Command& command) {

commands.push_back(command);

}

void executeCommands() {

for (const auto& command : commands) {

std::cout << "Executing " << command.getType()

<< " with parameter: " << std::fixed << std::setprecision(2)

<< command.getParameter() << std::endl;

}

commands.clear();

}

private:

std::vector<Command> commands; // List of commands to be executed

};

// Main function

int main() {

CNCMachine cncMachine;

// Adding commands to the CNC machine

cncMachine.addCommand(Command("Cut", 15.0)); // Cut operation with depth 15.0

cncMachine.addCommand(Command("Drill", 5.0)); // Drill operation with diameter 5.0

cncMachine.addCommand(Command("Cut", 10.0)); // Another Cut operation with depth 10.0

// Executing all commands

std::cout << "Starting CNC machine operations..." << std::endl;

cncMachine.executeCommands();

return 0;

}

Explanation: Command Class: type: Represents the type of operation (e.g., “Cut”, “Drill”). parameter: Represents the parameter for the operation (e.g., depth for cutting, diameter for drilling). Command(const std::string& type, double parameter): Constructor to initialize the command. getType() const: Returns the type of the command. getParameter() const: Returns the parameter of the command. CNCMachine Class: …

Simulation of CNC Machine Operation Gaming Project in C++ Read More »

Simulation of Cloud Computing Gaming Project in C++

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

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

const int SERVER_CAPACITY = 5; // Number of tasks the server can handle at a time
const int TASK_COUNT = 20; // Number of tasks to be simulated

// Task class
class Task {
public:
    Task(int id) : id(id) {}

    int getId() const {
        return id;
    }

private:
    int id;
};

// CloudServer class
class CloudServer {
public:
    CloudServer(int capacity) : capacity(capacity), tasksProcessed(0) {}

    void addTask(const Task& task) {
        if (currentTasks.size() < capacity) {
            currentTasks.push(task);
            std::cout << "Added Task " << task.getId() << " to the server." << std::endl;
        } else {
            std::cout << "Server is at full capacity. Task " << task.getId() << " cannot be added." << std::endl;
        }
    }

    void processTasks() {
        while (!currentTasks.empty()) {
            Task task = currentTasks.front();
            currentTasks.pop();
            tasksProcessed++;
            std::cout << "Processed Task " << task.getId() << "." << std::endl;
        }
    }

    int getTasksProcessed() const {
        return tasksProcessed;
    }

private:
    int capacity;
    int tasksProcessed;
    std::queue<Task> currentTasks;
};

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

    CloudServer server(SERVER_CAPACITY);

    // Simulate adding tasks to the cloud server
    for (int i = 0; i < TASK_COUNT; ++i) {
        Task task(i + 1);
        server.addTask(task);
    }

    // Process all tasks in the server
    std::cout << "Processing tasks..." << std::endl;
    server.processTasks();

    std::cout << "Total tasks processed: " << server.getTasksProcessed() << std::endl;

    return 0;
}

#include <iostream>

#include <queue>

#include <vector>

#include <cstdlib>

#include <ctime>

const int SERVER_CAPACITY = 5; // Number of tasks the server can handle at a time

const int TASK_COUNT = 20; // Number of tasks to be simulated

// Task class

class Task {

public:

Task(int id) : id(id) {}

int getId() const {

return id;

}

private:

int id;

};

// CloudServer class

class CloudServer {

public:

CloudServer(int capacity) : capacity(capacity), tasksProcessed(0) {}

void addTask(const Task& task) {

if (currentTasks.size() < capacity) {

currentTasks.push(task);

std::cout << "Added Task " << task.getId() << " to the server." << std::endl;

} else {

std::cout << "Server is at full capacity. Task " << task.getId() << " cannot be added." << std::endl;

}

void processTasks() {

while (!currentTasks.empty()) {

Task task = currentTasks.front();

currentTasks.pop();

tasksProcessed++;

std::cout << "Processed Task " << task.getId() << "." << std::endl;

}

int getTasksProcessed() const {

return tasksProcessed;

}

private:

int capacity;

int tasksProcessed;

std::queue<Task> currentTasks;

};

// Main function

int main() {

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

CloudServer server(SERVER_CAPACITY);

// Simulate adding tasks to the cloud server

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

Task task(i + 1);

server.addTask(task);

}

// Process all tasks in the server

std::cout << "Processing tasks..." << std::endl;

server.processTasks();

std::cout << "Total tasks processed: " << server.getTasksProcessed() << std::endl;

return 0;

}

Explanation: Task Class: Represents a task with an id. Task(int id): Constructor to initialize the task with an ID. getId() const: Returns the ID of the task. CloudServer Class: capacity: Maximum number of tasks the server can handle simultaneously. tasksProcessed: Total number of tasks processed by the server. currentTasks: A queue of tasks currently …

Simulation of Cloud Computing Gaming Project in C++ Read More »

Simulation of Chemical Reactions Gaming Project in C++

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

#include <iostream>
#include <iomanip>

// Constants
const double INITIAL_A = 100.0; // Initial concentration of A
const double INITIAL_B = 50.0;  // Initial concentration of B
const double REACTION_RATE = 0.1; // Reaction rate constant
const double TIME_STEP = 0.1; // Time step for simulation
const int STEPS = 100; // Number of simulation steps

// ChemicalReaction class
class ChemicalReaction {
public:
    ChemicalReaction(double a, double b, double rate)
        : concentrationA(a), concentrationB(b), rate(rate) {}

    void simulateStep() {
        double deltaC = rate * concentrationA * concentrationB * TIME_STEP;
        concentrationA -= deltaC;
        concentrationB -= deltaC;
        concentrationC += deltaC;

        // Ensure concentrations do not go negative
        if (concentrationA < 0) concentrationA = 0;
        if (concentrationB < 0) concentrationB = 0;
    }

    void printStatus(double time) const {
        std::cout << "Time: " << std::fixed << std::setprecision(1) << time
                  << " A: " << std::fixed << std::setprecision(2) << concentrationA
                  << " B: " << std::fixed << std::setprecision(2) << concentrationB
                  << " C: " << std::fixed << std::setprecision(2) << concentrationC
                  << std::endl;
    }

private:
    double concentrationA; // Concentration of chemical A
    double concentrationB; // Concentration of chemical B
    double concentrationC = 0.0; // Concentration of chemical C (product)
    double rate; // Reaction rate constant
};

int main() {
    ChemicalReaction reaction(INITIAL_A, INITIAL_B, REACTION_RATE);

    std::cout << "Simulation of Chemical Reaction:" << std::endl;
    std::cout << "Initial Conditions:" << std::endl;
    reaction.printStatus(0.0);

    for (int step = 1; step <= STEPS; ++step) {
        reaction.simulateStep();
        double time = step * TIME_STEP;
        reaction.printStatus(time);
    }

    return 0;
}

#include <iostream>

#include <iomanip>

// Constants

const double INITIAL_A = 100.0; // Initial concentration of A

const double INITIAL_B = 50.0; // Initial concentration of B

const double REACTION_RATE = 0.1; // Reaction rate constant

const double TIME_STEP = 0.1; // Time step for simulation

const int STEPS = 100; // Number of simulation steps

// ChemicalReaction class

class ChemicalReaction {

public:

ChemicalReaction(double a, double b, double rate)

: concentrationA(a), concentrationB(b), rate(rate) {}

void simulateStep() {

double deltaC = rate * concentrationA * concentrationB * TIME_STEP;

concentrationA -= deltaC;

concentrationB -= deltaC;

concentrationC += deltaC;

// Ensure concentrations do not go negative

if (concentrationA < 0) concentrationA = 0;

if (concentrationB < 0) concentrationB = 0;

}

void printStatus(double time) const {

std::cout << "Time: " << std::fixed << std::setprecision(1) << time

<< " A: " << std::fixed << std::setprecision(2) << concentrationA

<< " B: " << std::fixed << std::setprecision(2) << concentrationB

<< " C: " << std::fixed << std::setprecision(2) << concentrationC

<< std::endl;

}

private:

double concentrationA; // Concentration of chemical A

double concentrationB; // Concentration of chemical B

double concentrationC = 0.0; // Concentration of chemical C (product)

double rate; // Reaction rate constant

};

int main() {

ChemicalReaction reaction(INITIAL_A, INITIAL_B, REACTION_RATE);

std::cout << "Simulation of Chemical Reaction:" << std::endl;

std::cout << "Initial Conditions:" << std::endl;

reaction.printStatus(0.0);

for (int step = 1; step <= STEPS; ++step) {

reaction.simulateStep();

double time = step * TIME_STEP;

reaction.printStatus(time);

}

return 0;

}

Explanation: ChemicalReaction Class: concentrationA: The current concentration of chemical A. concentrationB: The current concentration of chemical B. concentrationC: The current concentration of the product C. rate: The reaction rate constant. ChemicalReaction(double a, double b, double rate): Constructor to initialize the concentrations and rate. simulateStep(): Updates the concentrations based on the reaction rate and time …

Simulation of Chemical Reactions Gaming Project in C++ Read More »

Simulation of Chaotic Systems Gaming Project in C++

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

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

// Constants
const int ITERATIONS = 100;
const double INITIAL_VALUE = 0.5;
const double R_MIN = 2.5;
const double R_MAX = 4.0;
const double R_STEP = 0.1;

// LogisticMap class
class LogisticMap {
public:
    LogisticMap(double r, double initialValue)
        : r(r), x(initialValue) {}

    void iterate() {
        x = r * x * (1 - x);
    }

    double getValue() const {
        return x;
    }

private:
    double r; // Control parameter
    double x; // Current value
};

// Main function
int main() {
    std::vector<double> rValues;

    // Iterate over the range of r values
    for (double r = R_MIN; r <= R_MAX; r += R_STEP) {
        LogisticMap logisticMap(r, INITIAL_VALUE);

        std::cout << "r = " << std::fixed << std::setprecision(1) << r << ": ";
        
        // Generate and print the logistic map values
        for (int i = 0; i < ITERATIONS; ++i) {
            logisticMap.iterate();
            std::cout << logisticMap.getValue() << ' ';
        }
        
        std::cout << std::endl;
    }

    return 0;
}

#include <iostream>

#include <vector>

#include <iomanip>

// Constants

const int ITERATIONS = 100;

const double INITIAL_VALUE = 0.5;

const double R_MIN = 2.5;

const double R_MAX = 4.0;

const double R_STEP = 0.1;

// LogisticMap class

class LogisticMap {

public:

LogisticMap(double r, double initialValue)

: r(r), x(initialValue) {}

void iterate() {

x = r * x * (1 - x);

}

double getValue() const {

return x;

}

private:

double r; // Control parameter

double x; // Current value

};

// Main function

int main() {

std::vector<double> rValues;

// Iterate over the range of r values

for (double r = R_MIN; r <= R_MAX; r += R_STEP) {

LogisticMap logisticMap(r, INITIAL_VALUE);

std::cout << "r = " << std::fixed << std::setprecision(1) << r << ": ";

// Generate and print the logistic map values

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

logisticMap.iterate();

std::cout << logisticMap.getValue() << ' ';

}

std::cout << std::endl;

}

return 0;

}

Explanation: LogisticMap Class: r: The control parameter for the logistic map, which influences the chaotic behavior. x: The current value of the system, initialized with the initialValue. LogisticMap(double r, double initialValue): Constructor that sets the value of r and initializes x. iterate(): Updates the value of x using the logistic map formula xn+1=r⋅xn⋅(1−xn)x_{n+1} = …

Simulation of Chaotic Systems Gaming Project in C++ Read More »

Simulation of Cellular Automata Gaming Project in C++

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

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

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

// CellularAutomaton class
class CellularAutomaton {
public:
    std::vector<std::vector<bool>> grid;
    std::vector<std::vector<bool>> nextGrid;

    CellularAutomaton() : grid(HEIGHT, std::vector<bool>(WIDTH, false)),
                          nextGrid(HEIGHT, std::vector<bool>(WIDTH, false)) {}

    void setCell(int x, int y, bool alive) {
        if (x >= 0 && x < WIDTH && y >= 0 && y < HEIGHT) {
            grid[y][x] = alive;
        }
    }

    void printGrid() const {
        for (const auto& row : grid) {
            for (bool cell : row) {
                std::cout << (cell ? '*' : '.') << ' ';
            }
            std::cout << std::endl;
        }
        std::cout << std::endl;
    }

    void update() {
        for (int y = 0; y < HEIGHT; ++y) {
            for (int x = 0; x < WIDTH; ++x) {
                int aliveNeighbors = countAliveNeighbors(x, y);
                if (grid[y][x]) {
                    nextGrid[y][x] = (aliveNeighbors == 2 || aliveNeighbors == 3);
                } else {
                    nextGrid[y][x] = (aliveNeighbors == 3);
                }
            }
        }
        grid = nextGrid;
    }

private:
    int countAliveNeighbors(int x, int y) const {
        int count = 0;
        for (int dy = -1; dy <= 1; ++dy) {
            for (int dx = -1; dx <= 1; ++dx) {
                if (dx == 0 && dy == 0) continue;
                int nx = x + dx;
                int ny = y + dy;
                if (nx >= 0 && nx < WIDTH && ny >= 0 && ny < HEIGHT && grid[ny][nx]) {
                    ++count;
                }
            }
        }
        return count;
    }
};

int main() {
    CellularAutomaton automaton;

    // Initialize some cells
    automaton.setCell(4, 1, true);
    automaton.setCell(4, 2, true);
    automaton.setCell(4, 3, true);

    // Print initial state
    std::cout << "Initial State:" << std::endl;
    automaton.printGrid();

    // Update and print the grid multiple times
    for (int i = 0; i < 5; ++i) {
        automaton.update();
        std::cout << "Generation " << (i + 1) << ":" << std::endl;
        automaton.printGrid();
    }

    return 0;
}

#include <iostream>

#include <vector>

#include <iomanip>

const int WIDTH = 10;

const int HEIGHT = 10;

// CellularAutomaton class

class CellularAutomaton {

public:

std::vector<std::vector<bool>> grid;

std::vector<std::vector<bool>> nextGrid;

CellularAutomaton() : grid(HEIGHT, std::vector<bool>(WIDTH, false)),

nextGrid(HEIGHT, std::vector<bool>(WIDTH, false)) {}

void setCell(int x, int y, bool alive) {

if (x >= 0 && x < WIDTH && y >= 0 && y < HEIGHT) {

grid[y][x] = alive;

}

void printGrid() const {

for (const auto& row : grid) {

for (bool cell : row) {

std::cout << (cell ? '*' : '.') << ' ';

}

std::cout << std::endl;

}

std::cout << std::endl;

}

void update() {

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

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

int aliveNeighbors = countAliveNeighbors(x, y);

if (grid[y][x]) {

nextGrid[y][x] = (aliveNeighbors == 2 || aliveNeighbors == 3);

} else {

nextGrid[y][x] = (aliveNeighbors == 3);

}

grid = nextGrid;

}

private:

int countAliveNeighbors(int x, int y) const {

int count = 0;

for (int dy = -1; dy <= 1; ++dy) {

for (int dx = -1; dx <= 1; ++dx) {

if (dx == 0 && dy == 0) continue;

int nx = x + dx;

int ny = y + dy;

if (nx >= 0 && nx < WIDTH && ny >= 0 && ny < HEIGHT && grid[ny][nx]) {

++count;

}

return count;

}

};

int main() {

CellularAutomaton automaton;

// Initialize some cells

automaton.setCell(4, 1, true);

automaton.setCell(4, 2, true);

automaton.setCell(4, 3, true);

// Print initial state

std::cout << "Initial State:" << std::endl;

automaton.printGrid();

// Update and print the grid multiple times

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

automaton.update();

std::cout << "Generation " << (i + 1) << ":" << std::endl;

automaton.printGrid();

}

return 0;

}

Explanation: CellularAutomaton Class: grid: The current state of the grid, where each cell can be either true (alive) or false (dead). nextGrid: The grid that will hold the state of the cells after the update. setCell(int x, int y, bool alive): Sets the state of a specific cell. printGrid() const: Prints the current state …

Simulation of Cellular Automata Gaming Project in C++ Read More »

Simulation of Cache Memory Gaming Project in C++

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

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

const int CACHE_SIZE = 16; // Number of cache lines

// CacheLine class
class CacheLine {
public:
    int tag;
    bool valid;
    int data;

    CacheLine() : tag(-1), valid(false), data(0) {}
};

// Cache class
class Cache {
public:
    std::vector<CacheLine> lines;

    Cache() : lines(CACHE_SIZE) {}

    int read(int address) {
        int index = address % CACHE_SIZE;
        int tag = address / CACHE_SIZE;

        if (lines[index].valid && lines[index].tag == tag) {
            // Cache hit
            std::cout << "Cache hit: Address " << address << " -> Data " << lines[index].data << std::endl;
            return lines[index].data;
        } else {
            // Cache miss
            std::cout << "Cache miss: Address " << address << std::endl;
            return -1;
        }
    }

    void write(int address, int data) {
        int index = address % CACHE_SIZE;
        int tag = address / CACHE_SIZE;

        lines[index].tag = tag;
        lines[index].valid = true;
        lines[index].data = data;

        std::cout << "Writing data " << data << " to address " << address << std::endl;
    }
};

int main() {
    Cache cache;

    // Writing data to cache
    cache.write(10, 100);
    cache.write(26, 200); // This will replace data at address 10 due to direct-mapping

    // Reading data from cache
    cache.read(10); // This will be a cache miss
    cache.read(26); // This will be a cache hit

    return 0;
}

#include <iostream>

#include <vector>

#include <unordered_map>

const int CACHE_SIZE = 16; // Number of cache lines

// CacheLine class

class CacheLine {

public:

int tag;

bool valid;

int data;

CacheLine() : tag(-1), valid(false), data(0) {}

};

// Cache class

class Cache {

public:

std::vector<CacheLine> lines;

Cache() : lines(CACHE_SIZE) {}

int read(int address) {

int index = address % CACHE_SIZE;

int tag = address / CACHE_SIZE;

if (lines[index].valid && lines[index].tag == tag) {

// Cache hit

std::cout << "Cache hit: Address " << address << " -> Data " << lines[index].data << std::endl;

return lines[index].data;

} else {

// Cache miss

std::cout << "Cache miss: Address " << address << std::endl;

return -1;

}

void write(int address, int data) {

int index = address % CACHE_SIZE;

int tag = address / CACHE_SIZE;

lines[index].tag = tag;

lines[index].valid = true;

lines[index].data = data;

std::cout << "Writing data " << data << " to address " << address << std::endl;

}

};

int main() {

Cache cache;

// Writing data to cache

cache.write(10, 100);

cache.write(26, 200); // This will replace data at address 10 due to direct-mapping

// Reading data from cache

cache.read(10); // This will be a cache miss

cache.read(26); // This will be a cache hit

return 0;

}

Explanation: CacheLine Class: tag: Stores the tag part of the address. valid: Indicates if the cache line contains valid data. data: Stores the data. Cache Class: lines: A vector of CacheLine objects representing the cache lines. read(int address): Reads data from the cache. Checks if the data is valid and if the tag matches. …

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

Simulation of Business Analytics Gaming Project in C++

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

#include <iostream>
#include <vector>
#include <iomanip> // For std::fixed and std::setprecision

// Constants
const int MONTHS_IN_YEAR = 12;

// SalesData class
class SalesData {
public:
    std::vector<double> monthlySales;

    SalesData() : monthlySales(MONTHS_IN_YEAR, 0.0) {}

    void recordSale(int month, double amount) {
        if (month >= 1 && month <= MONTHS_IN_YEAR) {
            monthlySales[month - 1] += amount;
        } else {
            std::cerr << "Invalid month: " << month << std::endl;
        }
    }

    double totalSales() const {
        double total = 0.0;
        for (double sale : monthlySales) {
            total += sale;
        }
        return total;
    }

    double averageSales() const {
        return totalSales() / MONTHS_IN_YEAR;
    }

    void printSales() const {
        std::cout << "Monthly Sales Data:" << std::endl;
        for (int i = 0; i < MONTHS_IN_YEAR; ++i) {
            std::cout << "Month " << (i + 1) << ": $" << std::fixed << std::setprecision(2) << monthlySales[i] << std::endl;
        }
        std::cout << "Total Sales: $" << std::fixed << std::setprecision(2) << totalSales() << std::endl;
        std::cout << "Average Monthly Sales: $" << std::fixed << std::setprecision(2) << averageSales() << std::endl;
    }
};

int main() {
    SalesData sales;

    // Example sales data recording
    sales.recordSale(1, 5000.0); // January
    sales.recordSale(2, 4500.0); // February
    sales.recordSale(3, 6000.0); // March
    sales.recordSale(4, 7000.0); // April
    sales.recordSale(5, 6500.0); // May
    sales.recordSale(6, 8000.0); // June
    sales.recordSale(7, 7500.0); // July
    sales.recordSale(8, 9000.0); // August
    sales.recordSale(9, 8500.0); // September
    sales.recordSale(10, 9500.0); // October
    sales.recordSale(11, 10000.0); // November
    sales.recordSale(12, 11000.0); // December

    // Print out the sales data and statistics
    sales.printSales();

    return 0;
}

#include <iostream>

#include <vector>

#include <iomanip> // For std::fixed and std::setprecision

// Constants

const int MONTHS_IN_YEAR = 12;

// SalesData class

class SalesData {

public:

std::vector<double> monthlySales;

SalesData() : monthlySales(MONTHS_IN_YEAR, 0.0) {}

void recordSale(int month, double amount) {

if (month >= 1 && month <= MONTHS_IN_YEAR) {

monthlySales[month - 1] += amount;

} else {

std::cerr << "Invalid month: " << month << std::endl;

}

double totalSales() const {

double total = 0.0;

for (double sale : monthlySales) {

total += sale;

}

return total;

}

double averageSales() const {

return totalSales() / MONTHS_IN_YEAR;

}

void printSales() const {

std::cout << "Monthly Sales Data:" << std::endl;

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

std::cout << "Month " << (i + 1) << ": $" << std::fixed << std::setprecision(2) << monthlySales[i] << std::endl;

}

std::cout << "Total Sales: $" << std::fixed << std::setprecision(2) << totalSales() << std::endl;

std::cout << "Average Monthly Sales: $" << std::fixed << std::setprecision(2) << averageSales() << std::endl;

}

};

int main() {

SalesData sales;

// Example sales data recording

sales.recordSale(1, 5000.0); // January

sales.recordSale(2, 4500.0); // February

sales.recordSale(3, 6000.0); // March

sales.recordSale(4, 7000.0); // April

sales.recordSale(5, 6500.0); // May

sales.recordSale(6, 8000.0); // June

sales.recordSale(7, 7500.0); // July

sales.recordSale(8, 9000.0); // August

sales.recordSale(9, 8500.0); // September

sales.recordSale(10, 9500.0); // October

sales.recordSale(11, 10000.0); // November

sales.recordSale(12, 11000.0); // December

// Print out the sales data and statistics

sales.printSales();

return 0;

}

Explanation: SalesData Class: monthlySales: A vector to store sales data for each month. recordSale(int month, double amount): Records a sale for a given month. totalSales() const: Calculates the total sales for the year. averageSales() const: Calculates the average sales per month. printSales() const: Prints the sales data and statistics. Main Function: Creates a SalesData …

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

Simulation of Brownian Motion Gaming Project in C++

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

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

// Constants
const int WIDTH = 800;
const int HEIGHT = 600;
const int PARTICLE_COUNT = 100;
const float STEP_SIZE = 1.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);
    }

    void operator+=(const Vector2& v) {
        x += v.x;
        y += v.y;
    }

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

// Particle class
class Particle {
public:
    Vector2 position;

    Particle(float x, float y) : position(x, y) {}

    void move() {
        int direction = rand() % 4; // Random direction: 0 = up, 1 = down, 2 = left, 3 = right
        switch (direction) {
            case 0: position.y -= STEP_SIZE; break;
            case 1: position.y += STEP_SIZE; break;
            case 2: position.x -= STEP_SIZE; break;
            case 3: position.x += STEP_SIZE; break;
        }
        position.wrapAround();
    }
};

// Main simulation function
void simulate(std::vector<Particle>& particles) {
    for (auto& particle : particles) {
        particle.move();
    }
}

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

    std::vector<Particle> particles;
    for (int i = 0; i < PARTICLE_COUNT; ++i) {
        particles.emplace_back(rand() % WIDTH, rand() % HEIGHT);
    }

    while (true) {
        simulate(particles);

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

    return 0;
}

#include <iostream>

#include <vector>

#include <cstdlib>

#include <ctime>

#include <cmath>

// Constants

const int WIDTH = 800;

const int HEIGHT = 600;

const int PARTICLE_COUNT = 100;

const float STEP_SIZE = 1.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);

}

void operator+=(const Vector2& v) {

x += v.x;

y += v.y;

}

void wrapAround() {

if (x < 0) x += WIDTH;

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

if (y < 0) y += HEIGHT;

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

}

};

// Particle class

class Particle {

public:

Vector2 position;

Particle(float x, float y) : position(x, y) {}

void move() {

int direction = rand() % 4; // Random direction: 0 = up, 1 = down, 2 = left, 3 = right

switch (direction) {

case 0: position.y -= STEP_SIZE; break;

case 1: position.y += STEP_SIZE; break;

case 2: position.x -= STEP_SIZE; break;

case 3: position.x += STEP_SIZE; break;

}

position.wrapAround();

}

};

// Main simulation function

void simulate(std::vector<Particle>& particles) {

for (auto& particle : particles) {

particle.move();

}

int main() {

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

std::vector<Particle> particles;

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

particles.emplace_back(rand() % WIDTH, rand() % HEIGHT);

}

while (true) {

simulate(particles);

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

}

return 0;

}

Explanation: Vector2 Class: Represents a 2D vector with basic operations and a wrapAround() method to handle boundary conditions. Particle Class: Represents a particle with a position. The move() method randomly changes the particle’s position in one of four directions (up, down, left, right) and wraps around the screen edges if needed. simulate Function: Updates …

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