C++ Projects – Page 19 – Projects Inventory

Digital Signal Processing (DSP) Basics Gaming Project in C++

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

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

using namespace std;

// Function to generate a sine wave signal
vector<double> generateSineWave(double frequency, double sampleRate, int numSamples) {
    vector<double> signal(numSamples);
    double angularFrequency = 2.0 * M_PI * frequency;

    for (int i = 0; i < numSamples; ++i) {
        signal[i] = sin(angularFrequency * i / sampleRate);
    }

    return signal;
}

// Function to apply a simple low-pass filter
vector<double> lowPassFilter(const vector<double>& signal, double alpha) {
    vector<double> filteredSignal(signal.size());
    filteredSignal[0] = signal[0];

    for (size_t i = 1; i < signal.size(); ++i) {
        filteredSignal[i] = alpha * signal[i] + (1 - alpha) * filteredSignal[i - 1];
    }

    return filteredSignal;
}

// Function to print the signal
void printSignal(const vector<double>& signal) {
    for (double sample : signal) {
        cout << sample << endl;
    }
}

int main() {
    double frequency = 5.0;      // Frequency of the sine wave (Hz)
    double sampleRate = 100.0;   // Sample rate (samples per second)
    int numSamples = 100;        // Number of samples

    // Generate a sine wave
    vector<double> sineWave = generateSineWave(frequency, sampleRate, numSamples);

    // Apply a low-pass filter
    double alpha = 0.1; // Smoothing factor for the low-pass filter
    vector<double> filteredSignal = lowPassFilter(sineWave, alpha);

    // Print the original and filtered signals
    cout << "Original Sine Wave:" << endl;
    printSignal(sineWave);

    cout << "\nFiltered Signal:" << endl;
    printSignal(filteredSignal);

    return 0;
}

#include <iostream>

#include <vector>

#include <cmath>

using namespace std;

// Function to generate a sine wave signal

vector<double> generateSineWave(double frequency, double sampleRate, int numSamples) {

vector<double> signal(numSamples);

double angularFrequency = 2.0 * M_PI * frequency;

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

signal[i] = sin(angularFrequency * i / sampleRate);

}

return signal;

}

// Function to apply a simple low-pass filter

vector<double> lowPassFilter(const vector<double>& signal, double alpha) {

vector<double> filteredSignal(signal.size());

filteredSignal[0] = signal[0];

for (size_t i = 1; i < signal.size(); ++i) {

filteredSignal[i] = alpha * signal[i] + (1 - alpha) * filteredSignal[i - 1];

}

return filteredSignal;

}

// Function to print the signal

