Having trouble with passing array of pointers to functions to other functions

I'm getting the error for the following code "error C2664: 'KaibaMainPhase' : cannot convert pa rameter 1 from 'void (__cdecl *[2])(std::vector<_Ty> &,std::vector<_Ty> &,std::vector<std::vector<_Ty>> &,std::vector<_Ty> &,std::vector<_Ty> &)' to 'void (__cdecl *)(std::vector<_Ty> &,std::vector<Card> &,std::vector<Card> &)"

Code:

---

class Card
{
public:
        string GetName() {return Name;}
        void SetName(const string& setName) {Name = setName; }
        void SetType(const string& setType) {Type = setType; }

private:
        string Name;
        string Type;
};

vector< vector<Card> > Field(4, vector<Card>(5));
vector<Card> KaibaHand;
vector<Card>::iterator KH;
vector<Card> YugiHand;
vector<Card>::iterator YH;

vector<Card> KaibaGraveyard;
vector<Card>::iterator KG;
vector<Card> YugiGraveyard;
vector<Card>::iterator YG;


void KaibaBeginning(vector<Card> &KaibaHand, vector<Card> &KaibaDeck);
void DrawForKaiba(vector<Card> &KaibaHand, vector<Card> &KaibaDeck);
void KaibaMainPhase(void (*)(vector< vector<Card> > &Field, vector<Card> &KaibaGraveyard, vector<Card> &YugiGraveyard), vector<Card> &KaibaHand, vector<Card> &KaibaDeck, vector< vector<Card> > &Field, vector<Card> &YugiGraveyard, vector<Card> &KaibaGraveyard);


void FieldFunction(vector< vector<Card> > &Field);
void KaibaHandFunction(vector<Card> &KaibaHand);
void KaibaGraveyardFunction(vector<Card> &KaibaGraveyard);
void YugiGraveyardFunction(vector<Card> &YugiGraveyard);
void KaibaSummon(vector< vector<Card> > &Field, vector<Card> &KaibaHand, int HandNumber, int MonstCount);
void YugiSummon(vector< vector<Card> > &Field, vector<Card> &YugiHand, int HandNumber, int MonstCount);
void KaibaDiscard(int HandNumber, vector<Card> &KaibaHand, vector<Card> &KaibaGraveyard);
void YugiDiscard(int HandNumber, vector<Card> &YugiHand, vector<Card> &YugiGraveyard);


void KaibaMainPhase(void (*)(vector< vector<Card> > &Field, vector<Card> &KaibaGraveyard, vector<Card> &YugiGraveyard), vector<Card> &KaibaHand, vector<Card> &KaibaDeck, vector< vector<Card> > &Field, vector<Card> &YugiGraveyard, vector<Card> &KaibaGraveyard);
 

void HEAVYSTORM(vector<Card> &KaibaHand, vector<Card> &KaibaDeck, vector< vector<Card> > &Field, vector<Card> &KaibaGraveyard, vector<Card> &YugiGraveyard)
        {
        cout<<"This card destroys ALL magic and traps cards on the field!!"<<endl;
                for (int i=0; i<5; i++)
                {
                        YugiGraveyard.push_back(Field[0][i]);
                Field[0][i]=Card();
                        KaibaGraveyard.push_back(Field[3][i]);
                        Field[3][i]=Card();
                }       
        }

void POTOFGREED(vector<Card> &KaibaHand, vector<Card> &KaibaDeck, vector< vector<Card> > &Field, vector<Card> &KaibaGraveyard, vector<Card> &YugiGraveyard)
{
        DrawForKaiba(KaibaHand, KaibaDeck);
}


int main()
{

void (* pFunct[2]) (vector<Card> &KaibaHand, vector<Card> &KaibaDeck, vector< vector<Card> > &Field, vector<Card> &KaibaGraveyard, vector<Card> &YugiGraveyard);
        pFunct[0] = HEAVYSTORM;
        pFunct[1] = POTOFGREED;


KaibaMainPhase(pFunct, KaibaHand, KaibaDeck, Field, YugiGraveyard, KaibaGraveyard);
}


void KaibaMainPhase( void (*pFunct)(vector<Card> &KaibaHand, vector<Card> &KaibaDeck, vector< vector<Card> > &Field, vector<Card> &KaibaGraveyard, vector<Card> &YugiGraveyard), vector<Card> &KaibaHand, vector<Card> &KaibaDeck, vector< vector<Card> > &Field, vector<Card> &YugiGraveyard, vector<Card> &KaibaGraveyard)
{
int HandNum;
cout<<"Enter a number: "<<endl;
cin>>HandNum;
cout<<"You played "<<Field[3][HandNum-1].GetName();
pFunct[HandNum-1](KaibaHand, KaibaDeck, Field, KaibaGraveyard, YugiGraveyard);//
}

void KaibaHandFunction(vector<Card> &KaibaHand)
{
                cout<<endl<<"Kaiba's hand contains: "<<endl;
                for (KH=KaibaHand.begin(); KH<KaibaHand.end(); KH++)
                {
                        cout<<KH->GetName()<<endl;

                }
}

void YugiHandFunction(vector<Card> &YugiHand)
{
                cout<<endl<<"Yugi's hand contains: "<<endl;
                for (YH=YugiHand.begin(); YH<YugiHand.end(); YH++)
                {
                        cout<<YH->GetName()<<endl;

                }
}

void KaibaGraveyardFunction(vector<Card> &KaibaGraveyard)
{
                        cout<<endl<<"Kaiba's graveyard contains: "<<endl;
                        for (KG=KaibaGraveyard.begin(); KG<KaibaGraveyard.end(); KG++)
                        {
                                cout<<KG->GetName()<<endl; //SAME AS (*gt).GetName
                        }
                        cout<<"\n";
}

void YugiGraveyardFunction(vector<Card> &YugiGraveyard)
{
                        cout<<endl<<"Yugi's graveyard contains: "<<endl;
                        for (YG=YugiGraveyard.begin(); YG<YugiGraveyard.end(); YG++)
                        {
                                cout<<YG->GetName()<<endl; //SAME AS (*gt).GetName
                        }
                        cout<<"\n";
}

---

Trying to compile the code you presented gives me a lot of errors, including trivial stuff like cout/cin/string/vector etc not declared. Could you present an updated version which when compiled demonstrates the error you mention?

The entire code is too long to post here. I only included part of the code, since I didn't think alot of it was relevant. But I'll post more of it if you want to see it

Code:

---

#include <stdlib.h>
#include <windows.h>
#include <ctime>
#include <cstdlib>
#include <iostream>
#include <vector>
#include <string>


using namespace std;

class Card
{
public:
        string GetName() {return Name;}
        void SetName(const string& setName) {Name = setName; }
        void SetType(const string& setType) {Type = setType; }

private:
        string Name;
        string Type;
};

vector< vector<Card> > Field(4, vector<Card>(5));
vector<Card> KaibaHand;
vector<Card>::iterator KH;


vector<Card> KaibaGraveyard;
vector<Card>::iterator KG;
vector<Card> YugiGraveyard;
vector<Card>::iterator YG;


void KaibaBeginning(vector<Card> &KaibaHand, vector<Card> &KaibaDeck);
void DrawForKaiba(vector<Card> &KaibaHand, vector<Card> &KaibaDeck);
void KaibaMainPhase(void (*)(vector<Card> &KaibaHand, vector<Card> &KaibaDeck, vector< vector<Card> > &Field, vector<Card> &KaibaGraveyard, vector<Card> &YugiGraveyard), vector<Card> &KaibaHand, vector<Card> &KaibaDeck, vector< vector<Card> > &Field, vector<Card> &YugiGraveyard, vector<Card> &KaibaGraveyard);


void FieldFunction(vector< vector<Card> > &Field);
void KaibaHandFunction(vector<Card> &KaibaHand);
void KaibaGraveyardFunction(vector<Card> &KaibaGraveyard);
void YugiGraveyardFunction(vector<Card> &YugiGraveyard);
void KaibaSummon(vector< vector<Card> > &Field, vector<Card> &KaibaHand, int HandNumber, int MonstCount);
void KaibaDiscard(int HandNumber, vector<Card> &KaibaHand, vector<Card> &KaibaGraveyard);


void KaibaMainPhase(void (*)(vector<Card> &KaibaHand, vector<Card> &KaibaDeck, vector< vector<Card> > &Field, vector<Card> &KaibaGraveyard, vector<Card> &YugiGraveyard), vector<Card> &KaibaHand, vector<Card> &KaibaDeck, vector< vector<Card> > &Field, vector<Card> &YugiGraveyard, vector<Card> &KaibaGraveyard);
 

void HEAVYSTORM(vector<Card> &KaibaHand, vector<Card> &KaibaDeck, vector< vector<Card> > &Field, vector<Card> &KaibaGraveyard, vector<Card> &YugiGraveyard)
        {
        cout<<"This card destroys ALL magic and traps cards on the field!!"<<endl;
                for (int i=0; i<5; i++)
                {
                        YugiGraveyard.push_back(Field[0][i]);
                Field[0][i]=Card();
                        KaibaGraveyard.push_back(Field[3][i]);
                        Field[3][i]=Card();
                }       
        }

void POTOFGREED(vector<Card> &KaibaHand, vector<Card> &KaibaDeck, vector< vector<Card> > &Field, vector<Card> &KaibaGraveyard, vector<Card> &YugiGraveyard)
{
        DrawForKaiba(KaibaHand, KaibaDeck);
}


