I'm totally at wit's end: I can't figure out how my dependency issues. I've read countless posts and blogs and reworked my code so many times that I can't even remember what almost worked and what didnt. I continually get not only redefinition errors, but class not defined errors. I rework the header guards and remove some errors simply to find others. I somehow got everything down to one error but then even that got broke while trying to fix it.

Would you please help me figure out the problem?

card.cpp

#include <iostream>
#include <cctype>
#include "card.h"

using namespace std;

// ====DECL======
Card::Card()
{
  abilities = 0;
  flavorText = 0;
  keywords = 0;
  artifact = 0;
  classType = new char[strlen("Card") + 1];
  classType = "Card";
}



Card::~Card (){
  delete name;
  delete abilities;
  delete flavorText;
  artifact = NULL;
}

   // ------------
Card::Card(const Card & to_copy)
{

  name = new char[strlen(to_copy.name) +1];         // creating dynamic array
  strcpy(to_copy.name, name);

  type = to_copy.type;
  color = to_copy.color;
  manaCost = to_copy.manaCost;

  abilities = new char[strlen(to_copy.abilities) +1];
  strcpy(abilities, to_copy.abilities);

  flavorText = new char[strlen(to_copy.flavorText) +1];
  strcpy(flavorText, to_copy.flavorText);

  keywords = new char[strlen(to_copy.keywords) +1];
  strcpy(keywords, to_copy.keywords);

  inPlay = to_copy.inPlay;
  tapped = to_copy.tapped;
  enchanted = to_copy.enchanted;
  cursed = to_copy.cursed;

  if (to_copy.type != ARTIFACT)
    artifact = to_copy.artifact;
 }

// ====DECL=====
int Card::equipArtifact(Artifact* to_equip){
  artifact = to_equip;
}

Artifact * Card::unequipArtifact(Card * unequip_from){
   Artifact * to_remove = artifact;
   artifact = NULL;
   return to_remove;
  // put card in hand or in graveyard
}

int Card::enchant( Card * to_enchant){
  to_enchant->enchanted = true;
  cout << "enchanted" << endl;
}

int Card::disenchant( Card * to_disenchant){
  to_disenchant->enchanted = false;
  cout << "Enchantment Removed" << endl;
}

// ========DECL=====
Spell::Spell()
{
  currPower = basePower;
  currToughness = baseToughness;
  classType = new char[strlen("Spell") + 1];
  classType = "Spell";

}

Spell::~Spell(){}

     // ---------------
Spell::Spell(const Spell & to_copy){
  currPower = to_copy.currPower;
  basePower = to_copy.basePower;
  currToughness = to_copy.currToughness;
  baseToughness = to_copy.baseToughness;
}

// =========
int Spell::attack( Spell *& blocker ){
  blocker->currToughness -= currPower;
  currToughness -= blocker->currToughness;
}

//==========
int Spell::counter (Spell *& to_counter){
  cout << to_counter->name << " was countered by " << name << endl;
}

// ============
int Spell::heal (Spell *& to_heal, int amountOfHealth){
  to_heal->currToughness += amountOfHealth;
}

// -------
Creature::Creature(){
 summoningSick = true;
}

// =====DECL======

Land::Land(){
  color = NON;
  classType = new char[strlen("Land") + 1];
  classType = "Land";
}

// ------

int Land::generateMana(int mana){
  // ... //  
}

card.h

#ifndef CARD_H
#define CARD_H
#include <cctype>
#include <iostream>
#include "conception.h"

class Artifact;
class Spell;


class Card : public Conception
{
  public:
   Card(); 
   Card(const Card &); 
  ~Card();

  protected:
    char* name;
    enum CardType { INSTANT, CREATURE, LAND, ENCHANTMENT, ARTIFACT, PLANESWALKER}; 
    enum CardColor { WHITE, BLUE, BLACK, RED, GREEN, NON };
    CardType type;
    CardColor color; 
    int manaCost;
    char* abilities;
    char* flavorText;
    char* keywords;
    bool inPlay;
    bool tapped;
    bool cursed;
    bool enchanted;
    Artifact* artifact;

    virtual int enchant( Card * );
    virtual int disenchant (Card * );
    virtual int equipArtifact(  Artifact*  );
    virtual Artifact* unequipArtifact(Card * );   
};

