Q:

Advice on how to resolve this error.

Hello I am new fairly newly to C++ and I am constructing a program that will simulate a colony of bunnies. I am a bit stuck on how to resolve this issue on how to get methods to recognize my global pointer variables. I get this error when I try to compile my program. 
enter code here
main.cpp: In function ‘bool ageCheck(BunnyNode*)’:
main.cpp:133:5: error: ‘head’ was not declared in this scope
if(head){
   ^

I have several more errors that are similar to this one. I am under the impression that if I understand why this error is being given, I will be able to sort out the others. I chose an error from the ageCheck() method that is supposed to traverse the linked list of bunnies and check their ages.
This is what I have
enter code here
#include <iostream>
#include <string>
#include <vector>
#include <cstdlib>

//#include "listofbunny.h"

using std::cin;
using namespace std;

typedef struct BunnyNode {
    string* name;
    int age;
    bool gender;
    string* color;
    bool radioactive_bunny;
    BunnyNode *next;
    BunnyNode *head;
    BunnyNode *tail;
    BunnyNode *current;
}

char menu();
int randomGeneration(int x);
void generateFeatures(BunnyNode * newBunny);
void startCheck(int pass);
void sizeCheck(bool& terminate);
bool fatherCheck(BunnyNode * bunny, bool& fatherPresent);
bool motherCheck(BunnyNode * bunny);
bool ageCheck(BunnyNode * bunny);
void addBunnyAge();
void addBabyBunny();
void addBunny();
void addBunny(BunnyNode * mother);
int  mutantCount();
void mutantTransform();
void purge();
string getGender(BunnyNode * bunny);
string getName(BunnyNode * bunny);
int getColonySize();
void printColony();
void printFeature(BunnyNode * bunny);
void printSize();

bool ageCheck(BunnyNode * bunny){
    if(head){
        if(bunny->age >= MAX_AGE && bunny->radioactive_bunny == false){
            return 1;
        }
        else if(bunny->age >= MAX_MUTANT_AGE && bunny->radioactive_bunny){
            return 1;
        }
        else
            return 0;
    }
}

A:

A typical linked list structure is made of three parts
The Data
class Bunny
{
    string name; // don't use pointers unless you really, really need them
    int age;
    bool gender;
    string color;
    bool radioactive_bunny;
public:
    string getGender(); // don't need to know which Bunny anymore because 
                        // these functions are bound to a particular Bunny
    string getName();
    ...
};

The Node
struct Node
{
    Bunny data; // we will ignore templates for now. But they are rilly kool!
    Node * next; // here is a good time to use a pointer: to point to the next node
    Node(): next(nullptr) // node constructor. This really helps. Trust me.
    {
    }
}

Nodes know nothing except their data and a link to the next Node. The dumber you can make a Node, the safer you are. Also note that the Node contains the Data. This allows you to easily swap out the Data without having to re-write the whole node and sets you up for easy templating of the Lined List structure later (though you're probably better off jumping to std::list).
And the Linked List:
class LinkedList
{
    Node *head;
    Node *tail;
    Node *current; // not as useful as you might think
public:
    LinkedList(): head(nullptr),tail(nullptr),current(nullptr)
    {
    }
    void add(Bunny & bunny);
    void remove(const string & bunnyname);
    Bunny & get(const string & bunnyname);
    Bunny & getNext(); // current may help here, but look into iterators
    ...
};

Note that we never let the caller at a Node. They could do something stupid like delete it or mangle Node::next. 
Adding, removing and iterating through the list has been beaten to death on Stack Overflow, so you should be able to find tonnes of examples of how to do this. For example: Using pointers to remove item from singly-linked list. There is, in my opinion, a really important trick in that link well worth the time spent learning. Pointers are like fire: A handy servant, but a terrifying master.
The big trick to getting linked lists is use a pencil and paper to draw the list and the nodes. See how they are connected. Redraw the list step by step as you add, remove, etc... so you can see how it needs to be done. Then write code to match the drawings. I know. Easier said than done, but way easier than banging your head against a wall with no plan whatsoever.