int main()
{
srand(time(0));

        vector<Card> KaibaDeck(40);
        vector<Card>:: iterator KD;
       
        KaibaDeck[0].SetName("BLUE EYES WHITE DRAGON"), KaibaDeck[1].SetName("BLUE EYES WHITE DRAGON"), KaibaDeck[2].SetName("BLUE EYES WHITE DRAGON"), KaibaDeck[3].SetName("VORSE RAIDER"), KaibaDeck[4].SetName("BLADE KNIGHT"),
        KaibaDeck[5].SetName("KAISER SEA HORSE"), KaibaDeck[6].SetName("LORD OF DRAGONS"), KaibaDeck[7].SetName("THUNDER DRAGON"), KaibaDeck[8].SetName("THUNDER DRAGON"), KaibaDeck[9].SetName("THUNDER DRAGON"),
        KaibaDeck[10].SetName("CYBER JAR"), KaibaDeck[11].SetName("SPEAR DRAGON"), KaibaDeck[12].SetName("TWIN HEADED BEHEMOTH"), KaibaDeck[13].SetName("X CANNON HEAD"), KaibaDeck[14].SetName("Y DRAGON HEAD"),
        KaibaDeck[15].SetName("Z HEAD TANK"), KaibaDeck[16].SetName("VAMPIRE LORD"), KaibaDeck[17].SetName("SPIRIT RYU"), KaibaDeck[18].SetName("POSSESSED DARK SOUL"), KaibaDeck[19].SetName("LA JINN THE MYSTICAL GENIE OF THE LAMP"),
        KaibaDeck[20].SetName("DIFFERENT DIMENSION DRAGON"), KaibaDeck[21].SetName("GIANT GERM"), KaibaDeck[22].SetName("GIANT GERM"), KaibaDeck[23].SetName("GIANT GERM"), KaibaDeck[24].SetName("MONSTER REBORN"),
        KaibaDeck[25].SetName("SHRINK"), KaibaDeck[26].SetName("SHRINK"), KaibaDeck[27].SetName("POLYMERIZATION"), KaibaDeck[28].SetName("FLUTE OF SUMMONING DRAGON"), KaibaDeck[29].SetName("FLUTE OF SUMMONING DRAGON"),
        KaibaDeck[30].SetName("COST DOWN"), KaibaDeck[31].SetName("HEAVY STORM"), KaibaDeck[32].SetName("SILENT DOOM"), KaibaDeck[33].SetName("STOP DEFENSE"), KaibaDeck[34].SetName("POT OF GREED"),
        KaibaDeck[35].SetName("VIRUS CANNON"), KaibaDeck[36].SetName("RING OF DESTRUCTION"), KaibaDeck[37].SetName("DRAGON'S RAGE"), KaibaDeck[38].SetName("CRUSH CARD"), KaibaDeck[39].SetName("INTERDIMENSIONAL MATTER TRANSPORTER");


void (* pFunct[2]) (vector<Card> &KaibaHand, vector<Card> &KaibaDeck, vector< vector<Card> > &Field, vector<Card> &KaibaGraveyard, vector<Card> &YugiGraveyard);
        pFunct[0] = HEAVYSTORM;
        pFunct[1] = POTOFGREED;


KaibaMainPhase(pFunct, KaibaHand, KaibaDeck, Field, YugiGraveyard, KaibaGraveyard);
}


void KaibaMainPhase( void (*pFunct)(vector<Card> &KaibaHand, vector<Card> &KaibaDeck, vector< vector<Card> > &Field, vector<Card> &KaibaGraveyard, vector<Card> &YugiGraveyard), vector<Card> &KaibaHand, vector<Card> &KaibaDeck, vector< vector<Card> > &Field, vector<Card> &YugiGraveyard, vector<Card> &KaibaGraveyard)
{
int HandNum;
cout<<"Enter a number: "<<endl;
cin>>HandNum;
cout<<"You played "<<Field[3][HandNum-1].GetName();
pFunct[HandNum-1](KaibaHand, KaibaDeck, Field, KaibaGraveyard, YugiGraveyard);//
}

void KaibaHandFunction(vector<Card> &KaibaHand)
{
                cout<<endl<<"Kaiba's hand contains: "<<endl;
                for (KH=KaibaHand.begin(); KH<KaibaHand.end(); KH++)
                {
                        cout<<KH->GetName()<<endl;

                }
}


void KaibaGraveyardFunction(vector<Card> &KaibaGraveyard)
{
                        cout<<endl<<"Kaiba's graveyard contains: "<<endl;
                        for (KG=KaibaGraveyard.begin(); KG<KaibaGraveyard.end(); KG++)
                        {
                                cout<<KG->GetName()<<endl; //SAME AS (*gt).GetName
                        }
                        cout<<"\n";
}

void YugiGraveyardFunction(vector<Card> &YugiGraveyard)
{
                        cout<<endl<<"Yugi's graveyard contains: "<<endl;
                        for (YG=YugiGraveyard.begin(); YG<YugiGraveyard.end(); YG++)
                        {
                                cout<<YG->GetName()<<endl; //SAME AS (*gt).GetName
                        }
                        cout<<"\n";
}

---

The error shows up with this line

Code:

---

KaibaMainPhase(pFunct, KaibaHand, KaibaDeck, Field, YugiGraveyard, KaibaGraveyard);

---

The error says "error C2664: 'KaibaMainPhase' : cannot convert parameter 1 from 'void (__cdecl *[2])(std::vector<_Ty> &,std::vector<_Ty> &,std::vector<std::vector<_Ty>> &,std::vector<_Ty> &,std::vector<_Ty> &)' to 'void (__cdecl *)(std::vector<_Ty> &,std::vector<_Ty> &,std::vector<std::vector<_Ty>> &,std::vector<_Ty> &,std::vector<_Ty> &)'"

I'd really like to know the cause of this problem

Quote:

---

Originally Posted by larry burns

The entire code is too long to post here.

---

A compiler error has nothing to do with the size of your current code base. Any compiler error can be simulated using minimal, but complete code.

Second, the reason why complete code is needed is that we have no idea if the compiler error is caused because of code you're missing. For example, if we see an error that states that the compiler doesn't know what a certain type is, and in haste you post code that doesn't define that type because you deem it to be irrelevant, what are we to deduce from that?

Here is what is expected when whittling down the program:

Code:

---

#include <vector>

using namespace std;

class Card
{ };

void KMP(void (*)(
              vector< vector<Card> > &,
              vector<Card> &,
              vector<Card> &,
              vector<Card> &,
              vector<Card> &k,
              vector< vector<Card> > &,
              vector<Card> &,
              vector<Card> &));

void HEAVYSTORM(vector<Card> &,
                              vector<Card> &,
                              vector< vector<Card> > &,
                              vector<Card> &,
                              vector<Card> &);

void POTOFGREED(vector<Card> &,
                              vector<Card> &,
                              vector< vector<Card> > &,
                              vector<Card> &,
                              vector<Card> &);

int main()
{
    void (* pFunct[2]) (vector<Card> &,
                                  vector<Card> &,
                                  vector< vector<Card> > &,
                                  vector<Card> &,
                                  vector<Card> &);

    pFunct[0] = HEAVYSTORM;
    pFunct[1] = POTOFGREED;
    KMP(pFunct);
}

---

This is a complete, but minimal program that produces the following compiler error when run on the Comeau C++ compiler:

Code:

---

Thank you for testing your code with Comeau C/C++!
Tell others about http://www.comeaucomputing.com/tryitout !

Your Comeau C/C++ test results are as follows:

Comeau C/C++ 4.3.10.1 (Oct  6 2008 11:28:09) for ONLINE_EVALUATION_BETA2
Copyright 1988-2008 Comeau Computing.  All rights reserved.
MODE:strict errors C++ C++0x_extensions

"ComeauTest.c", line 40: error: argument of type "void (**)(std::vector<Card,
          std::allocator<Card>> &, std::vector<Card, std::allocator<Card>> &,
          std::vector<std::vector<Card, std::allocator<Card>>,
          std::allocator<std::vector<Card, std::allocator<Card>>>> &,
          std::vector<Card, std::allocator<Card>> &, std::vector<Card,
          std::allocator<Card>> &)"

          is incompatible with parameter of type

          "void (*)(std::vector<std::vector<Card, std::allocator<Card>>,
          std::allocator<std::vector<Card, std::allocator<Card>>>> &,
          std::vector<Card, std::allocator<Card>> &, std::vector<Card,
          std::allocator<Card>> &, std::vector<Card, std::allocator<Card>> &,
          std::vector<Card, std::allocator<Card>> &,
          std::vector<std::vector<Card, std::allocator<Card>>,
          std::allocator<std::vector<Card, std::allocator<Card>>>> &,
          std::vector<Card, std::allocator<Card>> &, std::vector<Card,
          std::allocator<Card>> &)"

      KMP(pFunct);
          ^

1 error detected in the compilation of "ComeauTest.c".

---

So the issue is that you're specifying an array instead of pFunct[0] or pFunct[1].

Secondly, your parameters do not match up. If you look carefully, pFunct is an array of function pointers, but the function that pFunct[] is defining is incompatible with KMP, since KMP defines a different number of parameters.

You should be using typedef, so that you're not typing all of those parameters so many times, and also, you don't make mistakes as your code is doing now.

Code:

---

#include <vector>

using namespace std;

class Card
{ };

typedef void (*FuncType)(
              vector<Card> &,
              vector<Card> &,
              vector< vector<Card> > &,
              vector<Card> &,
              vector<Card> &);

void KMP( FuncType fn );

void HEAVYSTORM(vector<Card> &,
                vector<Card> &,
                vector< vector<Card> > &,
                vector<Card> &,
                vector<Card> &);

void POTOFGREED(vector<Card> &,
                              vector<Card> &,
                              vector< vector<Card> > &,
                              vector<Card> &,
                              vector<Card> &);

int main()
{
    FuncType pFunct[2];
    pFunct[0] = HEAVYSTORM;
    pFunct[1] = POTOFGREED;
    KMP(pFunct[0]);
}

---

This compiles successfully. I have no idea which one of the definitions you have is the correct one, so I chose one, and that has 5 parameters. If you wanted to actually pass the entire array, then the change is simple, all due to the usage of typedef above. A FuncType is no different than an int, double, char, etc. If you wanted to pass an array of int, how would you do it? Whatever that is, that is exactly the same way as passing an array of FuncType.

So you would change KMP prototype like this:

Code:

---

void KMP( FuncType* fn );

---

Then this will now work.

Code:

---

    KMP(pFunct);

---

However, this is really not a good design, as KMP has no idea how many items are in the array. Instead, usage of a container that knows its size instead of an array is recommended, or you need to pass the number of elements as a separate parameter.