void printSignal(const vector<double>& signal) {

for (double sample : signal) {

cout << sample << endl;

}

int main() {

double frequency = 5.0; // Frequency of the sine wave (Hz)

double sampleRate = 100.0; // Sample rate (samples per second)

int numSamples = 100; // Number of samples

// Generate a sine wave

vector<double> sineWave = generateSineWave(frequency, sampleRate, numSamples);

// Apply a low-pass filter

double alpha = 0.1; // Smoothing factor for the low-pass filter

vector<double> filteredSignal = lowPassFilter(sineWave, alpha);

// Print the original and filtered signals

cout << "Original Sine Wave:" << endl;

printSignal(sineWave);

cout << "\nFiltered Signal:" << endl;

printSignal(filteredSignal);

return 0;

}

Explanation: Sine Wave Generation (generateSineWave): The generateSineWave function generates a sine wave signal based on a specified frequency, sample rate, and number of samples. It calculates each sample using the sine function, sin(2 * pi * frequency * i / sampleRate), where i is the sample index. The function returns a vector containing the …

Digital Signal Processing (DSP) Basics Gaming Project in C++ Read More »

Digital Clock Gaming Project in C++

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

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

using namespace std;

void displayTime(int hours, int minutes, int seconds) {
    // Clears the screen (works on most consoles)
    system("clear"); // Use "cls" for Windows
    
    // Display the time in HH:MM:SS format
    cout << setfill('0') << setw(2) << hours << ":"
         << setfill('0') << setw(2) << minutes << ":"
         << setfill('0') << setw(2) << seconds << endl;
}

int main() {
    while (true) {
        // Get the current time from the system
        time_t now = time(0);
        tm *ltm = localtime(&now);

        int hours = ltm->tm_hour;
        int minutes = ltm->tm_min;
        int seconds = ltm->tm_sec;

        // Display the time
        displayTime(hours, minutes, seconds);

        // Wait for one second
        this_thread::sleep_for(chrono::seconds(1));
    }

    return 0;
}

#include <iostream>

#include <iomanip>

#include <ctime>

#include <chrono>

#include <thread>

using namespace std;

void displayTime(int hours, int minutes, int seconds) {

// Clears the screen (works on most consoles)

system("clear"); // Use "cls" for Windows

// Display the time in HH:MM:SS format

cout << setfill('0') << setw(2) << hours << ":"

<< setfill('0') << setw(2) << minutes << ":"

<< setfill('0') << setw(2) << seconds << endl;

}

int main() {

while (true) {

// Get the current time from the system

time_t now = time(0);

tm *ltm = localtime(&now);

int hours = ltm->tm_hour;

int minutes = ltm->tm_min;

int seconds = ltm->tm_sec;

// Display the time

displayTime(hours, minutes, seconds);

// Wait for one second

this_thread::sleep_for(chrono::seconds(1));

}

return 0;

}

Explanation: Getting the Current Time: The program uses the C++ standard library to get the current time from the system. The time(0) function returns the current time in seconds since the Epoch (January 1, 1970). The localtime() function converts this time into a tm structure, which contains the current time broken down into components …

Digital Clock Gaming Project in C++ Read More »

Database Connectivity (SQLite) Gaming Project in C++

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

#include <iostream>
#include <sqlite3.h>

using namespace std;

class Database {
public:
    Database(const string& dbName);
    ~Database();
    void createTable();
    void insertData(const string& playerName, int score);
    void displayData();

private:
    sqlite3* db;
    string dbName;

    static int callback(void* NotUsed, int argc, char** argv, char** azColName);
    void executeSQL(const string& sql);
};

Database::Database(const string& dbName) : db(nullptr), dbName(dbName) {
    if (sqlite3_open(dbName.c_str(), &db)) {
        cerr << "Can't open database: " << sqlite3_errmsg(db) << endl;
        exit(1);
    } else {
        cout << "Opened database successfully" << endl;
    }
}

Database::~Database() {
    if (db) {
        sqlite3_close(db);
        cout << "Closed database successfully" << endl;
    }
}

void Database::createTable() {
    string sql = "CREATE TABLE IF NOT EXISTS SCORES("
                 "ID INTEGER PRIMARY KEY AUTOINCREMENT,"
                 "PLAYER_NAME TEXT NOT NULL,"
                 "SCORE INT NOT NULL);";

    executeSQL(sql);
    cout << "Table created successfully" << endl;
}

void Database::insertData(const string& playerName, int score) {
    string sql = "INSERT INTO SCORES (PLAYER_NAME, SCORE) VALUES ('" + playerName + "', " + to_string(score) + ");";
    executeSQL(sql);
    cout << "Data inserted successfully" << endl;
}

void Database::displayData() {
    string sql = "SELECT * FROM SCORES;";
    executeSQL(sql);
}

int Database::callback(void* NotUsed, int argc, char** argv, char** azColName) {
    for (int i = 0; i < argc; i++) {
        cout << azColName[i] << ": " << (argv[i] ? argv[i] : "NULL") << endl;
    }
    cout << endl;
    return 0;
}

void Database::executeSQL(const string& sql) {
    char* errMsg = 0;
    int rc = sqlite3_exec(db, sql.c_str(), callback, 0, &errMsg);
    if (rc != SQLITE_OK) {
        cerr << "SQL error: " << errMsg << endl;
        sqlite3_free(errMsg);
    }
}

int main() {
    Database db("game_scores.db");

    db.createTable();
    db.insertData("Player1", 100);
    db.insertData("Player2", 150);
    db.insertData("Player3", 200);

    cout << "Displaying data:" << endl;
    db.displayData();

    return 0;
}

#include <iostream>

#include <sqlite3.h>

using namespace std;

class Database {

public:

Database(const string& dbName);

~Database();

void createTable();

void insertData(const string& playerName, int score);

void displayData();

private:

sqlite3* db;

string dbName;

static int callback(void* NotUsed, int argc, char** argv, char** azColName);

void executeSQL(const string& sql);

};

Database::Database(const string& dbName) : db(nullptr), dbName(dbName) {

if (sqlite3_open(dbName.c_str(), &db)) {

cerr << "Can't open database: " << sqlite3_errmsg(db) << endl;

exit(1);

} else {

cout << "Opened database successfully" << endl;

}

Database::~Database() {

if (db) {

sqlite3_close(db);

cout << "Closed database successfully" << endl;

}

void Database::createTable() {

string sql = "CREATE TABLE IF NOT EXISTS SCORES("

"ID INTEGER PRIMARY KEY AUTOINCREMENT,"

"PLAYER_NAME TEXT NOT NULL,"

"SCORE INT NOT NULL);";

executeSQL(sql);

cout << "Table created successfully" << endl;

}

void Database::insertData(const string& playerName, int score) {

string sql = "INSERT INTO SCORES (PLAYER_NAME, SCORE) VALUES ('" + playerName + "', " + to_string(score) + ");";

executeSQL(sql);

cout << "Data inserted successfully" << endl;

}

void Database::displayData() {

string sql = "SELECT * FROM SCORES;";

executeSQL(sql);

}

int Database::callback(void* NotUsed, int argc, char** argv, char** azColName) {

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

cout << azColName[i] << ": " << (argv[i] ? argv[i] : "NULL") << endl;

}

cout << endl;

return 0;

}

void Database::executeSQL(const string& sql) {

char* errMsg = 0;

int rc = sqlite3_exec(db, sql.c_str(), callback, 0, &errMsg);

if (rc != SQLITE_OK) {

cerr << "SQL error: " << errMsg << endl;

sqlite3_free(errMsg);

}

int main() {

Database db("game_scores.db");

db.createTable();

db.insertData("Player1", 100);

db.insertData("Player2", 150);

db.insertData("Player3", 200);

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

db.displayData();

return 0;

}

Explanation: SQLite3 Integration: The program uses the SQLite3 library to handle database operations. Make sure to link the SQLite library during compilation (e.g., -lsqlite3). Database Class: The Database class encapsulates all the SQLite-related functionality, including connecting to the database, creating tables, inserting data, and retrieving data. Constructor & Destructor: The constructor opens the SQLite …

Database Connectivity (SQLite) Gaming Project in C++ Read More »

Currency Converter Gaming Project in C++

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

#include <iostream>
#include <iomanip>
#include <map>
#include <string>

using namespace std;

class CurrencyConverter {
public:
    CurrencyConverter();
    void convertCurrency();

private:
    map<string, double> exchangeRates;

    void displayCurrencies();
    double getExchangeRate(const string& fromCurrency, const string& toCurrency);
};

CurrencyConverter::CurrencyConverter() {
    // Initialize exchange rates (example rates)
    exchangeRates["USD"] = 1.0;      // Base currency
    exchangeRates["EUR"] = 0.85;     // 1 USD = 0.85 EUR
    exchangeRates["GBP"] = 0.75;     // 1 USD = 0.75 GBP
    exchangeRates["INR"] = 74.00;    // 1 USD = 74.00 INR
    exchangeRates["JPY"] = 110.00;   // 1 USD = 110.00 JPY
}

void CurrencyConverter::displayCurrencies() {
    cout << "Available Currencies:" << endl;
    for (const auto& pair : exchangeRates) {
        cout << pair.first << endl;
    }
}

double CurrencyConverter::getExchangeRate(const string& fromCurrency, const string& toCurrency) {
    return exchangeRates[toCurrency] / exchangeRates[fromCurrency];
}

void CurrencyConverter::convertCurrency() {
    string fromCurrency, toCurrency;
    double amount;

    cout << "Welcome to the Currency Converter!" << endl;
    displayCurrencies();

    cout << "Enter the currency you want to convert from (e.g., USD): ";
    cin >> fromCurrency;

    cout << "Enter the currency you want to convert to (e.g., EUR): ";
    cin >> toCurrency;

    cout << "Enter the amount in " << fromCurrency << ": ";
    cin >> amount;

    if (exchangeRates.find(fromCurrency) != exchangeRates.end() &&
        exchangeRates.find(toCurrency) != exchangeRates.end()) {
        double rate = getExchangeRate(fromCurrency, toCurrency);
        double convertedAmount = amount * rate;

        cout << fixed << setprecision(2);
        cout << amount << " " << fromCurrency << " is equal to " 
             << convertedAmount << " " << toCurrency << endl;
    } else {
        cout << "Invalid currency entered. Please try again." << endl;
    }
}

int main() {
    CurrencyConverter converter;
    char choice;

    do {
        converter.convertCurrency();
        cout << "Do you want to perform another conversion? (y/n): ";
        cin >> choice;
    } while (choice == 'y' || choice == 'Y');

    cout << "Thank you for using the Currency Converter!" << endl;
    return 0;
}

#include <iostream>

#include <iomanip>

#include <map>

#include <string>

using namespace std;

class CurrencyConverter {

public:

CurrencyConverter();

void convertCurrency();

private:

map<string, double> exchangeRates;

void displayCurrencies();

double getExchangeRate(const string& fromCurrency, const string& toCurrency);

};

CurrencyConverter::CurrencyConverter() {

// Initialize exchange rates (example rates)

exchangeRates["USD"] = 1.0; // Base currency

exchangeRates["EUR"] = 0.85; // 1 USD = 0.85 EUR

exchangeRates["GBP"] = 0.75; // 1 USD = 0.75 GBP

exchangeRates["INR"] = 74.00; // 1 USD = 74.00 INR

exchangeRates["JPY"] = 110.00; // 1 USD = 110.00 JPY

}

void CurrencyConverter::displayCurrencies() {

cout << "Available Currencies:" << endl;

for (const auto& pair : exchangeRates) {

cout << pair.first << endl;

}

double CurrencyConverter::getExchangeRate(const string& fromCurrency, const string& toCurrency) {

return exchangeRates[toCurrency] / exchangeRates[fromCurrency];

}

void CurrencyConverter::convertCurrency() {

string fromCurrency, toCurrency;

double amount;

cout << "Welcome to the Currency Converter!" << endl;

displayCurrencies();

cout << "Enter the currency you want to convert from (e.g., USD): ";

cin >> fromCurrency;

cout << "Enter the currency you want to convert to (e.g., EUR): ";

cin >> toCurrency;

cout << "Enter the amount in " << fromCurrency << ": ";

cin >> amount;

if (exchangeRates.find(fromCurrency) != exchangeRates.end() &&

exchangeRates.find(toCurrency) != exchangeRates.end()) {

double rate = getExchangeRate(fromCurrency, toCurrency);

double convertedAmount = amount * rate;

cout << fixed << setprecision(2);

cout << amount << " " << fromCurrency << " is equal to "

<< convertedAmount << " " << toCurrency << endl;

} else {

cout << "Invalid currency entered. Please try again." << endl;

}

int main() {

CurrencyConverter converter;

char choice;

do {

converter.convertCurrency();

cout << "Do you want to perform another conversion? (y/n): ";

cin >> choice;

} while (choice == 'y' || choice == 'Y');

cout << "Thank you for using the Currency Converter!" << endl;

return 0;

}

Explanation: Class Definition (CurrencyConverter): The CurrencyConverter class manages the exchange rates and handles the conversion process. Exchange Rates Initialization: The constructor initializes a map of exchange rates, where each currency code (e.g., “USD”, “EUR”) maps to its exchange rate relative to a base currency (USD in this case). Currency Display (displayCurrencies): The displayCurrencies method …

Currency Converter Gaming Project in C++ Read More »

Connect Four Game Gaming Project in C++

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

#include <iostream>
#include <vector>

using namespace std;

class ConnectFour {
public:
    ConnectFour();
    void playGame();

private:
    vector<vector<char>> board;
    int rows, cols;
    char currentPlayer;

    void printBoard();
    bool makeMove(int col);
    bool checkWin(int row, int col);
    bool checkDirection(int startX, int startY, int dirX, int dirY);
    bool isFull();
};

ConnectFour::ConnectFour() : rows(6), cols(7), currentPlayer('X') {
    board.resize(rows, vector<char>(cols, '.'));
}

void ConnectFour::printBoard() {
    for (int i = 0; i < rows; ++i) {
        for (int j = 0; j < cols; ++j) {
            cout << board[i][j] << " ";
        }
        cout << endl;
    }
    cout << endl;
}

bool ConnectFour::makeMove(int col) {
    if (col < 0 || col >= cols || board[0][col] != '.') {
        cout << "Invalid move. Try again." << endl;
        return false;
    }

    for (int i = rows - 1; i >= 0; --i) {
        if (board[i][col] == '.') {
            board[i][col] = currentPlayer;
            if (checkWin(i, col)) {
                printBoard();
                cout << "Player " << currentPlayer << " wins!" << endl;
                return true;
            }
            currentPlayer = (currentPlayer == 'X') ? 'O' : 'X';
            return false;
        }
    }

    return false;
}

bool ConnectFour::checkWin(int row, int col) {
    return checkDirection(row, col, 1, 0) || // Horizontal
           checkDirection(row, col, 0, 1) || // Vertical
           checkDirection(row, col, 1, 1) || // Diagonal /
           checkDirection(row, col, 1, -1);  // Diagonal \
}

bool ConnectFour::checkDirection(int startX, int startY, int dirX, int dirY) {
    int count = 0;

    for (int i = -3; i <= 3; ++i) {
        int x = startX + i * dirX;
        int y = startY + i * dirY;

        if (x >= 0 && x < rows && y >= 0 && y < cols && board[x][y] == currentPlayer) {
            count++;
            if (count == 4) return true;
        } else {
            count = 0;
        }
    }

    return false;
}

bool ConnectFour::isFull() {
    for (int i = 0; i < cols; ++i) {
        if (board[0][i] == '.') return false;
    }
    return true;
}

void ConnectFour::playGame() {
    int col;
    bool gameWon = false;

    cout << "Welcome to Connect Four!" << endl;

    while (!gameWon && !isFull()) {
        printBoard();
        cout << "Player " << currentPlayer << ", enter the column (0-" << cols-1 << ") to drop your piece: ";
        cin >> col;

        gameWon = makeMove(col);
    }

    if (!gameWon) {
        printBoard();
        cout << "The game is a draw!" << endl;
    }
}

int main() {
    ConnectFour game;
    game.playGame();
    return 0;
}

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

#include <iostream>

#include <vector>

using namespace std;

class ConnectFour {

public:

ConnectFour();

void playGame();

private:

vector<vector<char>> board;

int rows, cols;

char currentPlayer;

void printBoard();

bool makeMove(int col);

bool checkWin(int row, int col);

bool checkDirection(int startX, int startY, int dirX, int dirY);

bool isFull();

};

ConnectFour::ConnectFour() : rows(6), cols(7), currentPlayer('X') {

board.resize(rows, vector<char>(cols, '.'));

}

void ConnectFour::printBoard() {

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

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

cout << board[i][j] << " ";

}

cout << endl;

}

cout << endl;

}

bool ConnectFour::makeMove(int col) {

if (col < 0 || col >= cols || board[0][col] != '.') {

cout << "Invalid move. Try again." << endl;

return false;

}

for (int i = rows - 1; i >= 0; --i) {

if (board[i][col] == '.') {

board[i][col] = currentPlayer;

if (checkWin(i, col)) {

printBoard();

cout << "Player " << currentPlayer << " wins!" << endl;

return true;

}

currentPlayer = (currentPlayer == 'X') ? 'O' : 'X';

return false;

}

return false;

}

bool ConnectFour::checkWin(int row, int col) {

return checkDirection(row, col, 1, 0) || // Horizontal

checkDirection(row, col, 0, 1) || // Vertical

checkDirection(row, col, 1, 1) || // Diagonal /

checkDirection(row, col, 1, -1); // Diagonal \

}

bool ConnectFour::checkDirection(int startX, int startY, int dirX, int dirY) {

int count = 0;

for (int i = -3; i <= 3; ++i) {

int x = startX + i * dirX;

int y = startY + i * dirY;

if (x >= 0 && x < rows && y >= 0 && y < cols && board[x][y] == currentPlayer) {

count++;

if (count == 4) return true;

} else {

count = 0;

}

return false;

}

bool ConnectFour::isFull() {

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

if (board[0][i] == '.') return false;

}

return true;

}

void ConnectFour::playGame() {

int col;

bool gameWon = false;

cout << "Welcome to Connect Four!" << endl;

while (!gameWon && !isFull()) {

printBoard();

cout << "Player " << currentPlayer << ", enter the column (0-" << cols-1 << ") to drop your piece: ";

cin >> col;

gameWon = makeMove(col);

}

if (!gameWon) {

printBoard();

cout << "The game is a draw!" << endl;

}

int main() {

ConnectFour game;

game.playGame();

return 0;

}

Explanation: Class Definition (ConnectFour): The ConnectFour class manages the game, including the game board, player moves, and win condition checks. Board Initialization: The board is initialized as a 6×7 grid filled with dots (‘.’), representing empty slots. The currentPlayer is set to ‘X’, meaning player X starts the game. Board Printing (printBoard): The printBoard …

Connect Four Game Gaming Project in C++ Read More »

Color Detection Gaming Project in C++

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

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

using namespace std;

// Struct to represent a color
struct Color {
    string name;
    int id;
};

// Function to generate a random color
Color generateRandomColor(const vector<Color>& colors) {
    int index = rand() % colors.size();
    return colors[index];
}

// Function to get the player's guess
int getPlayerGuess() {
    int guess;
    cout << "Enter the color ID you think it is: ";
    cin >> guess;
    return guess;
}

// Function to display the available colors
void displayColors(const vector<Color>& colors) {
    cout << "Available colors:" << endl;
    for (const auto& color : colors) {
        cout << color.id << ": " << color.name << endl;
    }
}

// Main function
int main() {
    srand(time(0));

    // Define a set of colors
    vector<Color> colors = {
        {"Red", 1},
        {"Green", 2},
        {"Blue", 3},
        {"Yellow", 4},
        {"Orange", 5},
        {"Purple", 6}
    };

    cout << "Welcome to the Color Detection Game!" << endl;
    displayColors(colors);

    Color correctColor = generateRandomColor(colors);

    int attempts = 0;
    bool isCorrect = false;

    while (!isCorrect && attempts < 3) {  // Limit the number of attempts to 3
        int guess = getPlayerGuess();
        attempts++;

        if (guess == correctColor.id) {
            isCorrect = true;
            cout << "Congratulations! You guessed the color correctly. It was " << correctColor.name << "!" << endl;
        } else {
            cout << "Incorrect guess. Try again!" << endl;
        }
    }

    if (!isCorrect) {
        cout << "Sorry, you're out of attempts. The correct color was " << correctColor.name << "." << endl;
    }

    return 0;
}

#include <iostream>

#include <vector>

#include <cstdlib>

#include <ctime>

using namespace std;

// Struct to represent a color

struct Color {

string name;

int id;

};

// Function to generate a random color

Color generateRandomColor(const vector<Color>& colors) {

int index = rand() % colors.size();

return colors[index];

}

// Function to get the player's guess

int getPlayerGuess() {

int guess;

cout << "Enter the color ID you think it is: ";

cin >> guess;

return guess;

}

// Function to display the available colors

void displayColors(const vector<Color>& colors) {

cout << "Available colors:" << endl;

for (const auto& color : colors) {

cout << color.id << ": " << color.name << endl;

}

// Main function

int main() {

srand(time(0));

// Define a set of colors

vector<Color> colors = {

{"Red", 1},

{"Green", 2},

{"Blue", 3},

{"Yellow", 4},

{"Orange", 5},

{"Purple", 6}

};

cout << "Welcome to the Color Detection Game!" << endl;

displayColors(colors);

Color correctColor = generateRandomColor(colors);

int attempts = 0;

bool isCorrect = false;

while (!isCorrect && attempts < 3) { // Limit the number of attempts to 3

int guess = getPlayerGuess();

attempts++;

if (guess == correctColor.id) {

isCorrect = true;

cout << "Congratulations! You guessed the color correctly. It was " << correctColor.name << "!" << endl;

} else {

cout << "Incorrect guess. Try again!" << endl;

}

if (!isCorrect) {

cout << "Sorry, you're out of attempts. The correct color was " << correctColor.name << "." << endl;

}

return 0;

}

Explanation: Color Representation: The Color struct represents a color with a name (e.g., “Red”) and an id (a unique integer corresponding to that color). Random Color Generation: The generateRandomColor function selects a random color from a predefined list of colors. This color is the one that the player needs to guess. Player Guess: The …

Color Detection Gaming Project in C++ Read More »

Code Breaker Game Gaming Project in C++

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

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

using namespace std;

// Function to generate a random code
vector<int> generateCode(int length, int maxDigit) {
    vector<int> code(length);
    for (int i = 0; i < length; ++i) {
        code[i] = rand() % maxDigit + 1;
    }
    return code;
}

// Function to get a guess from the player
vector<int> getPlayerGuess(int length) {
    vector<int> guess(length);
    cout << "Enter your guess (separate digits with spaces): ";
    for (int i = 0; i < length; ++i) {
        cin >> guess[i];
    }
    return guess;
}

// Function to compare the guess with the code and give feedback
pair<int, int> compareGuess(const vector<int>& code, const vector<int>& guess) {
    int correctPosition = 0;
    int correctNumber = 0;
    vector<bool> codeChecked(code.size(), false);
    vector<bool> guessChecked(guess.size(), false);

    // Check for correct numbers in the correct position
    for (int i = 0; i < code.size(); ++i) {
        if (code[i] == guess[i]) {
            correctPosition++;
            codeChecked[i] = true;
            guessChecked[i] = true;
        }
    }

    // Check for correct numbers in the wrong position
    for (int i = 0; i < code.size(); ++i) {
        if (!codeChecked[i]) {
            for (int j = 0; j < guess.size(); ++j) {
                if (!guessChecked[j] && code[i] == guess[j]) {
                    correctNumber++;
                    guessChecked[j] = true;
                    break;
                }
            }
        }
    }

    return {correctPosition, correctNumber};
}

// Main function
int main() {
    srand(time(0));
    
    const int codeLength = 4;
    const int maxDigit = 6;
    const int maxAttempts = 10;

    vector<int> code = generateCode(codeLength, maxDigit);
    bool isGuessed = false;

    cout << "Welcome to the Code Breaker Game!" << endl;
    cout << "Guess the " << codeLength << "-digit code. Each digit is between 1 and " << maxDigit << "." << endl;

    for (int attempt = 1; attempt <= maxAttempts; ++attempt) {
        cout << "\nAttempt " << attempt << " of " << maxAttempts << ":" << endl;
        vector<int> guess = getPlayerGuess(codeLength);

        pair<int, int> feedback = compareGuess(code, guess);

        cout << "Correct numbers in the correct position: " << feedback.first << endl;
        cout << "Correct numbers in the wrong position: " << feedback.second << endl;

        if (feedback.first == codeLength) {
            isGuessed = true;
            break;
        }
    }

    if (isGuessed) {
        cout << "Congratulations! You guessed the code!" << endl;
    } else {
        cout << "Sorry, you've run out of attempts. The code was: ";
        for (int digit : code) {
            cout << digit << " ";
        }
        cout << endl;
    }

    return 0;
}

#include <iostream>

#include <vector>

#include <cstdlib>

#include <ctime>

using namespace std;

// Function to generate a random code

vector<int> generateCode(int length, int maxDigit) {

vector<int> code(length);

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

code[i] = rand() % maxDigit + 1;

}

return code;

}

// Function to get a guess from the player

vector<int> getPlayerGuess(int length) {

vector<int> guess(length);

cout << "Enter your guess (separate digits with spaces): ";

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

cin >> guess[i];

}

return guess;

}

// Function to compare the guess with the code and give feedback

pair<int, int> compareGuess(const vector<int>& code, const vector<int>& guess) {

int correctPosition = 0;

int correctNumber = 0;

vector<bool> codeChecked(code.size(), false);

vector<bool> guessChecked(guess.size(), false);

// Check for correct numbers in the correct position

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

if (code[i] == guess[i]) {

correctPosition++;

codeChecked[i] = true;

guessChecked[i] = true;

}

// Check for correct numbers in the wrong position

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

if (!codeChecked[i]) {

for (int j = 0; j < guess.size(); ++j) {

if (!guessChecked[j] && code[i] == guess[j]) {

correctNumber++;

guessChecked[j] = true;

break;

}

return {correctPosition, correctNumber};

}

// Main function

int main() {

srand(time(0));

const int codeLength = 4;

const int maxDigit = 6;

const int maxAttempts = 10;

vector<int> code = generateCode(codeLength, maxDigit);

bool isGuessed = false;

cout << "Welcome to the Code Breaker Game!" << endl;

cout << "Guess the " << codeLength << "-digit code. Each digit is between 1 and " << maxDigit << "." << endl;

for (int attempt = 1; attempt <= maxAttempts; ++attempt) {

cout << "\nAttempt " << attempt << " of " << maxAttempts << ":" << endl;

vector<int> guess = getPlayerGuess(codeLength);

pair<int, int> feedback = compareGuess(code, guess);

cout << "Correct numbers in the correct position: " << feedback.first << endl;

cout << "Correct numbers in the wrong position: " << feedback.second << endl;

if (feedback.first == codeLength) {

isGuessed = true;

break;

}

if (isGuessed) {

cout << "Congratulations! You guessed the code!" << endl;

} else {

cout << "Sorry, you've run out of attempts. The code was: ";

for (int digit : code) {

cout << digit << " ";

}

cout << endl;

}

return 0;

}

Explanation: Code Generation: The function generateCode creates a random sequence of digits of a specified length. Each digit ranges between 1 and maxDigit. This sequence represents the secret code that the player must guess. Player Guess: The function getPlayerGuess prompts the player to input a guess. The guess is a sequence of digits of …

Code Breaker Game Gaming Project in C++ Read More »

Chess Game Gaming Project in C++

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

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

using namespace std;

// Enum for piece types and colors
enum PieceType { EMPTY, PAWN, ROOK, KNIGHT, BISHOP, QUEEN, KING };
enum PieceColor { NONE, WHITE, BLACK };

// Struct for a chess piece
struct Piece {
    PieceType type;
    PieceColor color;
};

// Class for the chess board
class ChessBoard {
public:
    ChessBoard();
    void printBoard();
    bool movePiece(int startX, int startY, int endX, int endY);
    bool isCheckmate(PieceColor color);

private:
    vector<vector<Piece>> board;
    bool isValidMove(int startX, int startY, int endX, int endY);
    bool isCheck(PieceColor color);
};

// Constructor to initialize the chess board
ChessBoard::ChessBoard() {
    board.resize(8, vector<Piece>(8, { EMPTY, NONE }));

    // Place pawns
    for (int i = 0; i < 8; ++i) {
        board[1][i] = { PAWN, WHITE };
        board[6][i] = { PAWN, BLACK };
    }

    // Place rooks
    board[0][0] = board[0][7] = { ROOK, WHITE };
    board[7][0] = board[7][7] = { ROOK, BLACK };

    // Place knights
    board[0][1] = board[0][6] = { KNIGHT, WHITE };
    board[7][1] = board[7][6] = { KNIGHT, BLACK };

    // Place bishops
    board[0][2] = board[0][5] = { BISHOP, WHITE };
    board[7][2] = board[7][5] = { BISHOP, BLACK };

    // Place queens
    board[0][3] = { QUEEN, WHITE };
    board[7][3] = { QUEEN, BLACK };

    // Place kings
    board[0][4] = { KING, WHITE };
    board[7][4] = { KING, BLACK };
}

// Function to print the chess board
void ChessBoard::printBoard() {
    for (int i = 7; i >= 0; --i) {
        for (int j = 0; j < 8; ++j) {
            char pieceChar = '.';
            switch (board[i][j].type) {
                case PAWN: pieceChar = (board[i][j].color == WHITE) ? 'P' : 'p'; break;
                case ROOK: pieceChar = (board[i][j].color == WHITE) ? 'R' : 'r'; break;
                case KNIGHT: pieceChar = (board[i][j].color == WHITE) ? 'N' : 'n'; break;
                case BISHOP: pieceChar = (board[i][j].color == WHITE) ? 'B' : 'b'; break;
                case QUEEN: pieceChar = (board[i][j].color == WHITE) ? 'Q' : 'q'; break;
                case KING: pieceChar = (board[i][j].color == WHITE) ? 'K' : 'k'; break;
                default: break;
            }
            cout << pieceChar << " ";
        }
        cout << endl;
    }
}

// Function to move a piece from one position to another
bool ChessBoard::movePiece(int startX, int startY, int endX, int endY) {
    if (isValidMove(startX, startY, endX, endY)) {
        board[endX][endY] = board[startX][startY];
        board[startX][startY] = { EMPTY, NONE };
        return true;
    }
    return false;
}

// Function to check if a move is valid (simplified)
bool ChessBoard::isValidMove(int startX, int startY, int endX, int endY) {
    // For simplicity, only checks if the destination is empty or has an opponent's piece
    if (startX < 0 || startX >= 8 || startY < 0 || startY >= 8 || endX < 0 || endX >= 8 || endY < 0 || endY >= 8)
        return false;

    Piece startPiece = board[startX][startY];
    Piece endPiece = board[endX][endY];

    if (startPiece.type == EMPTY || startPiece.color == NONE)
        return false;

    if (endPiece.type != EMPTY && startPiece.color == endPiece.color)
        return false;

    // For simplicity, assume all moves are valid (you can add specific rules for each piece)
    return true;
}

// Function to check if the current player is in checkmate (simplified)
bool ChessBoard::isCheckmate(PieceColor color) {
    // Simplified: Assume checkmate if the king of the given color is in check
    return isCheck(color);
}

// Function to check if the current player is in check (simplified)
bool ChessBoard::isCheck(PieceColor color) {
    // Simplified: Assume the king is in check if an opponent's piece can move to the king's position
    return false; // Replace with actual check logic
}

// Main function
int main() {
    ChessBoard game;
    game.printBoard();

    // Example moves
    game.movePiece(1, 4, 3, 4); // White pawn moves forward
    game.movePiece(6, 4, 4, 4); // Black pawn moves forward
    game.printBoard();

    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

#include <iostream>

#include <vector>

#include <string>

using namespace std;

// Enum for piece types and colors

enum PieceType { EMPTY, PAWN, ROOK, KNIGHT, BISHOP, QUEEN, KING };

enum PieceColor { NONE, WHITE, BLACK };

// Struct for a chess piece

struct Piece {

PieceType type;

PieceColor color;

};

// Class for the chess board

class ChessBoard {

public:

ChessBoard();

void printBoard();

bool movePiece(int startX, int startY, int endX, int endY);

bool isCheckmate(PieceColor color);

private:

vector<vector<Piece>> board;

bool isValidMove(int startX, int startY, int endX, int endY);

bool isCheck(PieceColor color);

};

// Constructor to initialize the chess board

ChessBoard::ChessBoard() {

board.resize(8, vector<Piece>(8, { EMPTY, NONE }));

// Place pawns

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

board[1][i] = { PAWN, WHITE };

board[6][i] = { PAWN, BLACK };

}

// Place rooks

board[0][0] = board[0][7] = { ROOK, WHITE };

board[7][0] = board[7][7] = { ROOK, BLACK };

// Place knights

board[0][1] = board[0][6] = { KNIGHT, WHITE };

board[7][1] = board[7][6] = { KNIGHT, BLACK };

// Place bishops

board[0][2] = board[0][5] = { BISHOP, WHITE };

board[7][2] = board[7][5] = { BISHOP, BLACK };

// Place queens

board[0][3] = { QUEEN, WHITE };

board[7][3] = { QUEEN, BLACK };

// Place kings

board[0][4] = { KING, WHITE };

board[7][4] = { KING, BLACK };

}

// Function to print the chess board

void ChessBoard::printBoard() {

for (int i = 7; i >= 0; --i) {

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

char pieceChar = '.';

switch (board[i][j].type) {

case PAWN: pieceChar = (board[i][j].color == WHITE) ? 'P' : 'p'; break;

case ROOK: pieceChar = (board[i][j].color == WHITE) ? 'R' : 'r'; break;

case KNIGHT: pieceChar = (board[i][j].color == WHITE) ? 'N' : 'n'; break;

case BISHOP: pieceChar = (board[i][j].color == WHITE) ? 'B' : 'b'; break;

case QUEEN: pieceChar = (board[i][j].color == WHITE) ? 'Q' : 'q'; break;

case KING: pieceChar = (board[i][j].color == WHITE) ? 'K' : 'k'; break;

default: break;

}

cout << pieceChar << " ";

}

cout << endl;

}

// Function to move a piece from one position to another

bool ChessBoard::movePiece(int startX, int startY, int endX, int endY) {

if (isValidMove(startX, startY, endX, endY)) {

board[endX][endY] = board[startX][startY];

board[startX][startY] = { EMPTY, NONE };

return true;

}

return false;

}

// Function to check if a move is valid (simplified)

bool ChessBoard::isValidMove(int startX, int startY, int endX, int endY) {

// For simplicity, only checks if the destination is empty or has an opponent's piece

if (startX < 0 || startX >= 8 || startY < 0 || startY >= 8 || endX < 0 || endX >= 8 || endY < 0 || endY >= 8)

return false;

Piece startPiece = board[startX][startY];

Piece endPiece = board[endX][endY];

if (startPiece.type == EMPTY || startPiece.color == NONE)

return false;

if (endPiece.type != EMPTY && startPiece.color == endPiece.color)

return false;

// For simplicity, assume all moves are valid (you can add specific rules for each piece)

return true;

}

// Function to check if the current player is in checkmate (simplified)

bool ChessBoard::isCheckmate(PieceColor color) {

// Simplified: Assume checkmate if the king of the given color is in check

return isCheck(color);

}

// Function to check if the current player is in check (simplified)

bool ChessBoard::isCheck(PieceColor color) {

// Simplified: Assume the king is in check if an opponent's piece can move to the king's position

return false; // Replace with actual check logic

}

// Main function

int main() {

ChessBoard game;

game.printBoard();

// Example moves

game.movePiece(1, 4, 3, 4); // White pawn moves forward

game.movePiece(6, 4, 4, 4); // Black pawn moves forward

game.printBoard();

return 0;

}

Explanation: Piece Structure: The Piece struct represents a chess piece with a type (e.g., pawn, rook, etc.) and a color (white or black). ChessBoard Class: The ChessBoard class manages the game board, checks move validity, and provides functions for printing the board and making moves. Board Initialization: The constructor initializes the board with the …

Chess Game Gaming Project in C++ Read More »

Calendar Application Gaming Project in C++

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

#include <iostream>
#include <iomanip>

using namespace std;

// Function to check if the year is a leap year
bool isLeapYear(int year) {
    if (year % 4 == 0) {
        if (year % 100 == 0) {
            if (year % 400 == 0)
                return true;
            else
                return false;
        } else
            return true;
    } else
        return false;
}

// Function to get the number of days in a month
int getDaysInMonth(int month, int year) {
    switch (month) {
        case 1: return 31; // January
        case 2: return isLeapYear(year) ? 29 : 28; // February
        case 3: return 31; // March
        case 4: return 30; // April
        case 5: return 31; // May
        case 6: return 30; // June
        case 7: return 31; // July
        case 8: return 31; // August
        case 9: return 30; // September
        case 10: return 31; // October
        case 11: return 30; // November
        case 12: return 31; // December
        default: return 0;
    }
}

// Function to calculate the day of the week for the 1st of a month
int getStartDay(int month, int year) {
    int day = 1; // First day of the month
    int century = year / 100;
    int yearInCentury = year % 100;
    if (month == 1 || month == 2) {
        month += 12;
        yearInCentury--;
    }
    int dayOfWeek = (day + (13 * (month + 1)) / 5 + yearInCentury + yearInCentury / 4 + century / 4 + 5 * century) % 7;
    return (dayOfWeek + 5) % 7; // Adjusting to start from Monday
}

// Function to display the calendar for a given month and year
void displayCalendar(int month, int year) {
    string months[] = {"January", "February", "March", "April", "May", "June", "July", "August", "September", "October", "November", "December"};
    cout << "\n   " << months[month - 1] << " " << year << "\n";
    cout << " Mo Tu We Th Fr Sa Su\n";

    int daysInMonth = getDaysInMonth(month, year);
    int startDay = getStartDay(month, year);

    // Print leading spaces for the first week
    for (int i = 0; i < startDay; i++)
        cout << "   ";

    for (int day = 1; day <= daysInMonth; day++) {
        cout << setw(2) << day << " ";
        if ((day + startDay) % 7 == 0)
            cout << "\n"; // New line after Sunday
    }
    cout << "\n";
}

int main() {
    int month, year;
    cout << "Enter month (1-12): ";
    cin >> month;
    cout << "Enter year: ";
    cin >> year;

    displayCalendar(month, year);

    return 0;
}

#include <iostream>

#include <iomanip>

using namespace std;

// Function to check if the year is a leap year

bool isLeapYear(int year) {

if (year % 4 == 0) {

if (year % 100 == 0) {

if (year % 400 == 0)

return true;

else

return false;

} else

return true;

} else

return false;

}

// Function to get the number of days in a month

int getDaysInMonth(int month, int year) {

switch (month) {

case 1: return 31; // January

case 2: return isLeapYear(year) ? 29 : 28; // February

case 3: return 31; // March

case 4: return 30; // April

case 5: return 31; // May

case 6: return 30; // June

case 7: return 31; // July

case 8: return 31; // August

case 9: return 30; // September

case 10: return 31; // October

case 11: return 30; // November

case 12: return 31; // December

default: return 0;

}

// Function to calculate the day of the week for the 1st of a month

int getStartDay(int month, int year) {

int day = 1; // First day of the month

int century = year / 100;

int yearInCentury = year % 100;

if (month == 1 || month == 2) {

month += 12;

yearInCentury--;

}

int dayOfWeek = (day + (13 * (month + 1)) / 5 + yearInCentury + yearInCentury / 4 + century / 4 + 5 * century) % 7;

return (dayOfWeek + 5) % 7; // Adjusting to start from Monday

}

// Function to display the calendar for a given month and year

void displayCalendar(int month, int year) {

string months[] = {"January", "February", "March", "April", "May", "June", "July", "August", "September", "October", "November", "December"};

cout << "\n " << months[month - 1] << " " << year << "\n";

cout << " Mo Tu We Th Fr Sa Su\n";

int daysInMonth = getDaysInMonth(month, year);

int startDay = getStartDay(month, year);

// Print leading spaces for the first week

for (int i = 0; i < startDay; i++)

cout << " ";

for (int day = 1; day <= daysInMonth; day++) {

cout << setw(2) << day << " ";

if ((day + startDay) % 7 == 0)

cout << "\n"; // New line after Sunday

}

cout << "\n";

}

int main() {

int month, year;

cout << "Enter month (1-12): ";

cin >> month;

cout << "Enter year: ";

cin >> year;

displayCalendar(month, year);

return 0;

}

Explanation: Leap Year Calculation: The function isLeapYear checks whether a given year is a leap year. A leap year occurs every 4 years, but years divisible by 100 are not leap years unless they are also divisible by 400. Days in a Month: The function getDaysInMonth returns the number of days in a particular …

Calendar Application Gaming Project in C++ Read More »

Caesar Cipher Gaming Project in C++

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

#include <iostream>
#include <string>

using namespace std;

// Function to encrypt a message using Caesar cipher
string encrypt(string plaintext, int shift) {
    string ciphertext = "";
    for (char c : plaintext) {
        if (isalpha(c)) { // Check if the character is a letter
            char base = islower(c) ? 'a' : 'A';
            char encryptedChar = (c - base + shift) % 26 + base;
            ciphertext += encryptedChar;
        } else {
            ciphertext += c; // Non-alphabetic characters remain unchanged
        }
    }
    return ciphertext;
}

// Function to decrypt a message using Caesar cipher
string decrypt(string ciphertext, int shift) {
    return encrypt(ciphertext, 26 - shift); // Decryption is just encryption with the inverse shift
}

int main() {
    string text;
    int shift;

    // Input plaintext and shift value
    cout << "Enter the text: ";
    getline(cin, text);
    cout << "Enter shift value (1-25): ";
    cin >> shift;

    // Validate shift value
    if (shift < 1 || shift > 25) {
        cerr << "Error: Shift value must be between 1 and 25." << endl;
        return 1;
    }

    // Encrypt the text
    string encryptedText = encrypt(text, shift);
    cout << "Encrypted text: " << encryptedText << endl;

    // Decrypt the text
    string decryptedText = decrypt(encryptedText, shift);
    cout << "Decrypted text: " << decryptedText << endl;

    return 0;
}

#include <iostream>

#include <string>

using namespace std;

// Function to encrypt a message using Caesar cipher

string encrypt(string plaintext, int shift) {

string ciphertext = "";

for (char c : plaintext) {

if (isalpha(c)) { // Check if the character is a letter

char base = islower(c) ? 'a' : 'A';

char encryptedChar = (c - base + shift) % 26 + base;

ciphertext += encryptedChar;

} else {

ciphertext += c; // Non-alphabetic characters remain unchanged

}

return ciphertext;

}

// Function to decrypt a message using Caesar cipher

string decrypt(string ciphertext, int shift) {

return encrypt(ciphertext, 26 - shift); // Decryption is just encryption with the inverse shift

}

int main() {

string text;

int shift;

// Input plaintext and shift value

cout << "Enter the text: ";

getline(cin, text);

cout << "Enter shift value (1-25): ";

cin >> shift;

// Validate shift value

if (shift < 1 || shift > 25) {

cerr << "Error: Shift value must be between 1 and 25." << endl;

return 1;

}

// Encrypt the text

string encryptedText = encrypt(text, shift);

cout << "Encrypted text: " << encryptedText << endl;

// Decrypt the text

string decryptedText = decrypt(encryptedText, shift);

cout << "Decrypted text: " << decryptedText << endl;

return 0;

}

Explanation Include Libraries: #include <iostream>: For input and output operations. #include <string>: For using std::string. Encrypt Function: string encrypt(string plaintext, int shift): Encrypts the plaintext using the Caesar cipher. plaintext: The input string to be encrypted. shift: The number of positions each letter in the plaintext is shifted. Iterates over each character in plaintext: …

Caesar Cipher Gaming Project in C++ Read More »