Problème d'execution

Bonjour.

Voilà, je suis en réseaux et telecom et j'ai un projet du style "pacman à réaliser".
Le programme que j'ai fais pour le moment compile. Mais il plante quand je l'execute. Si quelqu'un avait une solution.

Voici mon programme:


//Jeu basique !

#include <iostream>
#include <iomanip>
#include <myconio.h>


#define UP 72
#define DOWN 80
#define LEFT 75
#define RIGHT 77
#define ESC 27

#define NBLIGNES 20
#define NBCOLONNES 20
#define NBL NBLIGNES
#define NBC NBCOLONNES

#define NORD 'n'
#define SUD 's'
#define EST 'e'
#define OUEST 'o'

#define MUR 3
#define VIDE 0
#define ETOILE 2
#define PIPIL 1

#define CMUR '#'
#define CVIDE '1'
#define CETOILE '*'
#define CPIPIL 'O'




using namespace std;
//--------------------------------------------------------------------------------------------------------------------------------
//PROTOTYPES
//--------------------------------------------------------------------------------------------------------------------------------


void effaceTerrain(int TabTerrain[NBL][NBC]);
void genereEtoile(int TabTerrain[NBL][NBC]);
void generePion(int TabTerrain[NBL][NBC],int & Pl,int & Pc);
void afficheTerrain(int TabTerrain[NBL][NBC]);
void affichePion(int & Pc,int & Pl);
int lectureTouche(int & touche);
int avancePion(int TabTerrain[NBL][NBC],int touche,int & Pc,int & Pl);
int casePointee(int touche,int TabTerrain[NBL][NBC],int Pl,int Pc,int & CasePL,int & CasePC);
void videCase(int TabTerrain[NBL][NBC],int CasePL,int CasePC);





//--------------------------------------------------------------------------------------------------------------------------------
//PROGRAMME PRINCIPAL
//--------------------------------------------------------------------------------------------------------------------------------



int main (void)
{
int TabTerrain[NBL][NBC];
int Pc,Pl;
int Reconnu;
int touche;
int MiamEtoile;
int NBEtoile;
int CasePC,CasePL;



effaceTerrain(TabTerrain); //initialise le tableau a VIDE

genereEtoile(TabTerrain); //Genere coordonnées d'une etoile (aleatoire)

generePion(TabTerrain,Pc,Pl); //Genere les coordonnées du PIPILMAN
getch();
do
{

afficheTerrain(TabTerrain); //Affiche a l'écran le terrain
getch();
do
{

affichePion(Pc,Pl); //Affiche le Pion

getch();
do
{
Reconnu=lectureTouche(touche); //Lecture touche
}
while ( Reconnu!=1);

if(touche !=ESC)
{
MiamEtoile=avancePion(TabTerrain,touche,Pc,Pl); //Avancement du PILPILMAN sous condition
}

}while ( (MiamEtoile!=1 ) && (touche !=ESC) );

NBEtoile=NBEtoile+1;

if ((NBEtoile != 10) && (touche !=ESC))
{
videCase(TabTerrain,CasePC,CasePL);

genereEtoile(TabTerrain);
}

}while ((NBEtoile!=10) && (touche !=ESC));

if (touche !=ESC)
{

cout<<"OKI!";
//fin();
//menuPrincipal();
}








getch ();
return 0;


}


//---------------------------------------------------------------------------------------------------------------------------------
// FONCTIONS
//---------------------------------------------------------------------------------------------------------------------------------





void effaceTerrain(int TabTerrain[NBL][NBC])
{
int c,l;

for (l=0;l<NBL;l++)
{
for (c=0;c<NBC;c++)
{
TabTerrain[l][c]=VIDE;
}
}
}