But the main point is this -- if you get a compiler error, any compiler error can be duplicated with a simple, do nothing program. Note that those functions need no function body, as well as formal parameter names.

Regards,

Paul McKenzie

Code:

---

#include <stdlib.h>
#include <windows.h>
#include <ctime>
#include <cstdlib>
#include <iostream>
#include <vector>
#include <string>

using namespace std;

class Card
{
public:
        int GetAttack() {return Attack;}
        int GetDefense() {return Defense;}
        int GetStars() {return Stars;}
        string GetName() {return Name;}
        string GetMode() {return Mode;}
        string GetFace() {return Face;}
        string GetType() {return Type;}
        void SetAttack(int setAttack) { Attack = setAttack; }
        void SetDefense(int setDefense) { Defense = setDefense; }
        void SetStars(int setStars) {Stars = setStars; }
        void SetName(const string& setName) {Name = setName; } //'&' means that the address of setName is the same as "BLUE EYES WHITE DRAGON"
        void SetMode(const string& setMode) {Mode = setMode; }
        void SetFace(const string& setFace) {Face = setFace; }
        void SetType(const string& setType) {Type = setType; }

private:
        int Attack;
        int Defense;
        int Stars;
        string Name;
        string Mode;
        string Face;
        string Type;
};

vector< vector<Card> > Field(4, vector<Card>(5));
vector<Card> KaibaHand;
vector<Card>::iterator KH;
vector<Card> YugiHand;
vector<Card>::iterator YH;

vector<Card> KaibaGraveyard;
vector<Card>::iterator KG;
vector<Card> YugiGraveyard;
vector<Card>::iterator YG;

typedef void (*FunctType) (vector<Card> &, vector<Card> &, vector< vector<Card> > &, vector<Card> &, vector<Card> &);

void KaibaBeginning(vector<Card> &KaibaHand, vector<Card> &KaibaDeck);
void YugiBeginning(vector<Card> &YugiHand, vector<Card> &YugiDeck);
void DrawForKaiba(vector<Card> &KaibaHand, vector<Card> &KaibaDeck);
void DrawForYugi(vector<Card> &YugiHand, vector<Card> &YugiDeck);

void KaibaMainPhase( FunctType* fn);

void YugiMainPhase(vector< vector<Card> > &Field, vector<Card> &YugiHand, vector<Card> &YugiGraveyard, vector<Card> &KaibaGraveyard);
void KaibaBattlePhase(vector< vector<Card> > &Field, vector<Card> &YugiGraveyard, vector<Card> &KaibaGraveyard, int& KaLP, int& YuLP);
void YugiBattlePhase(vector< vector<Card> > &Field, vector<Card> &YugiGraveyard, vector<Card> &KaibaGraveyard, int& KaLP, int& YuLP);
void KaibaBattleFunction(vector< vector<Card> > &Field, int MonsterCard, int MonsterToAttack, vector<Card> &KaibaGraveyard, vector<Card> &YugiGraveyard, int& KaLP, int& YuLP);
void YugiBattleFunction(vector< vector<Card> > &Field, int MonsterCard, int MonsterToAttack, vector<Card> &KaibaGraveyard, vector<Card> &YugiGraveyard, int& KaLP, int& YuLP);

void FieldFunction(vector< vector<Card> > &Field);
void KaibaHandFunction(vector<Card> &KaibaHand);
void YugiHandFunction(vector<Card> &YugiHand);
void KaibaGraveyardFunction(vector<Card> &KaibaGraveyard);
void YugiGraveyardFunction(vector<Card> &YugiGraveyard);
void KaibaSummon(vector< vector<Card> > &Field, vector<Card> &KaibaHand, int HandNumber, int MonstCount);
void YugiSummon(vector< vector<Card> > &Field, vector<Card> &YugiHand, int HandNumber, int MonstCount);
void KaibaDiscard(int HandNumber, vector<Card> &KaibaHand, vector<Card> &KaibaGraveyard);
void YugiDiscard(int HandNumber, vector<Card> &YugiHand, vector<Card> &YugiGraveyard);

void HEAVYSTORM(vector<Card> &KaibaHand, vector<Card> &KaibaDeck, vector< vector<Card> > &Field, vector<Card> &KaibaGraveyard, vector<Card> &YugiGraveyard)
        {
        cout<<"This card destroys ALL magic and traps cards on the field!!"<<endl;
                for (int i=0; i<5; i++)
                {
                        YugiGraveyard.push_back(Field[0][i]);
                Field[0][i]=Card();
                        KaibaGraveyard.push_back(Field[3][i]);
                        Field[3][i]=Card();
                }       
        }

void MONSTERREBORN(vector< vector<Card> > &Field, vector<Card> &KaibaGraveyard, vector<Card> &YugiGraveyard)
        {
                cout<<"This card lets me revive a monster from the graveyard!!"<<endl;
                YugiGraveyardFunction(YugiGraveyard);
                KaibaGraveyardFunction(KaibaGraveyard);
                int PlayerGrave, GraveNum, Slot;
                cout<<"Which graveyard do you want to revive the monster from?  (1-Kaiba, 2-Yugi)"<<endl;
                cin>>PlayerGrave;
                        if (PlayerGrave==1)
                        {
                                cout<<"Which Kaiba monster to revive? (1 for 1st monster, etc. Press 0 to cancel)"<<endl;
                                cin>>GraveNum;
                                if (GraveNum!=0)
                                {
                                        cout<<"Which monster slot do you wish to summon it on?"<<endl;
                                        cin>>Slot;
                                        KaibaSummon(Field, KaibaHand, GraveNum, Slot);
                                        KaibaGraveyard.erase(KaibaGraveyard.begin()+GraveNum-1);
                                }
                        }
                        if (PlayerGrave==2)
                        {
                                cout<<"Which Yugi monster to revive? (1 for 1st monster, etc. Press 0 to cancel)"<<endl;
                                cin>>GraveNum;
                                if (GraveNum!=0)
                                {
                                        cout<<"Which monster slot do you wish to summon it on?"<<endl;
                                        cin>>Slot;
                                        KaibaSummon(Field, KaibaHand, GraveNum, Slot);
                                        KaibaGraveyard.erase(KaibaGraveyard.begin()+GraveNum-1);
                                }
                        }
               
        }

void POTOFGREED(vector<Card> &KaibaHand, vector<Card> &KaibaDeck, vector< vector<Card> > &Field, vector<Card> &KaibaGraveyard, vector<Card> &YugiGraveyard)
{
        DrawForKaiba(KaibaHand, KaibaDeck);
}

void FLUTEOFSUMMONINGDRAGON(vector<Card> &KaibaHand, vector< vector<Card> > &Field)
{
        int DragonOne, DragonTwo;
        int FluteSlot, FluteChoice;
        for (int i=1; i<6; i++)
        {
                if (Field[2][i-1].GetName()=="LORD OF DRAGONS")
                {
                cout<<"Choose the Dragon in your hand that you want to Special Summon (press 0 to not summon any)"<<endl;
                cin>>DragonOne;
                cout<<"Choose which slot to special summon the monster"<<endl;
                cin>>FluteSlot;
                KaibaSummon(Field, KaibaHand, DragonOne, FluteSlot);
                cout<<"Do you want to summon another Dragon? (1-yes, 0-no)"<<endl;
                cin>>FluteChoice;
                if (FluteChoice==1)
                        {
                        cout<<"Choose the Dragon in your hand that you want to Special Summon (press 0 to not summon any)"<<endl;
                        cin>>DragonTwo;
                        cout<<"Choose which slot to special summon the monster"<<endl;
                        cin>>FluteSlot;
                        KaibaSummon(Field, KaibaHand, DragonTwo, FluteSlot);
                        }
                break;
                }
        }
}

void COSTDOWN(vector<Card> &KaibaHand, vector< vector<Card> > &Field, vector<Card> &KaibaGraveyard)
{
        int CDdiscard, CDcostdown;
        cout<<"Discard one card from your hand"<<endl;
        cin>>CDdiscard;
        KaibaDiscard(CDdiscard, KaibaHand, KaibaGraveyard);
        cout<<"Choose the Card in your hand that you want to lower by 2 stars (press 0 to not summon any)"<<endl;
        cin>>CDcostdown;
        KaibaHand[CDcostdown-1].SetStars( KaibaHand[CDcostdown-1].GetStars() - 2);
}

void SILENTDOOM(vector< vector<Card> > &Field, vector<Card> &KaibaGraveyard)
{
        int SDgrave, SDSlot;
        cout<<"Pick which monster from your graveyard to Special Summon"<<endl;
        cin>>SDgrave;
        KaibaSummon(Field, KaibaHand, SDgrave, SDSlot);
        KaibaGraveyard.erase(KaibaGraveyard.begin()+SDgrave-1);
}

void STOPDEFENSE(vector< vector<Card> > &Field)
{
        int DEFmonster;
        cout<<"Pick which monster on Yugi's field to switch to ATK mode"<<endl;
        cout<<"Enter 6 for 1st monster slot, etc"<<endl;
        cin>>DEFmonster;
        Field[1][DEFmonster-6].SetMode("ATK Mode");
}

void VIRUSCANNON(vector<Card> &YugiDeck, vector<Card> &YugiGraveyard)
{
        cout<<"This card will randomly send 10 cards from Yugi's deck to the graveyard!"<<endl;
        int YugiDeckSize;
        int DrawYugi;
        int Counter=1;
        while (Counter<10)
        {
                DrawYugi = rand() &#37; YugiDeckSize + 1;
                if (YugiDeck[DrawYugi-1].GetType()=="Magic")
                {
                cout<<YugiDeck[DrawYugi-1].GetName()<<"is sent to the Graveyard"<<endl;
                YugiDeck.erase(YugiDeck.begin()+DrawYugi-1);
                Counter++;
                }
        }
}

