Squirrel Simulation In C++

A squirrel, several nuts, and a tree are in the vicinity. The positions on a grid are depicted by cells in two dimensions. The main objective is to find the most efficient route for the squirrel to collect each nut and store it beneath the tree one by one. Moving in four directions (up, down, left, and right) to an adjacent cell, the squirrel is restricted to carrying just one nut at a time. The distance is determined by the total number of moves made.

Key features:

There are several features of the Squirrel simulation in C++. Some main features are as follows:

• ✅ Modeling the Environment: A virtual setting that resembles a squirrel's usual home will be included in the simulation. There will be grass, bushes, trees, and other materials necessary for squirrel life in this habitat.
• ✅ Squirrels attributes: A squirrel's hunger, energy, health, and social behavior are just a few of the characteristics that each squirrel in the simulation will have. The squirrel's choices and behavior during the simulation will be influenced by these characteristics.
• ✅ Behavioral Patterns: A squirrel's behavior can be characterized by a variety of behaviors, including constructing nests, avoiding predators, interacting with other squirrels, and foraging for nuts. These patterns will be added to make the simulation seem more realistic.

Requirements for the Code:

• ✅ Squirrel class:

To depict individual squirrels within the simulation, establish a class named Squirrel.

Characteristics related to energy levels, appetite, and social interactions are essential traits for all squirrels.

To establish the highest values for these attributes during initialization, incorporate a constructor.

Implement strategies to simulate the process of collecting food and to continuously monitor the squirrel's status in real-time.

• ✅ Environment class:

To oversee the simulation environment, establish a class named Environment.

Include a vector to expand the capacity for storing additional squirrels in the area.

Implement a strategy to introduce squirrels into the ecosystem.

In the setting where squirrels forage for sustenance and adjust their conditions, develop a function that mimics a full day.

Simulation Implementation:

Instantiate an object of the Environment class within the main function. Increment the number of squirrels in the environment by a small amount.

Select the relevant method to call and simulate a day in the environment.

• ✅ Randomness: Use the library to add some unpredictability to the simulation. Use a random number generator to replicate the quantity of food discovered while foraging.
• ✅ Output: Print pertinent information to the console to show how the simulation is progressing.
• ✅ After every simulation step, show the amount of food found during foraging and the squirrels' levels of hunger and energy.

Example:

Let's consider a scenario to demonstrate the Squirrel Simulation in C++.

#include <iostream>
#include <vector>
#include <ctime>
#include <random>

// Constants
const int MAX_ENERGY = 100;
const int MAX_HUNGER = 100;
const int MAX_SOCIAL = 100;

// Random number generator
std::mt19937 rng(time(nullptr));

// Class representing a Squirrel
class Squirrel {
private:
    int energy;
    int hunger;
    int social;

public:
    Squirrel() : energy(MAX_ENERGY), hunger(MAX_HUNGER), social(MAX_SOCIAL) {}

    // Function to simulate foraging for food
    void forage() {
        // Simulate foraging - reduces hunger and consumes energy
        int foodFound = rng() % 20 + 1; // Random amount of food found
        hunger -= foodFound;
        energy -= foodFound / 2;

        // Output for demonstration
        std::cout << "Squirrel foraged for " << foodFound << " units of food.\n";
    }

    // Function to update squirrel's state over time
    void update() {
        // Simulate energy and hunger depletion over time
        energy -= 1;
        hunger += 1;

        // Output for demonstration
        std::cout << "Squirrel's energy: " << energy << ", hunger: " << hunger << std::endl;
    }
};

// Class representing the environment
class Environment {
private:
    std::vector<Squirrel> squirrels;

public:
    // Function to add squirrels to the environment
    void addSquirrel(const Squirrel& squirrel) {
        squirrels.push_back(squirrel);
    }

    // Function to simulate a day in the environment
    void simulateDay() {
        // Simulate behaviors for each squirrel
        for (Squirrel& squirrel : squirrels) {
            squirrel.forage(); // Squirrels forage for food
            squirrel.update(); // Update squirrel's state
        }
    }
};

int main() {
    // Create an environment
    Environment environment;

    // Add some squirrels to the environment
    for (int i = 0; i < 3; ++i) {
        environment.addSquirrel(Squirrel());
    }

    // Simulate a day in the environment
    environment.simulateDay();

    return 0;
}

Output:

Squirrel foraged for 6 units of food.
Squirrel's energy: 96, hunger: 95
Squirrel foraged for 17 units of food.
Squirrel's energy: 91, hunger: 84
Squirrel foraged for 17 units of food.
Squirrel's energy: 91, hunger: 84