void genereEtoile(int TabTerrain[NBL][NBC])
{

int n1,n2;


srand (time (NULL) ) ;

do
{

n1=rand();
n1=(n1%NBL);

n2=rand();
n2=(n2%NBC);

if (TabTerrain[n1][n2]==VIDE)
{
TabTerrain[n1][n2]=ETOILE;
}

}while(TabTerrain[n1][n2]!=ETOILE);

}

void generePion(int TabTerrain[NBL][NBC],int & Pl,int & Pc)
{


int n1,n2;



srand (time (NULL) ) ;

do
{

n1=rand();
n1=(n1%NBL);

n2=rand();
n2=(n2%NBC);

if (TabTerrain[n1][n2]==VIDE)
{
TabTerrain[n1][n2]=PIPIL;
}

}while(TabTerrain[n1][n2]!=PIPIL);
Pl=n1;
Pc=n2;
}

void afficheTerrain(int TabTerrain[NBL][NBC])
{
int c,l;
int CASE;

for (l=0;l<NBL;l++)
{
for (c=0;c<NBC;c++)
{
CASE=TabTerrain[l][c];

switch(CASE)
{
case VIDE : cout<<CVIDE;
break;
case ETOILE : cout<<CETOILE;
break;
default: cout<<"?";
}


}
cout<<endl;
}
}

void affichePion(int & Pc,int & Pl)
{

gotoxy(Pc,Pl);
cout<<PIPIL;
}


int lectureTouche(int & touche)
{

int reconnu;
int caractere_etendu=-1;

touche=getch();
if(touche==224 || touche==0)

{
caractere_etendu=touche;
touche=getch();
}

if(caractere_etendu==-1)
{

switch(touche)
{
case UP : reconnu=1;
break;
case DOWN : reconnu=1;
break;
case LEFT : reconnu=1;;
break;
case RIGHT : reconnu=1;
break;
case ESC : reconnu=1;
break;
default : reconnu=0;
}

}

return reconnu;

}

int avancePion(int TabTerrain[NBC][NBL],int touche,int & Pc,int & Pl)
{
int valcase;
int MiamEtoile;
int CasePL,CasePC;

valcase=casePointee(touche,TabTerrain,Pc,Pl,CasePL,CasePC);

switch (valcase)
{
case VIDE: MiamEtoile=0;Pl=CasePL;Pc=CasePC;
break;
case ETOILE: MiamEtoile=1;Pl=CasePL;Pc=CasePC;
break;
default :;

}
return MiamEtoile;
}

int casePointee(int touche,int TabTerrain[NBL][NBC],int Pc,int Pl,int & CasePL,int & CasePC)
{
int valcase;



switch(touche)
{
case UP :

if ((Pl-1)<0)
{
valcase=TabTerrain[NBL][Pc];
CasePL=NBL;
CasePC=Pc;
}
else
{
valcase=TabTerrain[Pl-1][Pc];CasePL=Pl-1;CasePC=Pc;
}

break;

case DOWN :
if ((Pl+1)>NBL)
{
valcase=TabTerrain[0][Pc];
CasePL=0;
CasePC=Pc;
}

else
{
valcase=TabTerrain[Pl+1][Pc];CasePL=Pl+1;CasePC=Pc;
}
break;

case LEFT :
if ((Pc-1)<0)
{
valcase=TabTerrain[Pl][NBC];
CasePL=Pl;
CasePC=NBC;
}
else
{
valcase=TabTerrain[Pl][Pc-1];CasePL=Pl;CasePC=Pc-1;
}


break;

case RIGHT :
if ((Pc+1)>NBC)
{
valcase=TabTerrain[Pl][0];
CasePL=Pl;
CasePC=0;
}

else
{
valcase=TabTerrain[Pl][Pc+1];CasePL=Pl;CasePC=Pc+1;
}
break;

default : ;
}
return valcase;
}

void videCase(int TabTerrain[NBL][NBC],int CasePL,int CasePC)
{

TabTerrain[CasePL][CasePC]=VIDE;
}






Merci d'avance.