void RINGOFDESTRUCTION(vector< vector<Card> > &Field, vector<Card> &KaibaGraveyard, vector<Card> &YugiGraveyard, int &KaLP, int &YuLP)
{
        int RingRow, RingColumn;
        cout<<"Select which monster on the field to destroy";
        cin>>RingRow;
        cin>>RingColumn;
        if (RingRow==2)
                {
                        KaibaGraveyard.push_back(Field[2][RingColumn-1]);       
                        Field[2][RingColumn-1]=Card();
                        KaLP=KaLP-Field[2][RingColumn-1].GetAttack();       
                        YuLP=YuLP-Field[2][RingColumn-1].GetAttack();       
                }
        if (RingRow==1)
                {
                        YugiGraveyard.push_back(Field[1][RingColumn-6]);       
                        Field[1][RingColumn-6]=Card();
                        KaLP=KaLP-Field[1][RingColumn-6].GetAttack();       
                        YuLP=YuLP-Field[1][RingColumn-6].GetAttack();
                }
}


int HandNumber;
int CardSlot;
int Decision;
int KaibaDeckSize;
int YugiDeckSize;
int DrawChoice;
int MonsterCard;
int MonsterToAttack;
int FaceEnter;
int SacrificeNumberOne;
int SacrificeNumberTwo;

int KaibaLP=8000;
int YugiLP=8000;



int main()
{
        srand(time(0));

        vector<Card> KaibaDeck(40);
        vector<Card>:: iterator KD;
       
        KaibaDeck[0].SetName("BLUE EYES WHITE DRAGON"), KaibaDeck[1].SetName("BLUE EYES WHITE DRAGON"), KaibaDeck[2].SetName("BLUE EYES WHITE DRAGON"), KaibaDeck[3].SetName("VORSE RAIDER"), KaibaDeck[4].SetName("BLADE KNIGHT"),
        KaibaDeck[5].SetName("KAISER SEA HORSE"), KaibaDeck[6].SetName("LORD OF DRAGONS"), KaibaDeck[7].SetName("THUNDER DRAGON"), KaibaDeck[8].SetName("THUNDER DRAGON"), KaibaDeck[9].SetName("THUNDER DRAGON"),
        KaibaDeck[10].SetName("CYBER JAR"), KaibaDeck[11].SetName("SPEAR DRAGON"), KaibaDeck[12].SetName("TWIN HEADED BEHEMOTH"), KaibaDeck[13].SetName("X CANNON HEAD"), KaibaDeck[14].SetName("Y DRAGON HEAD"),
        KaibaDeck[15].SetName("Z HEAD TANK"), KaibaDeck[16].SetName("VAMPIRE LORD"), KaibaDeck[17].SetName("SPIRIT RYU"), KaibaDeck[18].SetName("POSSESSED DARK SOUL"), KaibaDeck[19].SetName("LA JINN THE MYSTICAL GENIE OF THE LAMP"),
        KaibaDeck[20].SetName("DIFFERENT DIMENSION DRAGON"), KaibaDeck[21].SetName("GIANT GERM"), KaibaDeck[22].SetName("GIANT GERM"), KaibaDeck[23].SetName("GIANT GERM"), KaibaDeck[24].SetName("MONSTER REBORN"),
        KaibaDeck[25].SetName("SHRINK"), KaibaDeck[26].SetName("SHRINK"), KaibaDeck[27].SetName("POLYMERIZATION"), KaibaDeck[28].SetName("FLUTE OF SUMMONING DRAGON"), KaibaDeck[29].SetName("FLUTE OF SUMMONING DRAGON"),
        KaibaDeck[30].SetName("COST DOWN"), KaibaDeck[31].SetName("HEAVY STORM"), KaibaDeck[32].SetName("SILENT DOOM"), KaibaDeck[33].SetName("STOP DEFENSE"), KaibaDeck[34].SetName("POT OF GREED"),
        KaibaDeck[35].SetName("VIRUS CANNON"), KaibaDeck[36].SetName("RING OF DESTRUCTION"), KaibaDeck[37].SetName("DRAGON'S RAGE"), KaibaDeck[38].SetName("CRUSH CARD"), KaibaDeck[39].SetName("INTERDIMENSIONAL MATTER TRANSPORTER");

        FunctType pFunct[2];
        //void (* pFunct[2]) (vector<Card> &KaibaHand, vector<Card> &KaibaDeck, vector< vector<Card> > &Field, vector<Card> &KaibaGraveyard, vector<Card> &YugiGraveyard);
        pFunct[0] = HEAVYSTORM;
        pFunct[1] = POTOFGREED;

        //std::vector<void *(*)(vector< vector<Card> > &Field, vector<Card> &KaibaGraveyard, vector<Card> &YugiGraveyard)> fns;
        //fns.push_back(HEAVYSTORM);
  // {
    //    BLADEKNIGHT,
        //        HEAVYSTORM, MONSTERREBORN
  // };
       
        KaibaDeck[0].SetAttack(3000), KaibaDeck[1].SetAttack(3000), KaibaDeck[2].SetAttack(3000), KaibaDeck[3].SetAttack(1900), KaibaDeck[4].SetAttack(1600),
        KaibaDeck[5].SetAttack(1700), KaibaDeck[6].SetAttack(1300), KaibaDeck[7].SetAttack(1600), KaibaDeck[8].SetAttack(1600), KaibaDeck[9].SetAttack(1600),
        KaibaDeck[10].SetAttack(900), KaibaDeck[11].SetAttack(1900), KaibaDeck[12].SetAttack(1500), KaibaDeck[13].SetAttack(1800), KaibaDeck[14].SetAttack(1500),
        KaibaDeck[15].SetAttack(1500), KaibaDeck[16].SetAttack(2000), KaibaDeck[17].SetAttack(1000), KaibaDeck[18].SetAttack(1200), KaibaDeck[19].SetAttack(1800),
        KaibaDeck[20].SetAttack(1500), KaibaDeck[21].SetAttack(1000), KaibaDeck[22].SetAttack(1000), KaibaDeck[23].SetAttack(1000);

        KaibaDeck[0].SetDefense(2500), KaibaDeck[1].SetDefense(2500), KaibaDeck[2].SetDefense(2500), KaibaDeck[3].SetDefense(1200), KaibaDeck[4].SetDefense(1000),
        KaibaDeck[5].SetDefense(1000), KaibaDeck[6].SetDefense(1200), KaibaDeck[7].SetDefense(1500), KaibaDeck[8].SetDefense(1500), KaibaDeck[9].SetDefense(1500),
        KaibaDeck[10].SetDefense(800), KaibaDeck[11].SetDefense(0), KaibaDeck[12].SetDefense(800), KaibaDeck[13].SetDefense(600), KaibaDeck[14].SetDefense(1600),
        KaibaDeck[15].SetDefense(1300), KaibaDeck[16].SetDefense(1200), KaibaDeck[17].SetDefense(1000), KaibaDeck[18].SetDefense(800), KaibaDeck[19].SetDefense(500),
        KaibaDeck[20].SetDefense(1600), KaibaDeck[21].SetDefense(100), KaibaDeck[22].SetDefense(100), KaibaDeck[23].SetDefense(100);

        KaibaDeck[0].SetStars(8), KaibaDeck[1].SetStars(8), KaibaDeck[2].SetStars(8), KaibaDeck[3].SetStars(4), KaibaDeck[4].SetStars(4),
        KaibaDeck[5].SetStars(4), KaibaDeck[6].SetStars(4), KaibaDeck[7].SetStars(5), KaibaDeck[8].SetStars(5), KaibaDeck[9].SetStars(5),
        KaibaDeck[10].SetStars(3), KaibaDeck[11].SetStars(4), KaibaDeck[12].SetStars(3), KaibaDeck[13].SetStars(4), KaibaDeck[14].SetStars(4),
        KaibaDeck[15].SetStars(4), KaibaDeck[16].SetStars(4), KaibaDeck[17].SetStars(5), KaibaDeck[18].SetStars(5), KaibaDeck[19].SetStars(5),
        KaibaDeck[20].SetStars(5), KaibaDeck[21].SetStars(3), KaibaDeck[22].SetStars(3), KaibaDeck[23].SetStars(3);


        for (KD=KaibaDeck.begin(); KD<KaibaDeck.begin()+24; KD++)
        { KD->SetType("Monster"); }
        for (KD=KaibaDeck.begin()+24; KD<KaibaDeck.begin()+35; KD++)
        { KD->SetType("Magic"); }
        for (KD=KaibaDeck.begin()+35; KD<KaibaDeck.end(); KD++)
        { KD->SetType("Trap"); }

        vector<Card> YugiDeck(40);
        vector<Card>:: iterator YD;

        YugiDeck[0].SetName("ALPHA THE MAGNET WARRIOR"), YugiDeck[1].SetName("BETA THE MAGNET WARRIOR"), YugiDeck[2].SetName("GAMMA THE MAGNET WARRIOR"), YugiDeck[3].SetName("CELTIC GUARDIAN"), YugiDeck[4].SetName("CURSE OF DRAGON"),
        YugiDeck[5].SetName("DARK MAGICIAN"), YugiDeck[6].SetName("DARK MAGICIAN GIRL"), YugiDeck[7].SetName("GAZELLE THE KING OF MYTHICAL BEASTS"), YugiDeck[8].SetName("BIG SHIELD GARDNA"), YugiDeck[9].SetName("BUSTER BLADER"),
        YugiDeck[10].SetName("KURIBOH"), YugiDeck[11].SetName("MYSTICAL ELF"), YugiDeck[12].SetName("BERFOMET"), YugiDeck[13].SetName("JACK'S KNIGHT"), YugiDeck[14].SetName("QUEEN'S KNIGHT"),
        YugiDeck[15].SetName("KING'S KNIGHT"), YugiDeck[16].SetName("GIANT SOLDIER OF STONE"), YugiDeck[17].SetName("SUMMONED SKULL"), YugiDeck[18].SetName("SWIFT GAIA THE FIERCE KNIGHT"), YugiDeck[19].SetName("CYBER JAR"),
        YugiDeck[20].SetName("SANGAN"), YugiDeck[21].SetName("FERAL IMP"), YugiDeck[22].SetName("CATAPULT TURTLE"), YugiDeck[23].SetName("CARD DESTRUCTION"), YugiDeck[24].SetName("MAGICAL HATS"),
        YugiDeck[25].SetName("HEAVY STORM"), YugiDeck[26].SetName("MONSTER REBORN"), YugiDeck[27].SetName("POLYMERIZATION"), YugiDeck[28].SetName("POT OF GREED"), YugiDeck[29].SetName("SWORDS OF REVEALING LIGHT"),
        YugiDeck[30].SetName("BRAIN CONTROL"), YugiDeck[31].SetName("DIFFUSION WAVE MOTION"), YugiDeck[32].SetName("EXCHANGE"), YugiDeck[33].SetName("MULTIPLY"), YugiDeck[34].SetName("MYSTIC BOX"),
        YugiDeck[35].SetName("MIRROR FORCE"), YugiDeck[36].SetName("MAGIC CYLINDER"), YugiDeck[37].SetName("SPELLBINDING CIRCLE"), YugiDeck[38].SetName("DUST TORNADO"), YugiDeck[39].SetName("LIGHTFORCE SWORD");

        for (YD=YugiDeck.begin(); YD<YugiDeck.begin()+23; YD++)
        { YD->SetType("Monster");}
        for (YD=YugiDeck.begin()+23; YD<YugiDeck.begin()+35; YD++)
        { YD->SetType("Magic"); }
        for (YD=YugiDeck.begin()+35; YD<YugiDeck.end(); YD++)
        { YD->SetType("Trap"); }

        YugiDeck[0].SetStars(4), YugiDeck[1].SetStars(4), YugiDeck[2].SetStars(4), YugiDeck[3].SetStars(4), YugiDeck[4].SetStars(5),
        YugiDeck[5].SetStars(7), YugiDeck[6].SetStars(4), YugiDeck[7].SetStars(4), YugiDeck[8].SetStars(4), YugiDeck[9].SetStars(7),
        YugiDeck[10].SetStars(1), YugiDeck[11].SetStars(4), YugiDeck[12].SetStars(5), YugiDeck[13].SetStars(4), YugiDeck[14].SetStars(4),
        YugiDeck[15].SetStars(5), YugiDeck[16].SetStars(4), YugiDeck[17].SetStars(6), YugiDeck[18].SetStars(7), YugiDeck[19].SetStars(3),
        YugiDeck[20].SetStars(3), YugiDeck[21].SetStars(3), YugiDeck[22].SetStars(5);

        YugiDeck[0].SetAttack(1400), YugiDeck[1].SetAttack(1700), YugiDeck[2].SetAttack(1500), YugiDeck[3].SetAttack(1400), YugiDeck[4].SetAttack(2000),
        YugiDeck[5].SetAttack(2500), YugiDeck[6].SetAttack(2000), YugiDeck[7].SetAttack(1500), YugiDeck[8].SetAttack(100), YugiDeck[9].SetAttack(2600),
        YugiDeck[10].SetAttack(300), YugiDeck[11].SetAttack(800), YugiDeck[12].SetAttack(1400), YugiDeck[13].SetAttack(1600), YugiDeck[14].SetAttack(1600),
        YugiDeck[15].SetAttack(1600), YugiDeck[16].SetAttack(1200), YugiDeck[17].SetAttack(2500), YugiDeck[18].SetAttack(2300), YugiDeck[19].SetAttack(900),
        YugiDeck[20].SetAttack(1000), YugiDeck[21].SetAttack(1200), YugiDeck[22].SetAttack(1500);

        YugiDeck[0].SetDefense(1700), YugiDeck[1].SetDefense(1600), YugiDeck[2].SetDefense(1800), YugiDeck[3].SetDefense(1900), YugiDeck[4].SetDefense(1600),
        YugiDeck[5].SetDefense(2100), YugiDeck[6].SetDefense(1600), YugiDeck[7].SetDefense(1000), YugiDeck[8].SetDefense(2600), YugiDeck[9].SetDefense(2200),
        YugiDeck[10].SetDefense(200), YugiDeck[11].SetDefense(2000), YugiDeck[12].SetDefense(1800), YugiDeck[13].SetDefense(1900), YugiDeck[14].SetDefense(1600),
        YugiDeck[15].SetDefense(1700), YugiDeck[16].SetDefense(2000), YugiDeck[17].SetDefense(1800), YugiDeck[18].SetDefense(1900), YugiDeck[19].SetDefense(1600),
        YugiDeck[20].SetDefense(600), YugiDeck[21].SetDefense(1000), YugiDeck[22].SetDefense(2000);

        //for (KD=KaibaDeck.begin(); KD<KaibaDeck.end(); KD++)
        //{ cout<<KD->GetName()<<" is a "<<KD->GetType()<<" card"<<endl;}
        //for (YD=YugiDeck.begin(); YD<YugiDeck.end(); YD++)
        //{ cout<<YD->GetName()<<" is a "<<YD->GetType()<<" card"<<endl;}

KaibaBeginning(KaibaHand, KaibaDeck);
YugiBeginning(YugiHand, YugiDeck);
//funct(Field, KaibaGraveyard, YugiGraveyard);

        while (KaibaDeckSize>0 && YugiDeckSize>0)
                {
                        //KAIBA'S TURN
                        cout<<endl<<endl<<"KAIBA'S TURN"<<endl;
                        KaibaDeckSize = KaibaDeck.size();
                        if (KaibaDeckSize==0)
                        {
                                cout<<"There are no cards left. KAIBA has DECKED OUT"<<endl;
                                break;
                        }
                        cout<<endl<<endl<<"KAIBA - DRAW PHASE (Press 1 to draw, 0 to CONCEDE)"<<endl;
                        cin>>DrawChoice;
                        if (DrawChoice==0)
                        {
                                break;
                        }
                       
                        else
                        {
                        DrawForKaiba(KaibaHand, KaibaDeck);

                        cout<<endl<<"MAIN PHASE"<<endl;

                        //KaibaMainPhase(pFunct, KaibaHand, KaibaDeck, Field, YugiGraveyard, KaibaGraveyard);
                        KaibaMainPhase(pFunct);
                        cout<<endl<<"BATTLE PHASE"<<endl;
                        KaibaBattlePhase(Field, YugiGraveyard, KaibaGraveyard, KaibaLP, YugiLP);
                        cout<<endl<<"END OF TURN"<<"\n"<<endl;
                        }

                        //YUGI'S TURN
                        cout<<endl<<endl<<"YUGI'S TURN"<<endl;
                        YugiDeckSize = YugiDeck.size();
                        if (KaibaDeckSize==0)
                        {
                                cout<<"There are no cards left. YUGI has DECKED OUT"<<endl;
                                break;
                        }
                        cout<<endl<<endl<<"YUGI - DRAW PHASE (Press 1 to draw, 0 to CONCEDE)"<<endl;
                        cin>>DrawChoice;
                        if (DrawChoice==0)
                        {
                                break;
                        }
                       
                        else
                        {
                        DrawForYugi(YugiHand, YugiDeck);
                        cout<<endl<<"MAIN PHASE"<<endl;
                        YugiMainPhase(Field, YugiHand, YugiGraveyard, KaibaGraveyard);
                        cout<<endl<<"BATTLE PHASE"<<endl;
                        YugiBattlePhase(Field, YugiGraveyard, KaibaGraveyard, KaibaLP, YugiLP);
                        cout<<endl<<"END OF TURN"<<"\n"<<endl;
                        }
                }


cout<< "\n"<<"GAME OVER"<<endl;

return 0;
}
//end main()


