Squirrel Simulation In C++

A squirrel, multiple nuts, and a tree are present. A two-dimensional grid's cells represent positions. Ultimately, we want to determine the shortest path possible for the squirrel to travel to gather each nut and place it under the tree individually. With the ability to move in four directions (up, down, left, and right) to the adjacent cell, the squirrel can only take one nut at a time. It is the number of moves that represents the distance.

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 represent specific squirrels in the simulation, define a class called Squirrel.

Features for energy, appetite, and social behavior should be present in every squirrel.

In order to set these attributes' maximum values at initialization, implement a constructor.

Provide techniques to mimic food gathering and to update the squirrel's condition in real-time.

• ✅ Environment class:

In order to manage the simulation environment, define an Environment class.

Have a vector included so that you can store more squirrels in the surroundings.

Introduce squirrels into the environment by putting a plan into action.

In the environment, where squirrels search for food and update their states, create a function that simulates a day.

Simulation Implementation:

An instance of the Environment class should be created in the main function. Increase the environment's squirrel count by a few.

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 us take an example to illustrate 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