// ------------
class Spell: public Card
{
  public:
    Spell(); 
   ~Spell();
   Spell(const Spell &); 

  protected:
    virtual int heal( Spell *&, int );   
    virtual int attack( Spell *& );
    virtual int counter( Spell*& );
    int currToughness;
    int baseToughness;
    int currPower;
    int basePower;
};

class Land: public Card
{
  public:
    Land();
    ~Land();

  protected:
  virtual int generateMana(int);

};

class Forest: public Land
{
  public:
    Forest();
    ~Forest();

  protected:
    int generateMana();

};

class Creature: public Spell
{
  public:
    Creature();
    ~Creature();

  protected:
    bool summoningSick;

};

class Sorcery: public Spell
{
  public:
    Sorcery();
    ~Sorcery();

  protected:

};

#endif

conception.h -- this is an "uber class" from which everything derives

 class Conception{
  public:
    Conception(); 
    ~Conception();
  protected:
    char* classType;
};

conception.cpp

Conception::Conception{
  Conception(){
    classType = new char[11];
    char = "Conception"; 
}

game.cpp -- this is an incomplete class as of this code

#include <iostream>
#include <cctype>
#include "game.h"
#include "player.h"

Battlefield::Battlefield(){
  card = 0;  
}

Battlefield::~Battlefield(){
  delete card;
}

Battlefield::Battlefield(const Battlefield & to_copy){  
}

// ===========

/*
class Game(){
  public:
    Game();
    ~Game();

  protected:
    Player** player;    // for multiple players
    Battlefield* root;  // for battlefield
    getPlayerMove();    // ask player what to do
    addToBattlefield();
    removeFromBattlefield();
    sendAttack();
}
*/

#endif

game.h

#ifndef GAME_H
#define GAME_H
#include "list.h"

class CardList();

class Battlefield : CardList{
  public:
    Battlefield();
    ~Battlefield();

  protected:
    Card* card;         // make an array
};

class Game : Conception{
  public:
    Game();
    ~Game();

  protected:
    Player** player;    // for multiple players
    Battlefield* root;  // for battlefield
    getPlayerMove();    // ask player what to do
    addToBattlefield();
    removeFromBattlefield();
    sendAttack();

    Battlefield* field;
};

list.cpp

#include <iostream>
#include <cctype>
#include "list.h"

// ==========
LinkedList::LinkedList(){
  root = new Node;
  classType = new char[strlen("LinkedList") + 1];
  classType = "LinkedList";
};

LinkedList::~LinkedList(){
  delete root;
}

LinkedList::LinkedList(const LinkedList & obj)
{
    // code to copy
}

// ---------

// =========
int LinkedList::delete_all(Node* root){
  if (root = 0)
    return 0;
  delete_all(root->next);
  root = 0;
}

int LinkedList::add( Conception*& is){
  if (root == 0){
    root = new Node;
    root->next = 0;
  }
  else
  {
    Node * curr = root;
    root = new Node;
    root->next=curr;  
    root->it = is;
  }
}

int LinkedList::remove(Node * root, Node * prev, Conception* is){
  if (root = 0)
    return -1;
  if (root->it == is){
    root->next = root->next;
    return 0;
  }
  remove(root->next, root, is);
  return 0;
}

Conception* LinkedList::find(Node*& root, const Conception* is, Conception* holder = NULL)
{
  if (root==0)
    return NULL;
  if (root->it == is){
     return root-> it;
  }
  holder = find(root->next, is);
  return holder;
}



Node* LinkedList::goForward(Node * root){
  if (root==0)
    return root;
  if (root->next == 0)
    return root;
  else
    return root->next;
} 

// ============
Node* LinkedList::goBackward(Node * root){
  root = root->prev;
}

list.h

#ifndef LIST_H
#define LIST_H
#include <iostream>
#include "conception.h"

class Node : public Conception {
  public:
    Node() : next(0), prev(0), it(0)
      { it = 0;
        classType = new char[strlen("Node") + 1];
        classType = "Node";
      };
    ~Node(){
      delete it;
      delete next;
      delete prev;
    }

    Node* next;   
    Node* prev; 
    Conception* it;                 // generic object

};

// ----------------------
class LinkedList : public Conception {
  public:
   LinkedList();
   ~LinkedList();
   LinkedList(const LinkedList&);

   friend bool operator== (Conception& thing_1, Conception& thing_2 );

  protected:
   virtual int delete_all(Node*);
   virtual int add( Conception*& );     // 
   virtual Conception* find(Node *&, const Conception*, Conception* );  //   
   virtual int remove( Node *, Node *, Conception* );   // removes  question with keyword   int display_all(node*& );               
   virtual Node* goForward(Node *);
   virtual Node* goBackward(Node *);

   Node* root;
// write copy constrcutor

};

// =============

class CircularLinkedList : public LinkedList {
  public:
   // CircularLinkedList();
   // ~CircularLinkedList();    
   // CircularLinkedList(const CircularLinkedList &);

};

class DoubleLinkedList : public LinkedList {
  public:
//    DoubleLinkedList();
  //  ~DoubleLinkedList();
  //  DoubleLinkedList(const DoubleLinkedList &);

  protected:
};

// END OF LIST Hierarchy


#endif

player.cpp

#include <iostream>
#include "player.h"
#include "list.h"
using namespace std;


Library::Library(){
  root = 0;
}
Library::~Library(){
  delete card;
}

// ====DECL=========
Player::~Player(){
  delete fname;
  delete lname;
  delete deck;
}

Wizard::~Wizard(){
  delete mana;
  delete rootL;
  delete rootH;
}


// =====Player======
void Player::changeName(const char[] first, const char[] last){
  char* backup1 = new char[strlen(fname) + 1];
  strcpy(backup1, fname); 
  char* backup2 = new char[strlen(lname) + 1];
  strcpy(backup1, lname); 

  if (first != NULL){
    fname = new char[strlen(first) +1];
    strcpy(fname, first);
  }
  if (last != NULL){
    lname = new char[strlen(last) +1];
    strcpy(lname, last);
  }
  return 0;
}

// ==========
void Player::seeStats(Stats*& to_put){
  to_put->wins = stats->wins;
  to_put->losses = stats->losses;
  to_put->winRatio = stats->winRatio;
}
    // ----------

void Player::displayDeck(const LinkedList* deck){

}

// ================
void CardList::findCard(Node* root, int id, NodeCard*& is){
  if (root == NULL)
    return;
  if (root->it.id == id){
    copyCard(root->it, is);
    return;
  }
  else
    findCard(root->next, id, is);
}

     // --------
void CardList::deleteAll(Node* root){
  if (root == NULL)
    return;
  deleteAll(root->next);
  root->next = NULL;
}

    // ---------
void CardList::removeCard(Node* root, int id){
  if (root == NULL)
    return;
  if (root->id = id){
    root->prev->next = root->next;      // the prev link of root, looks back to next of prev node, and sets to where root next is pointing
  }
   return;
}

// ---------
void CardList::addCard(Card* to_add){
  if (!root){
    root = new Node;
    root->next = NULL;
    root->prev = NULL;
    root->it = &to_add;
    return;
  }
  else
  {
    Node* original = root;
    root = new Node;
    root->next = original;
    root->prev = NULL;
    original->prev = root;
  }
}

// -----------
void CardList::displayAll(Node*& root){
  if (root == NULL)
    return;

   cout << "Card Name: " << root->it.cardName;
   cout << " || Type: " << root->it.type <<  endl;
   cout << "    --------------- " << endl;
  if (root->classType == "Spell"){
    cout << "Base Power: " << root->it.basePower;
    cout << " || Current Power: " << root->it.currPower <<  endl;
   cout << "Base Toughness: " << root->it.baseToughness;
   cout << " || Current Toughness: " << root->it.currToughness <<  endl;
  }
   cout << "Card Type: " << root->it.currPower;
   cout << " || Card Color: " << root->it.color << endl;
   cout << "Mana Cost" << root->it.manaCost << endl;
   cout << "Keywords: " << root->it.keywords << endl;
   cout << "Flavor Text: " << root->it.flavorText << endl;
   cout << "  ----- Class Type: " << root->it.classType << " || ID: " << root->it.id << " -----  " << endl;
   cout << "     ******************************************" << endl;
   cout << endl;

// -------
void CardList::copyCard(const Card& to_get,  Card& put_to){
  put_to.type = to_get.type;
  put_to.color = to_get.color;
  put_to.manaCost = to_get.manaCost;
  put_to.inPlay = to_get.inPlay;
  put_to.tapped = to_get.tapped;
  put_to.class = to_get.class;
  put_to.id = to_get.id;
  put_to.enchanted = to_get.enchanted;
  put_to.artifact = to_get.artifact;  
  put_to.class = to_get.class;

  put.to.abilities = new char[strlen(to_get.abilities) +1];
  strcpy(put_to.abilities, to_get.abilities);
  put.to.keywords = new char[strlen(to_get.keywords) +1];
  strcpy(put_to.keywords, to_get.keywords);
  put.to.flavorText = new char[strlen(to_get.flavorText) +1];
  strcpy(put_to.flavorText, to_get.flavorText);

  if (to_get.class = "Spell"){
    put_to.baseToughness = to_get.baseToughness;
    put_to.basePower = to_get.basePower;
    put_to.currToughness = to_get.currToughness;
    put_to.currPower = to_get.currPower;
  }

}

 // ----------

player.h

#ifndef player.h
#define player.h

#include "list.h"

// ============
class CardList() : public LinkedList(){
  public:
    CardList();
    ~CardList();

  protected:
    virtual void findCard(Card&);
    virtual void addCard(Card* );
    virtual void removeCard(Node* root, int id);
    virtual void deleteAll();
    virtual void displayAll();
    virtual void copyCard(const Conception*, Node*&);

    Node* root;
}

// ---------
class Library() : public CardList(){
  public:
    Library();
    ~Library();

  protected:
    Card* card;
    int numCards;
    findCard(Card&);    // get Card and fill empty template
} 
  // -----------

class Deck() : public CardList(){
  public:
    Deck();
    ~Deck();

  protected:
    enum deckColor { WHITE, BLUE, BLACK, RED, GREEN, MIXED };
    char* deckName;


}

// ===============
class Mana(int amount) : public Conception {
  public:
    Mana() : displayTotal(0), classType(0) 
       { displayTotal = 0;
           classType = new char[strlen("Mana") + 1];
           classType = "Mana";
        }; 
  protected: 
    int accrued;    
    void add();
    void remove();
    int displayTotal();

}

inline Mana::add(){   accrued += 1;   }
inline Mana::remove(){  accrued -= 1; }
inline Mana::displayTotal(){  return accrued; }

// ================
class Stats() : public Conception {
  public:
    friend class Player;
    friend class Game;

    Stats() : wins(0), losses(0), winRatio(0) {
             wins = 0; losses = 0; 
             if ( (wins + losses != 0)
               winRatio = wins / (wins + losses);
             else
               winRatio = 0;
           classType = new char[strlen("Stats") + 1];
           classType = "Stats";

            }
  protected:
    int wins;
    int losses;
    float winRatio;
    void int getStats(Stats*& );
}

// ==================
class Player() : public Conception{
  public:
    Player() : wins(0), losses(0), winRatio(0) {
      fname = NULL;
      lname = NULL;
      stats = NULL;
      CardList = NULL;
      classType = new char[strlen("Player") + 1];
      classType = "Player";
    };
    ~Player();
    Player(const Player & obj);

  protected:
  // member variables
    char* fname;
    char* lname;
    Stats stats;            // holds previous game statistics    
    CardList* deck[];       // hold multiple decks that player might use - put ll in this

  private:
  // member functions
    void changeName(const char[], const char[]);
    void shuffleDeck(int);
    void seeStats(Stats*& );
    void displayDeck(int);    
    chooseDeck();
}

// --------------------
class Wizard(Card) : public Player(){
  public:
    Wizard() : { mana = NULL; rootL = NULL; rootH = NULL};
    ~Wizard();

  protected:

    playCard(const Card &);
    removeCard(Card &);
    attackWithCard(Card &);
    enchantWithCard(Card &);
    disenchantWithCard(Card &);
    healWithCard(Card &);
    equipWithCard(Card &);
    Mana* mana[];
    Library* rootL;         // Library  
    Library* rootH;         // Hand
}

#endif