void KaibaBeginning(vector<Card> &KaibaHand, vector<Card> &KaibaDeck)
{
        cout<<"Kaiba has 8000LP"<<endl;
        cout<<endl<<endl<<"KAIBA - DRAW YOUR FIRST 5 CARDS"<<endl;
        for (int i=1; i<6; i++)
                {
                        cout<<"(Press 1 to draw)"<<endl;
                        cin>>DrawChoice;
                        if (DrawChoice==0)
                        {
                                break;
                        }
                       
                        else
                        {
                        DrawForKaiba(KaibaHand, KaibaDeck);
                        }
                }
}

void YugiBeginning(vector<Card> &YugiHand, vector<Card> &YugiDeck)
{
        cout<<endl<<"Yugi has 8000LP"<<endl;
        cout<<endl<<"YUGI - DRAW YOUR FIRST 5 CARDS"<<endl;
        for (int i=1; i<6; i++)
                {
                        cout<<"(Press 1 to draw)"<<endl;
                        cin>>DrawChoice;
                        if (DrawChoice==0)
                        {
                                break;
                        }
                       
                        else
                        {
                        DrawForYugi(YugiHand, YugiDeck);
                        }
                }
}

---

code continued..

Code:

---

void DrawForKaiba(vector<Card> &KaibaHand, vector<Card> &KaibaDeck)
{
KaibaDeckSize = KaibaDeck.size();
cout<<"BEFORE you draw, there were "<<KaibaDeckSize<<" cards left in the Deck"<<endl;
int DrawKaiba = rand() &#37; KaibaDeckSize + 1;
cout<<"Random number is: "<<DrawKaiba<<" "<<endl;

cout<<"You drew "<<KaibaDeck[DrawKaiba-1].GetName()<<endl;
KaibaHand.push_back(KaibaDeck[DrawKaiba-1]);
KaibaDeck.erase (KaibaDeck.begin()+DrawKaiba-1);
}

void DrawForYugi(vector<Card> &YugiHand, vector<Card> &YugiDeck)
{
YugiDeckSize = YugiDeck.size();
cout<<"BEFORE you draw, there were "<<YugiDeckSize<<" cards left in the Deck"<<endl;
int DrawYugi = rand() % YugiDeckSize + 1;
cout<<"Random number is: "<<DrawYugi<<" "<<endl;

cout<<"You drew "<<YugiDeck[DrawYugi-1].GetName()<<endl;
YugiHand.push_back(YugiDeck[DrawYugi-1]);
YugiDeck.erase (YugiDeck.begin()+DrawYugi-1);
}


void KaibaMainPhase( void (*pFunct)(vector<Card> &KaibaHand, vector<Card> &KaibaDeck, vector< vector<Card> > &Field, vector<Card> &KaibaGraveyard, vector<Card> &YugiGraveyard), vector<Card> &KaibaHand, vector<Card> &KaibaDeck, vector< vector<Card> > &Field, vector<Card> &YugiGraveyard, vector<Card> &KaibaGraveyard)
{
        while(1)//so the while loop NEVER breaks unless you have a 'break' later on
        {
        cout<<"Would you like to continue the Main Phase? (Yes-'1'  No-'0')"<<endl;
        cin>>Decision;
                if (Decision==0)
                {
                        break;
                }

                KaibaHandFunction(KaibaHand);
                cout<<"\n";
                FieldFunction(Field);

                cout<<"Which card in your hand do you wish to play? (if none, press '0')"<<endl;
                cout<<"(Press '-1' for your graveyard, '-2' for Yugi's)"<<endl;
                cin>>HandNumber;
                if (HandNumber==-1)
                {
                        KaibaGraveyardFunction(KaibaGraveyard);
                }
                if (HandNumber==-2)
                {
                        YugiGraveyardFunction(YugiGraveyard);
                }
                else if (HandNumber>0)
                {
                        if (KaibaHand[HandNumber-1].GetStars()==5 || KaibaHand[HandNumber-1].GetStars()==6)//level 5 or 6 - 1 sac
                        {
                        cout<<"You must SACRIFICE one monster to play this card. Enter 1-5 for the Monster you wish to sacrifice (0 to cancel)"<<endl;
                        cin>>SacrificeNumberOne;
                                for (int j=1; j<6; j++)//To choose the Monster to Sacrifice
                                {
                                        if (SacrificeNumberOne==j)
                                        {
                                                cout<<"I will now sacrifice my "<<Field[2][j-1].GetName()<<" .."<<endl;
                                                KaibaGraveyard.push_back(Field[2][j-1]);       
                                                Field[2][j-1]=Card();//Restore the Field slot that the destroyed monster occupied
                                                break;
                                        }
                                }
                        }
                        if (KaibaHand[HandNumber-1].GetStars() > 6)//level 7 or higher - 2 sac
                        {
                        cout<<"You must SACRIFICE TWO monsters to play this card. Enter 1-5 for the Monsters you wish to sacrifice (0 to cancel)"<<endl;
                        cin>>SacrificeNumberOne;
                        cin>>SacrificeNumberTwo;
                                for (int j=1; j<6; j++)//To choose the Monster to Sacrifice
                                {
                                        if (SacrificeNumberOne==j || SacrificeNumberTwo == j)
                                        {
                                                cout<<"I will now sacrifice my "<<Field[2][j-1].GetName()<<".."<<endl;
                                                KaibaGraveyard.push_back(Field[2][j-1]);       
                                                Field[2][j-1]=Card();//Restore the Field slot that the destroyed monster occupied
                                        }
                                }
                        }

cout<<"Where do you want to place this card?"<<endl<<" (1-5 for Monster zones, 6-10 for M/T, 11 for Graveyard)"<<endl;
                        cin>>CardSlot;
                       
                        for (int j=1; j<6; j++)//To play Monster in Monster zone
                        {
                                if (CardSlot==j)
                                {
                                int SummonSet;
                                cout<<"Do you wish to play it in Attack or Defense mode? (1 Atk, 2 Def) "<<endl;
                                cin>>SummonSet;
                                        if (SummonSet==1)
                                        {
                                        Field[2][j-1].SetMode("ATK Mode");
                                        Field[2][j-1].SetFace("Face Up");
                                        }
                                        else if (SummonSet==2)
                                        {
                                        Field[2][j-1].SetMode("DEF Mode");
                                        Field[2][j-1].SetFace("Face Down");
                                        }
                                       
                                KaibaSummon(Field, KaibaHand, HandNumber, j);

                                break;
                                }
                }

                for (int j=6; j<11; j++)//To play M/T in M/T zone
                {
                                if (CardSlot==j)
                                {
                                cout<<"The card is played in slot "<<j-5<<" of the 2nd row"<<endl;
                                Field[3][j-6]=KaibaHand[HandNumber-1];
                                       
                                        if (KaibaHand[HandNumber-1].GetType()=="Trap")
                                        {Field[3][j-6].SetFace("Face Down");}

                                        if (KaibaHand[HandNumber-1].GetType()=="Magic")
                                        {
                                        cout<<"Do you want to play it Face-up or SET it face-down? (Enter 1-face UP, 2-face DOWN)"<<endl;
                                        cin>>FaceEnter;
                                                if (FaceEnter==1)
                                                {
                                                Field[3][j-6].SetFace("Face Up");
                                                cout<<endl<<"I now play my "<<Field[3][j-6].GetName()<<" Magic card! "<<endl;
                                                FieldFunction(Field);
 int FunctNum;
                                                cout<<"Enter a number: "<<endl;
                                                cin>>FunctNum;
                                                        cout<<"You played "<<Field[3][FunctNum-6].GetName();
                                                        pFunct[FunctNum-1](KaibaHand, KaibaDeck, Field, KaibaGraveyard, YugiGraveyard);

                                                cout<<Field[3][j-6].GetName()<<" is now sent to the Graveyard"<<endl;
                                                KaibaGraveyard.push_back(Field[3][j-6]);       
                                                Field[3][j-6]=Card();//Restore the Field slot that the Magic card occupied}
                                                       
                                                if (FaceEnter==2)
                                                {
                                                Field[3][j-6].SetFace("Face Down");
                                                cout<<"I will place one card face down!"<<endl;
                                                }
                                        }

                        KaibaHand.erase (KaibaHand.begin()+HandNumber-1); //Card moves from Hand to field\

                                }
                }
                        if (CardSlot==11)
                        {KaibaDiscard(HandNumber, KaibaHand, KaibaGraveyard);}
                       
                        cout<<"\n";
                        FieldFunction(Field);
                       

                }// end of if Mainhand>0
    }// end of while(1)
}

void YugiMainPhase(vector< vector<Card> > &Field, vector<Card> &YugiHand, vector<Card> &YugiGraveyard, vector<Card> &KaibaGraveyard)
{
        while(1)//so the while loop NEVER breaks unless you have a 'break' later on
        {
        cout<<"Would you like to continue the Main Phase? (Yes-'1'  No-'0')"<<endl;
        cin>>Decision;
                if (Decision==0)
                {
                        break;
                }

                YugiHandFunction(YugiHand);
                cout<<"\n";
                FieldFunction(Field);

                cout<<"Which card in your hand do you wish to play? (if none, press '0')"<<endl;
                cout<<"Press '-1' for Kaiba's graveyard, '-2' for yours)"<<endl;
                cin>>HandNumber;
                if (HandNumber==-1)
                {
                        KaibaGraveyardFunction(KaibaGraveyard);
                }
                if (HandNumber==-2)
                {
                        YugiGraveyardFunction(YugiGraveyard);
                }
                else if (HandNumber>0)
                {

                        if (YugiHand[HandNumber-1].GetStars()==5 || YugiHand[HandNumber-1].GetStars()==6)//level 5 or 6 - 1 sac
                        {
                        cout<<"You must SACRIFICE one monster to play this card. Enter 1-5 for the Monster you wish to sacrifice (0 to cancel)"<<endl;
                        cin>>SacrificeNumberOne;
                                for (int j=6; j<11; j++)//To choose the Monster to Sacrifice
                                {
                                        if (SacrificeNumberOne==j)
                                        {
                                                cout<<"I will now sacrifice my "<<Field[1][j-6].GetName()<<" .."<<endl;
                                                YugiGraveyard.push_back(Field[1][j-6]);       
                                                Field[1][j-6]=Card();//Restore the Field slot that the destroyed monster occupied
                                                break;
                                        }
                                }
                        }
                        if (YugiHand[HandNumber-1].GetStars() > 6)//level 7 or higher - 2 sac
                        {
                        cout<<"You must SACRIFICE TWO monsters to play this card. Enter 1-5 for the Monsters you wish to sacrifice (0 to cancel)"<<endl;
                        cin>>SacrificeNumberOne;
                        cin>>SacrificeNumberTwo;
                                for (int j=6; j<11; j++)//To choose the Monster to Sacrifice
                                {
                                        if (SacrificeNumberOne==j || SacrificeNumberTwo == j)
                                        {
                                                cout<<"I will now sacrifice my "<<Field[1][j-6].GetName()<<" and.."<<endl;
                                                YugiGraveyard.push_back(Field[1][j-6]);       
                                                Field[1][j-6]=Card();//Restore the Field slot that the destroyed monster occupied
                                        }
                                }
                        }

                        cout<<"Where do you want to place this card?"<<endl<<" (1-5 for M/T, 6-10 for Monster, 11 for Graveyard)"<<endl;
                        cin>>CardSlot;
                       
                        for (int j=1; j<6; j++)//To play M/T in M/T zone
                        {
                                        if (CardSlot==j)
                                        {
                                        cout<<YugiHand[HandNumber-1].GetName()<<" is played in slot "<<j<<" of the 1st row"<<endl;
                                        Field[0][j-1]=YugiHand[HandNumber-1];
                                       
                                                if (YugiHand[HandNumber-1].GetType()=="Trap")
                                                {Field[0][j-1].SetFace("Face Down");}

                                                if (YugiHand[HandNumber-1].GetType()=="Magic")
                                                {
                                                cout<<"Do you want to play it Face-up or SET it face-down? (Enter 1-face UP, 2-face DOWN)"<<endl;
                                                cin>>FaceEnter;
                                                        if (FaceEnter==1)
                                                        {Field[0][j-1].SetFace("Face Up");}
                                                        if (FaceEnter==2)
                                                        {Field[0][j-1].SetFace("Face Down");}
                                                }
                                        YugiHand.erase (YugiHand.begin()+HandNumber-1); //Card moves from Hand to field
                                        break;
                                        }
                        }

                        for (int j=6; j<11; j++)//To play Monster in Monster zone
                        {
                                        if (CardSlot==j)
                                        {
                                        int SummonSet;
                                        cout<<"Do you wish to play it in Attack or Defense mode? (1 Atk, 2 Def) "<<endl;
                                        cin>>SummonSet;
                                                if (SummonSet==1)
                                                {
                                                Field[1][j-6].SetMode("ATK Mode");
                                                Field[1][j-6].SetFace("Face Up");
                                                }
                                                else if (SummonSet==2)
                                                {
                                                Field[1][j-6].SetMode("DEF Mode");
                                                Field[1][j-6].SetFace("Face Down");
                                                }

                                        YugiSummon(Field, YugiHand, HandNumber, j);

                                        break;
                                        }
                        }
                        if (CardSlot==11)
                        {
                                YugiDiscard(HandNumber, YugiHand, YugiGraveyard);
                        }
                       
                        cout<<"\n";
                        FieldFunction(Field);


                }// end of if Mainhand>0


    }// end of while(1)

}


void KaibaBattlePhase(vector< vector<Card> > &Field, vector<Card> &YugiGraveyard, vector<Card> &KaibaGraveyard, int& KaLP, int& YuLP)
{
        while(1)//so the while loop NEVER breaks unless you have a 'break' later on
        {
        cout<<"Would you like to continue the Battle Phase? (Yes-'1'  No-'0', Check Kaiba's Graveyard '-1', Check YUGI's graveyard '-2')"<<endl;
        cin>>Decision;
                if (Decision==0)
                {
                        break;
                }
               
                if (Decision==-1)
                {
                        KaibaGraveyardFunction(KaibaGraveyard);
                }
                if (Decision==-2)
                {
                        YugiGraveyardFunction(YugiGraveyard);
                }

        FieldFunction(Field);
        cout<<"\n";
        cout<<"Which Monster card on your field do you wish to attack with?"<<endl;
        cout<<"(Press 1 for monster in 1st slot, etc. If none, press '0')"<<endl;
        cin>>MonsterCard;
        if (MonsterCard==0)
        {break;}
        cout<<"Which Monster on YUGI's field do you want to attack?"<<endl;
        cout<<"(Press 6, NOT 1, for monster in 1st slot, etc. To attack DIRECTLY, press '0')"<<endl;
        cin>>MonsterToAttack;
        cout<<"The ATK of Kaiba's "<<Field[2][MonsterCard-1].GetName()<<" is "<<Field[2][MonsterCard-1].GetAttack()<<endl;
        cout<<"The DEF of Kaiba's "<<Field[2][MonsterCard-1].GetName()<<" is "<<Field[2][MonsterCard-1].GetDefense()<<endl;

        cout<<"The ATK of Yugi's "<<Field[1][MonsterToAttack-6].GetName()<<" is "<<Field[1][MonsterToAttack-6].GetAttack()<<endl;
        cout<<"The DEF of Yugi's "<<Field[1][MonsterToAttack-6].GetName()<<" is "<<Field[1][MonsterToAttack-6].GetDefense()<<endl;
       
        cout<<endl<<"My "<<Field[2][MonsterCard-1].GetName()<<" attacks Yugi's "<<Field[1][MonsterToAttack-6].GetName()<<" !!"<<endl<<endl;

        cout<<"Yugi's monster is in "<<Field[1][MonsterToAttack-6].GetMode()<<endl;

        KaibaBattleFunction(Field, MonsterCard, MonsterToAttack, KaibaGraveyard, YugiGraveyard, KaLP, YuLP);

    }// end of while(1)

}


void YugiBattlePhase(vector< vector<Card> > &Field, vector<Card> &YugiGraveyard, vector<Card> &KaibaGraveyard, int& KaLP, int& YuLP)
{
        while(1)//so the while loop NEVER breaks unless you have a 'break' later on
        {
        cout<<"Would you like to continue the Battle Phase? (Yes-'1'  No-'0', Check Kaiba's Graveyard '-1', Check YUGI's graveyard '-2')"<<endl;
        cin>>Decision;
                if (Decision==0)
                {
                        break;
                }
                if (Decision==-1)
                {
                        KaibaGraveyardFunction(KaibaGraveyard);
                }
                if (Decision==-2)
                {
                        YugiGraveyardFunction(YugiGraveyard);
                }

        FieldFunction(Field);
        cout<<"\n";
        cout<<"Which Monster card on your field do you wish to attack with?"<<endl;
        cout<<"(Press 6, NOT 1, for monster in 1st slot, etc. If none, press '0')"<<endl;
        cin>>MonsterCard;
        if (MonsterCard==0)
        {break;}
        cout<<"Which Monster on KAIBA's field do you want to attack?"<<endl;
        cout<<"(Press 1, for monster in 1st slot, etc. To attack DIRECTLY, press '0')"<<endl;
        cin>>MonsterToAttack;

        cout<<"The ATK of Yugi's "<<Field[1][MonsterCard-6].GetName()<<" is "<<Field[1][MonsterCard-6].GetAttack()<<endl;
        cout<<"The DEF of Yugi's "<<Field[1][MonsterCard-6].GetName()<<" is "<<Field[1][MonsterCard-6].GetDefense()<<endl;
       
        cout<<"The ATK of Kaiba's "<<Field[2][MonsterToAttack-1].GetName()<<" is "<<Field[2][MonsterToAttack-1].GetAttack()<<endl;
        cout<<"The DEF of Kaiba's "<<Field[2][MonsterToAttack-1].GetName()<<" is "<<Field[2][MonsterToAttack-1].GetDefense()<<endl;

        cout<<endl<<"My "<<Field[1][MonsterCard-6].GetName()<<" attacks Kaiba's "<<Field[2][MonsterToAttack-1].GetName()<<" !!"<<endl<<endl;

        cout<<"Kaibas monster is in "<<Field[2][MonsterToAttack-1].GetMode()<<endl;

        YugiBattleFunction(Field, MonsterCard, MonsterToAttack, KaibaGraveyard, YugiGraveyard, KaLP, YuLP);


    }// end of while(1)

}



void FieldFunction(vector< vector<Card> > &Field)
{
                        cout<<endl<<"Yugi's M/T Field contains: "<<endl;
                        for (int i=0; i<5; i++)
                        {
                                cout<<i+1<<". ";
                                if (Field[0][i].GetFace()=="Face Up")
                                {
                                        cout<<Field[0][i].GetName();
                                }
                                if (Field[0][i].GetFace()=="Face Down")
                                {
                                        cout<<"FACE DOWN CARD";
                                }
                                cout<<"\t";
                        }                       
                        cout<<endl<<"Yugi's Monster Field contains: "<<endl;
                        for (int i=0; i<5; i++)
                        {
                                cout<<i+6<<". ";
                                if (Field[1][i].GetFace()=="Face Up")
                                {
                                        cout<<Field[1][i].GetName()<<" - "<<Field[1][i].GetMode();
                                }
                                if (Field[1][i].GetFace()=="Face Down")
                                {
                                        cout<<"FACE DOWN CARD";
                                }
                                cout<<"\t";
                        }
                        cout<<"\n";

                        cout<<endl<<"Kaiba's Monster Field contains: "<<endl;
                        for (int i=0; i<5; i++)
                        {
                                cout<<i+1<<". ";
                                if (Field[2][i].GetFace()=="Face Up")
                                {
                                cout<<Field[2][i].GetName()<<" - "<<Field[2][i].GetMode();
                                }
                                if (Field[2][i].GetFace()=="Face Down")
                                {
                                        cout<<"FACE DOWN CARD"<<"\t";
                                }
                                cout<<"\t";
                        }
       
                        cout<<endl<<"Kaiba's M/T Field contains: "<<endl;
                        for (int i=0; i<5; i++)
                        {
                                cout<<i+6<<". ";
                                if (Field[3][i].GetFace()=="Face Up")
                                {
                                        cout<<Field[3][i].GetName();
                                }
                                if (Field[3][i].GetFace()=="Face Down")
                                {
                                        cout<<"FACE DOWN CARD";
                                }
                                cout<<"\t";
                        }
                        cout<<endl<<endl;
}



void KaibaHandFunction(vector<Card> &KaibaHand)
{
                cout<<endl<<"Kaiba's hand contains: "<<endl;
                for (KH=KaibaHand.begin(); KH<KaibaHand.end(); KH++)
                {
                        cout<<KH->GetName()<<endl;

                }
}

void YugiHandFunction(vector<Card> &YugiHand)
{
                cout<<endl<<"Yugi's hand contains: "<<endl;
                for (YH=YugiHand.begin(); YH<YugiHand.end(); YH++)
                {
                        cout<<YH->GetName()<<endl;

                }
}

void KaibaGraveyardFunction(vector<Card> &KaibaGraveyard)
{
                        cout<<endl<<"Kaiba's graveyard contains: "<<endl;
                        for (KG=KaibaGraveyard.begin(); KG<KaibaGraveyard.end(); KG++)
                        {
                                cout<<KG->GetName()<<endl; //SAME AS (*gt).GetName
                        }
                        cout<<"\n";
}

void YugiGraveyardFunction(vector<Card> &YugiGraveyard)
{
                        cout<<endl<<"Yugi's graveyard contains: "<<endl;
                        for (YG=YugiGraveyard.begin(); YG<YugiGraveyard.end(); YG++)
                        {
                                cout<<YG->GetName()<<endl; //SAME AS (*gt).GetName
                        }
                        cout<<"\n";
}

void KaibaSummon(vector< vector<Card> > &Field, vector<Card> &KaibaHand, int HandNumber, int MonstCount)
{
                Field[2][MonstCount-1].SetName( KaibaHand[HandNumber-1].GetName() );
                Field[2][MonstCount-1].SetAttack( KaibaHand[HandNumber-1].GetAttack() );
                Field[2][MonstCount-1].SetDefense( KaibaHand[HandNumber-1].GetDefense() );
                if (Field[2][MonstCount-1].GetMode() == "ATK Mode")
                        {
                                cout<<endl<<"I summon my "<<Field[2][MonstCount-1].GetName()<<" in ATTACK MODE! ";
                        }
                else
                        {
                                cout<<"I place one monster in Defense MODE! ";
                        }
                KaibaHand.erase (KaibaHand.begin()+HandNumber-1); //Card moves from Hand to field
}

void YugiSummon(vector< vector<Card> > &Field, vector<Card> &YugiHand, int HandNumber, int MonstCount)
{
                Field[1][MonstCount-6].SetName( YugiHand[HandNumber-1].GetName() );
                Field[1][MonstCount-6].SetAttack( YugiHand[HandNumber-1].GetAttack() );
                Field[1][MonstCount-6].SetDefense( YugiHand[HandNumber-1].GetDefense() );
                if (Field[1][MonstCount-6].GetMode() == "ATK Mode")
                        {
                                cout<<endl<<"I summon my "<<Field[1][MonstCount-6].GetName()<<" in ATTACK MODE! ";
                        }
                else
                        {
                                cout<<"I place one monster in Defense MODE! ";
                        }
                YugiHand.erase (YugiHand.begin()+HandNumber-1); //Card moves from Hand to field
}

void KaibaDiscard(int HandNumber, vector<Card> &KaibaHand, vector<Card> &KaibaGraveyard)
{
        cout<<KaibaHand[HandNumber-1].GetName()<<" is discarded to the Graveyard"<<endl;
        KaibaGraveyard.push_back(KaibaHand[HandNumber-1]);
        KaibaHand.erase (KaibaHand.begin()+HandNumber-1); //Discarded card is now erased from Hand       
}

void YugiDiscard(int HandNumber, vector<Card> &YugiHand, vector<Card> &YugiGraveyard)
{
        cout<<YugiHand[HandNumber-1].GetName()<<" is discarded to the Graveyard"<<endl;
        YugiGraveyard.push_back(YugiHand[HandNumber-1]);
        YugiHand.erase (YugiHand.begin()+HandNumber-1); //Discarded card is now erased from Hand       
}

---

code continued..

Code:

---

void KaibaBattleFunction(vector< vector<Card> > &Field, int MonsterCard, int MonsterToAttack, vector<Card> &KaibaGraveyard, vector<Card> &YugiGraveyard, int& KaLP, int& YuLP)
{
                if ( Field[1][MonsterToAttack-6].GetMode()=="ATK Mode") 
                {
                if( Field[2][MonsterCard-1].GetAttack() > Field[1][MonsterToAttack-6].GetAttack() )//Kaiba's monster's ATK > Yugi ATK
                {
                cout<<Field[1][MonsterToAttack-6].GetName()<<" is DESTROYED"<<endl<<endl;
                YugiGraveyard.push_back(Field[1][MonsterToAttack-6]);       
                YuLP=YuLP-( Field[2][MonsterCard-1].GetAttack() - Field[1][MonsterToAttack-6].GetAttack() ); //LP subtracted if destroyed monster is in ATK mode
                cout<<"Yugi now has "<<YuLP<<" Life Points "<<endl<<endl;
                Field[1][MonsterToAttack-6]=Card();//Restore the Field slot that the destroyed monster occupied
                }

                if( Field[2][MonsterCard-1].GetAttack() < Field[1][MonsterToAttack-6].GetAttack() )//Kaiba's monster's ATK < Yugi ATK
                {
                cout<<Field[2][MonsterCard-1].GetName()<<" is DESTROYED"<<endl<<endl;
                KaibaGraveyard.push_back(Field[2][MonsterCard-1]);       
                KaLP=KaLP-( Field[1][MonsterToAttack-6].GetAttack() - Field[2][MonsterCard-1].GetAttack() );
                cout<<"Kaiba now has "<<KaLP<<" Life Points "<<endl<<endl;
                Field[2][MonsterCard-1]=Card();//Restore the Field slot that the destroyed monster occupied
                }
        }

        if ( Field[1][MonsterToAttack-6].GetMode()=="DEF Mode" )//Kaiba's monster's ATK > Yugi DEF
        {
                if ( Field[2][MonsterCard-1].GetAttack() > Field[1][MonsterToAttack-6].GetDefense() )
                {
                cout<<Field[1][MonsterToAttack-6].GetName()<<" is DESTROYED"<<endl<<endl;
                YugiGraveyard.push_back(Field[1][MonsterToAttack-6]);        // NO LP subtracated if card in DEF mode
                Field[1][MonsterToAttack-6]=Card();//Restore the Field slot that the destroyed monster occupied
                }
                       
                if ( Field[2][MonsterCard-1].GetAttack() < Field[1][MonsterToAttack-6].GetDefense() )//Kaiba ATK < Yugi DEF
                {
                KaLP=KaLP-( Field[1][MonsterToAttack-6].GetDefense() - Field[2][MonsterCard-1].GetAttack() ); //LP subtracted
                cout<<"Kaiba now has "<<KaLP<<" Life Points "<<endl<<endl;
                Field[1][MonsterToAttack-6].SetFace("Face Up");

                }
        }
}

void YugiBattleFunction(vector< vector<Card> > &Field, int MonsterCard, int MonsterToAttack, vector<Card> &KaibaGraveyard, vector<Card> &YugiGraveyard, int& KaLP, int& YuLP)
{
        if ( Field[2][MonsterToAttack-1].GetMode()=="ATK Mode") 
        {
                if( Field[1][MonsterCard-6].GetAttack() > Field[2][MonsterToAttack-1].GetAttack() )
                {
                cout<<Field[2][MonsterToAttack-1].GetName()<<" is DESTROYED"<<endl<<endl;
                KaibaGraveyard.push_back(Field[2][MonsterToAttack-1]);       
                KaLP=KaLP-( Field[1][MonsterCard-6].GetAttack() - Field[2][MonsterToAttack-1].GetAttack() );
                cout<<"Kaiba now has "<<KaLP<<" Life Points "<<endl<<endl;
                Field[2][MonsterToAttack-1]=Card();//Restore the Field slot that the destroyed monster occupied
                }
                if( Field[1][MonsterCard-6].GetAttack() < Field[2][MonsterToAttack-1].GetAttack() )
                {
cout<<Field[1][MonsterCard-6].GetName()<<" is DESTROYED"<<endl<<endl;
                YugiGraveyard.push_back(Field[1][MonsterCard-6]);       
                YuLP=YuLP-(Field[2][MonsterToAttack-1].GetAttack() - Field[1][MonsterCard-6].GetAttack() );
                cout<<"Yugi now has "<<YuLP<<" Life Points "<<endl<<endl;
                Field[1][MonsterCard-6]=Card();//Restore the Field slot that the destroyed monster occupied
        }
        }

                if ( Field[2][MonsterToAttack-1].GetMode()=="DEF Mode" )
{
                if ( Field[1][MonsterCard-6].GetAttack() > Field[2][MonsterToAttack-1].GetDefense() )//Yugi ATK > Kaiba DEF
                {
                cout<<Field[2][MonsterToAttack-1].GetName()<<" is DESTROYED"<<endl<<endl;
                KaibaGraveyard.push_back(Field[2][MonsterToAttack-1]);        // NO LP subtracated if card in DEF mode
                Field[2][MonsterToAttack-1]=Card();//Restore the Field slot that the destroyed monster occupied
                }       
                if ( Field[1][MonsterCard-6].GetAttack() < Field[2][MonsterToAttack-1].GetDefense() )//Yugi ATK < Kaiba DEF
                {
                YuLP=YuLP-( Field[2][MonsterToAttack-1].GetDefense() - Field[1][MonsterCard-6].GetAttack() ); //LP subtracted
                cout<<"Yugi now has "<<YuLP<<" Life Points "<<endl<<endl;
                Field[2][MonsterToAttack-1].SetFace("Face Up");
                }
        }
}

---

Ok I posted the entire code, with the changes you suggested.

The old errors are gone, but I got a new one. "error C2109: subscript requires array or pointer type"

referring to this

Code:

---

pFunct[FunctNum-1](KaibaHand, KaibaDeck, Field, KaibaGraveyard, YugiGraveyard);

---

This is confusing me. I thought I already defined pFunct as an array here? :

Code:

---

FunctType pFunct[2];
        //void (* pFunct[2]) (vector<Card> &KaibaHand, vector<Card> &KaibaDeck, vector< vector<Card> > &Field, vector<Card> &KaibaGraveyard, vector<Card> &YugiGraveyard);
        pFunct[0] = HEAVYSTORM;
        pFunct[1] = POTOFGREED;

---

Quote:

---

Originally Posted by larry burns

code continued..

---

I guess I didn't make my point more clear about needing to post thousands of lines of code to simulate a compiler error. You seem to erroneously believe that compiler errors only come about by writing a lot of code.

OK, so you're having trouble calling a function, so why don't you take the minimal example I posted, and attempt to call a function? There is no need to post pages and pages of code. No one is going to go through all of that code just to address a simple compiler error. A good programmer always has a small test program or programs to figure out various functions, C++ syntax, etc. Then when they are familiar with how to use C++, then they apply it to their larger programs.

Code:

---

#include <vector>

using namespace std;

class Card
{ };

typedef void (*FuncType)(
              vector<Card> &,
              vector<Card> &,
              vector< vector<Card> > &,
              vector<Card> &,
              vector<Card> &);

void KMP( FuncType* fn )
{
    vector<Card> v1;
    vector<vector<Card> > v2;
    fn[0]( v1, v1, v2, v1, v1);  // calls the HEAVYSTORM function
}

void HEAVYSTORM(vector<Card> &,
                vector<Card> &,
                vector< vector<Card> > &,
                vector<Card> &,
                vector<Card> &);

void POTOFGREED(vector<Card> &,
                              vector<Card> &,
                              vector< vector<Card> > &,
                              vector<Card> &,
                              vector<Card> &);

int main()
{
    FuncType pFunct[2];
    pFunct[0] = HEAVYSTORM;
    pFunct[1] = POTOFGREED;
    KMP(pFunct);
}

---

This code compiles correctly, and calls the first function in the array. Again, I don't care what the function does or is supposed to do -- those functions could be called anything (I was tired typing in those long function names you have, so I used KMP)" and those vectors could be completely empty, it isn't important when fixing a compiler error. All that's needed is enough to simulate the arguments being passed.

Regards,

Paul McKenzie