Aha! serpent, en c tout court, avec editeur de niveaux, ennemis et mode d'emploi...
Description
le jeu du serpent, ecrit en c dans le cadre de mon BTS.
Avec des ennemis, un editeur de niveaux etc..
Ne vous attendez pas a un jeu en 4d en 1900*1600, ce jeu n'utilise que les fonctions du C, donc pas de directx ou autres ALLEGRO (c la faute du prof).
Bon ok, sur le site on voit pas les tabulations et les caractères ascii un peu speciaux...
Donc la mise en page est crade. Le mieux est de prendre le zip, y'a les sources, les niveaux et le mode d'emploi...
Compilé avec Rhide/djgpp
Si quelqu'un a le courage de réactiver les déplacements en diagonales des ennemis, et qu'il corrige le bug, qu'il me fasse signe, merci (y'avai un bug sur le test de collision, en diagonale, un ennemi pouvait sauter un obstacle).
Bon je pense avoir assez commenté le source, mais si vous avez des question, mailez...
Enjoy!
PS:Désolé ANSI/POSIX...
VOTEZ, PLEASE!!!!!
Avec des ennemis, un editeur de niveaux etc..
Ne vous attendez pas a un jeu en 4d en 1900*1600, ce jeu n'utilise que les fonctions du C, donc pas de directx ou autres ALLEGRO (c la faute du prof).
Source / Exemple :
/////////////////////////////////////////////////////////////////////////
// //
// Action Professionelle 2002: //
// //
// SERPENT //
// //
// PERNES Olivier BTSIG1 //
// //
// "COMMUN.H" //
// //
// //
/////////////////////////////////////////////////////////////////////////
#include <conio.h>
#include <stdlib.h>
#include <time.h>
#include <stdio.h>
int taperdu; //J'suis mort ou pas?? (0 ou 1)
int score; //score en cours (0-9)
struct { //Structure du serpent:
int x; // position en x du serpent
int y; // position en y du serpent
int dir; // direction du serpent
int lgQueue; // longueur de la queue
struct { // 'matrice' de queue:
int x; // coordonne en X
int y; // coordonne en Y
}queue[42]; // 42 elements max
}serpent;
struct { //Structure des balles:
int x; // Position en X
int y; // Position en Y
int incx; // Incrmentation en X
int incy; // Incrmentation en Y
}baballe[10]; // 10 balles maximum
struct { //Structure des niveaux:
int EnCours; // Index en cours de Liste
int NbMax; // Total de niveaux
int Liste[100]; // Liste des numros de niveaux
} Niveaux;
int MAT[43][80]; //Matrice reprsentant l'ecran (1=mur,2=pomme)
void Message(char l1[74],char l2[74],char l3[74]);
void FaireNiveau();
void ObtenirNiveaux();
int Editeur(int nivo);
void place_baballes();
void deplace_baballes();
int menu();
/////////////////////////////////////////////////////////////////////////
// //
// Action Professionelle 2002: //
// //
// SERPENT //
// //
// PERNES Olivier BTSIG1 //
// //
// "EDITOR.C" //
// //
// //
/////////////////////////////////////////////////////////////////////////
#include "commun.h"
int Editeur(int nivo)
{
char temp[64]; //Sert pour le nom de fichier lors de l'ecriture
FILE *fichier; //Pointeur vers le fichier a ouvrir
int touche=0,fin=0; //Quelle touche appuye?? Avons nous fini??
int x,y; //Variables utilises pour parcourir la matrice
int curseurx,curseury; //Position du curseur
curseurx=40; //Place le curseur au milieu de l'ecran
curseury=21;
//Definition du nom de fichier en fonction du numro en argument
sprintf(temp,"level%d.dat",nivo);
if (__file_exists(temp)==0) //Detecte si le fichier existe deja
{
//Dans le cas ou le fichier n'existe pas:
//'Dessine' les murs du jeu dans la matrice:
//1)Rinitialise cette derniere:
for (x=0;x<=79;x++)
for (y=0;y<=42;y++)
MAT[y][x]=0;
//2)'Trace' les bordures haute et basse
for (x=0;x<=79;x++)
{MAT[0][x]=1; MAT[42][x]=1;}
//3)'Trace' les bordures gauche et droite
for (y=0;y<=42;y++)
{MAT[y][0]=1; MAT[y][79]=1;}
}
else {
//Dans le cas ou le fichier existe, charger le niveau dans la matrice
fichier = fopen(temp,"r");
for (y=0;y<43;y++) //43 lignes (0-42)
for (x=0;x<81;x++) //81 car 0-79 + 2 car. de retour ligne
{
touche=fgetc(fichier); //Stocke le caractere suivant dans touche
if (touche>=48) MAT[y][x]=touche-48; //>48 ascii = >0 (donc pas de retour
} //charriot ou autre car. systemes
fclose(fichier); //Ferme le fichier
}
textattr((BLUE << 4) | WHITE); //Rend le fond de texte bleu et le txt blanc
clrscr();
while (!(fin==1)) {
//Scanne la matrice pour y trouver des 1:
for (x=0;x<=79;x++)
for (y=0;y<=42;y++)
{
if (MAT[y][x]!=0)
ScreenPutChar('Û', (BLUE << 4) | WHITE, x, y);//Trace les murs
}
//Affiche le curseur:
if (MAT[curseury][curseurx]==0)
ScreenPutChar('_', BLINK | (BLUE << 4) | LIGHTMAGENTA, curseurx,curseury);
else
//Si l'on est deja sur un mur, changer la couleur du mur.
ScreenPutChar('Û', (BLUE << 4) | LIGHTMAGENTA,curseurx,curseury );
while (!kbhit()); //Attendre une touche
//Efface le curseur avant de repositionner le suivant
ScreenPutChar(' ', (BLUE << 4), curseurx,curseury);
touche=getch(); //Recupere le code ASCII de la touche
if (touche==32) //Si on appuie sur espace: inverser le statut du mur:
MAT[curseury][curseurx] = !MAT[curseury][curseurx];// 0=absent et 1=present
if (touche==27) //Echap = Terminer
{
fin=1;
break;
}
if (touche==0) //0: touche tendue
touche = getch(); //|->rcuperer le code de la touche tendue
switch(touche){
case 'H': //haut
if (curseury>1)
curseury--; //Monte le curseur
break;
case 'M': //droite
if (curseurx<78)
curseurx++;
break;
case 'P': //bas
if (curseury<41)
curseury++;
break;
case 'K': //gauche
if (curseurx>1)
curseurx--;
break;
}
}
//Demande la confirmation de l'enregistrement du fichier
touche = -1;
while ((touche <0)||(touche >1))
{
clrscr();
Message("Editeur:","Voulez vous enregistrer???","(tapez 0 pour oui ou 1 pour non): ");
ScreenSetCursor(45/2,57); //Place le curseur a la fin de la phrase
scanf("%d",&touche); //Saisie du chiffre
}
if (touche==0)
{
//Ecrit la matrice MAT dans le fichier...
//ouvre le fichier en mode criture
fichier=fopen(temp,"w");
//Pour tous les elements de la matrice:
for (y=0;y<43;y++)
for (x=0;x<80;x++)
{//2)vrifier la matrice, en cas d'erreur, remplacer par un mur (1)
if ((MAT[y][x]>1)||(MAT[y][x]<0)) MAT[y][x] = 1;
//3)ecrire dans le fichier le caractere en cours
fputc(MAT[y][x]+48,fichier); // 0 + 48 = '0'et 1 + 48 = '1'
if (x==79) fputc(10,fichier);}//Si on est en fin de ligne rajouter un
fclose(fichier); //LineFeed
}
return(0);
}
/////////////////////////////////////////////////////////////////////////
// //
// Action Professionelle 2002: //
// //
// SERPENT //
// //
// PERNES Olivier BTSIG1 //
// //
// "LEVEL.C" //
// //
// //
/////////////////////////////////////////////////////////////////////////
#include <dir.h>
#include "commun.h"
/////////////////////////////////////////////////////////////////////////
// //
// FAIRENIVEAU: Lit le fichier de niveau, place //
// les infos dans la matrice MAT, et affiche les //
// murs. //
// //
/////////////////////////////////////////////////////////////////////////
void FaireNiveau()
{
int x,y;
int lettre;
char tmp[50];
FILE *fichier;
strcpy(tmp,"level"); // "levelX.dat"
strcat(tmp,itoa(Niveaux.Liste[Niveaux.EnCours],NULL,9));
strcat(tmp,".dat");
fichier = fopen(tmp,"r");
for (y=0;y<43;y++) //43 lignes (0-42)
for (x=0;x<81;x++) //81 car 0-79 + 2 car. de retour ligne
{
lettre=fgetc(fichier);
if (lettre>=48) MAT[y][x]=lettre-48; //>48 ascii = >0 (donc pas de retour
} //charriot ou autre car. systemes
fclose(fichier); //Ferme le fichier
for (y=0;y<43;y++)
for (x=0;x<80;x++)
if (MAT[y][x]==1) // Si on a un mur (1):
ScreenPutChar('Û', WHITE, x, y); // l'afficher
return;
}
/////////////////////////////////////////////////////////////////////////
// //
// PLACEPOINT: Place alatoirement le point a //
// manger pour le serpent. //
// //
/////////////////////////////////////////////////////////////////////////
void PlacePoint()
{
int x,y;
int good=0;
while (!(good==1))
{
x = (random()%77)+1; //80-2 (pour les murs), soit de 0-77
y = (random()%41)+1; //43-2 (pour les murs), soit de 0-41
if (MAT[y][x]==0) //Vrifie que la place est libre
{ //dans la matrice,
MAT[y][x]=2; //et y place un 2
cet endroit
good=1;
}
}
ScreenPutChar(48+score, GREEN | (BLUE<<4), x, y); // Afficher le point
}
/////////////////////////////////////////////////////////////////////////
// //
// MESSAGE:affiche une boite de dialogue //
// avec trois lignes (l1,l2etl3) //
// //
/////////////////////////////////////////////////////////////////////////
void Message(char l1[74],char l2[74],char l3[74])
{
int lignes=0,nbCarac=0; //Nb de lignes et nb de caracteres
int X=0,Y=0; //Position de la fenetre
char fnL1[78]={},fnL2[74]={},fnL3[74]={},fnL4[74]={},fnL5[74]={};
int i=0;
clrscr();
//Redessine la matrice
for (Y=0;Y<43;Y++)
for (X=0;X<80;X++)
{
if (MAT[Y][X]==1) //Redessine les murs
ScreenPutChar('Û', WHITE|(BLUE << 4), X, Y);
if (MAT[Y][X]==2) //Redessine les points
ScreenPutChar(48+score, BLINK|GREEN|(BLUE << 4), X, Y);
if (MAT[Y][X]==3) //Redessine les balles
ScreenPutChar('', BLINK|RED|(BLUE << 4), X, Y);
}
//Dtermine le nombre de caractres max a afficher et le nb de lignes
if (strlen(l1)>0) lignes++;
if (strlen(l2)>0) lignes++;
if (strlen(l3)>0) lignes++;
if ((strlen(l1)>=strlen(l2))&&((strlen(l1)>=strlen(l3)))) nbCarac=strlen(l1);
if ((strlen(l2)>=strlen(l1))&&((strlen(l2)>=strlen(l3)))) nbCarac=strlen(l2);
if ((strlen(l3)>=strlen(l1))&&((strlen(l3)>=strlen(l2)))) nbCarac=strlen(l3);
//Determine la position de la fenetre selon les infos ci dessus (centree)
X = (80 / 2) - (nbCarac+4)/2;
Y = (43 / 2) - (lignes+2 )/2;
//Genere la fenetre ligne par ligne:
//ligne 1 (que la bordure suprieure)
strcpy(fnL1,"É");
for (i=0;i<nbCarac+2;i++)
strcat(fnL1,"Í"); //remplit la ligne selon le nb de car max
strcat(fnL1,"»");
//Lignes 2-4 : en 3 parties :
sprintf(fnL2,"Ý %s",l1); //1)bordure gauche+texte de la ligne
sprintf(fnL3,"Ý %s",l2);
sprintf(fnL4,"Ý %s",l3);
if (strlen(fnL2)<strlen(fnL1)-2) //2)comble la fin de la ligne si besoin
while(strlen(fnL2)<strlen(fnL1)-2) // par des espaces
strcat(fnL2," ");
strcat(fnL2," Þ"); //3)bordure droite
if (strlen(fnL3)<strlen(fnL1)-2)
while(strlen(fnL3)<strlen(fnL1)-2)
strcat(fnL3," ");
strcat(fnL3," Þ");
if (strlen(fnL4)<strlen(fnL1)-2)
while(strlen(fnL4)<strlen(fnL1)-2)
strcat(fnL4," ");
strcat(fnL4," Þ");
//Ligne Nø5 (bordure basse)
strcpy(fnL5,"È");
for (i=0;i<nbCarac+2;i++)
strcat(fnL5,"Í");
strcat(fnL5,"¼");
//Affichage proprement dit de la bote
ScreenSetCursor(Y,X);
printf("%s\n",fnL1);Y++;
ScreenSetCursor(Y,X);
if (strlen(l1)!=0) {printf("%s\n",fnL2);Y++;}
ScreenSetCursor(Y,X);
if (strlen(l2)!=0) {printf("%s\n",fnL3);Y++;}
ScreenSetCursor(Y,X);
if (strlen(l3)!=0) {printf("%s\n",fnL4);Y++;}
ScreenSetCursor(Y,X);
printf("%s\n",fnL5);
}
/////////////////////////////////////////////////////////////////////////
// //
// OBTENIRNIVEAUX:parcours le repertoire pour //
// trouver les fichiers *.dat et en determiner le //
// nombre //
// //
/////////////////////////////////////////////////////////////////////////
void ObtenirNiveaux()
{
struct ffblk f;
char *tmp;
int done = findfirst("*.dat", &f, FA_HIDDEN | FA_SYSTEM);//cherche les .dat
tmp=f.ff_name + 5; //Pointe vers le chiffre du nom de fichier,ex:"1.dat"
while (!done)
{
Niveaux.Liste[Niveaux.NbMax] = atoi(tmp);//indexe le nø du niveau
Niveaux.NbMax++; //incremente le nombre de niv.
done = findnext(&f); //Cherche le .dat suivant
}
Niveaux.NbMax--; //decremente le nombre max
return; //(pour faire correspondre aux index)
}
/////////////////////////////////////////////////////////////////////////
// //
// Action Professionelle 2002: //
// //
// SERPENT //
// //
// PERNES Olivier BTSIG1 //
// //
// "SERPENT.C" //
// //
// //
/////////////////////////////////////////////////////////////////////////
#include "commun.h"
const vitesse=50000; //Vitesse du jeu
const HAUT=0,DROITE=1,BAS=2,GAUCHE=3;
/////////////////////////////////////////////////////////////////////////
// //
// INIT: initialise les variables //
// //
/////////////////////////////////////////////////////////////////////////
void init()
{
int i;
score=0;
taperdu=0; //ben oui, perdre des le debut c pas le but...
srandom(time(NULL)); //initialise le gnrateur alatoire
serpent.x = 40; //place le serpent en X au milieu de l'ecran
serpent.y = 21; //place le serpent en Y au milieu de l'ecran
serpent.dir = random()%3; //direction alatoire: 0H,1D,2B,3G
serpent.lgQueue=0;
for (i=0;i<=48;i++)
{serpent.queue[i].x = 40; //initialise la queue
serpent.queue[i].y = 21;}
if (Niveaux.EnCours==0){
Message("Bonjour!","Bienvenue dans SERPENT","Niveau 1: 3");
sleep(1);
Message("Bonjour!","Bienvenue dans SERPENT","Niveau 1: 2");
sleep(1);
Message("Bonjour!","Bienvenue dans SERPENT","Niveau 1: 1");
sleep(1);
clrscr(); //efface le message
ObtenirNiveaux(); //charge la liste de niveaux
}
FaireNiveau(); //trace le niveau
PlacePoint(); //Place le point a attraper
place_baballes(); //Place les balles
}
/////////////////////////////////////////////////////////////////////////
// //
// TOUCHE: Se charge de la gestion du score avec //
// les points, et dclenche le changement //
// de tableau //
// //
/////////////////////////////////////////////////////////////////////////
void Touche()
{
char temp[74];
score++; //incrmente le score
if (serpent.lgQueue!=0) //augmente la taille de la queue
serpent.lgQueue = serpent.lgQueue + (serpent.lgQueue/2);
else
serpent.lgQueue=2;
if (score==10) //passe le niveau
{
Niveaux.EnCours++; //incrmente le numro du niveau
if (Niveaux.EnCours>Niveaux.NbMax) //teste si il y a encore un niveau
{
Message("Bravo!!","vous avez gagn","!!!");
getkey();
taperdu=1;
return;
}
sprintf(temp,"Niveau %d: 3",Niveaux.EnCours+1);
Message("","Bravo!!",temp);
sleep(1);
sprintf(temp,"Niveau %d: 2",Niveaux.EnCours+1);
Message("","Bravo!!",temp);
sleep(1);
sprintf(temp,"Niveau %d: 1",Niveaux.EnCours+1);
Message("","Bravo!!",temp);
sleep(1);
clrscr();
init(); //Rinitialise les donnes
}
else
PlacePoint(); //Replace un point
}
/////////////////////////////////////////////////////////////////////////
// //
// GAMEOVER: Comme son nom l'indique //
// //
/////////////////////////////////////////////////////////////////////////
void gameover()
{
int x,y;
textattr( (BLUE << 4) | WHITE);
Message ("Vous avez perdu","votre score:",itoa(score,NULL,9));
taperdu = 1;
while(!kbhit());
return;
}
/////////////////////////////////////////////////////////////////////////
// //
// GESTIONDEPCOL: Gere le deplacement du serpent //
// et teste les collisions... //
// //
/////////////////////////////////////////////////////////////////////////
void GestionDepCol()
{
//Ralentit le jeu de 'vitesse'æs
usleep(vitesse);
//Gestion du dep. vers le haut
if (serpent.dir == HAUT)
{
if (MAT[serpent.y-1][serpent.x]==0)
serpent.y--; //deplace le serpent
else if (MAT[serpent.y-1][serpent.x]==2)
{Touche();serpent.y--;} //Attrap un point
else taperdu=1; //touch un mur
}
if (serpent.dir == DROITE) //Gestion du dep. vers la droite
{
if (MAT[serpent.y][serpent.x+1]==0)
serpent.x++;
else if (MAT[serpent.y][serpent.x+1]==2)
{Touche();serpent.x++;}
else taperdu=1;
}
if (serpent.dir == BAS) //Gestion du dep. vers le bas
{
if (MAT[serpent.y+1][serpent.x]==0)
serpent.y++;
else if (MAT[serpent.y+1][serpent.x]==2)
{Touche();serpent.y++;}
else taperdu=1;
}
if (serpent.dir == GAUCHE) //Gestion du dep. vers la gauche
{
if (MAT[serpent.y][serpent.x-1]==0)
serpent.x--;
else if (MAT[serpent.y][serpent.x-1]==2)
{Touche();serpent.x--;}
else taperdu=1;
}
return;
}
/////////////////////////////////////////////////////////////////////////
// //
// GEREQUEUE: Gere le mouvement de la queue //
// gr en LILO (last in last out) //
// //
/////////////////////////////////////////////////////////////////////////
void GereQueue()
{
int i;
//efface le dernier element de la liste de l'cran
ScreenPutChar('Û',BLUE,serpent.queue[serpent.lgQueue].x
,serpent.queue[serpent.lgQueue].y);
//remet a 0 dans la matrice le bout de queue efface
MAT[serpent.queue[serpent.lgQueue].y][serpent.queue[serpent.lgQueue].x]=0;
//Dcale tous les lments de la queue
for (i=42;i>0;i--)
{
serpent.queue[i].x = serpent.queue[i-1].x;
serpent.queue[i].y = serpent.queue[i-1].y;
}
//Insre dans le haut de la pile la nouvelle coord. du serpent.
serpent.queue[0].x = serpent.x;
serpent.queue[0].y = serpent.y;
//Met
jour la matrice
for (i=0;i<=serpent.lgQueue;i++)
MAT[serpent.queue[i].y][serpent.queue[i].x]=1;
}
/////////////////////////////////////////////////////////////////////////
// //
// MAIN: Routine principale //
// //
/////////////////////////////////////////////////////////////////////////
main(int argc,char *argv[])
{
int retour_menu=0; //Variable contenant le nøde menu selectionne
char Touche=0; //Touche contient la touche appuye
_set_screen_lines(43); //Mode d'ecran:80*43 Texte
while (retour_menu!=2)
{
retour_menu = menu(); //Affiche et gere le menu
if (retour_menu < 0)
{
Editeur(abs(retour_menu));
break;
}
if (retour_menu==0)
{
init(); //initialise les variables
while(taperdu!=1) //Tant qu'on appuie pas sur echap...
{
while(!kbhit()) //Tant qu'on appuie sur rien...
{
GestionDepCol(); //Apelle la fonction de dep./collision
GereQueue(); //Gere le deplacement de la queue
deplace_baballes();
if (taperdu==1) gameover();//Teste la mort (?!)
ScreenPutChar('Û',WHITE,serpent.x,serpent.y); //Affiche le serpent
}
Touche=getch(); //Les touches 'normales' renvoient un code
//ascii standard (sur un caractere).
if (Touche==0) //Ascii 0==> touche tendue utilise...
Touche=getch(); //Ce 2nd getch est pour rcuprer les touches
switch (Touche) //(codees sur 2 caractres (0+code))
{
case 27: //Echap = byebye
taperdu = 1;
case 'H': //le haut
serpent.dir=HAUT;
break;
case 'M': //la droite
serpent.dir=DROITE;
break;
case 'P': //le bas
serpent.dir=BAS;
break;
case 'K': //la gauche
serpent.dir=GAUCHE;
break;
}
}
}
}
return(0);
}
/////////////////////////////////////////////////////////////////////////
// //
// Action Professionelle 2002: //
// //
// SERPENT //
// //
// PERNES Olivier BTSIG1 //
// //
// "BALLES.C" //
// //
// //
/////////////////////////////////////////////////////////////////////////
#include "commun.h"
const maxbaballes = 5; //Determine le nombre de balles
/////////////////////////////////////////////////////////////////////////
// //
// PLACE_BALLE: Se charge de placer les balles //
// dans la matrice et de les afficher //
// (phase d'initialisation des balles) //
// //
/////////////////////////////////////////////////////////////////////////
void place_baballes()
{
int i,fini;
for (i=0;i<maxbaballes;i++) //Pour toutes les balles:
{
fini = 0; //Tant qu'on a pas trouve une place
while (fini==0) //libre dans la matrice
{
baballe[i].x = (random()%77)+1; //Coordonnes X et Y alatoires
baballe[i].y = (random()%41)+1; // de 1-78 X et 1-24 Y
baballe[i].incx = (random()%2)-1; //Incrementation en X,Y alatoires
baballe[i].incy = (random()%2)-1; // de -1
1
if (baballe[i].incx == baballe[i].incy)
if (baballe[i].incx == 0) //Fait en sorte qu'une balle ne soit
baballe[i].incx = 1; //pas immobile (incx=incy=0)
if (baballe[i].incx != 0) //Mouvements diagonales dsactivs
if (baballe[i].incy != 0)
baballe[i].incy = 0;
if (MAT[baballe[i].y][baballe[i].x]==0)
{ //Si la place est libre dans la matrice
MAT[baballe[i].y][baballe[i].x]=3; //placer a ces coordonnees un 3
fini = 1;
}
}
//Affiche les balles
ScreenPutChar('', LIGHTRED | (BLUE<<4), baballe[i].x, baballe[i].y);
}
}
/////////////////////////////////////////////////////////////////////////
// //
// DEPLACE_BALLE: Se charge de dplacer les balles//
// dans la matrice et de les afficher //
// //
/////////////////////////////////////////////////////////////////////////
void deplace_baballes()
{
int i,j;
//Pour toutes les balles
for (i=0;i<maxbaballes;i++)
{
if (baballe[i].x+baballe[i].incx == serpent.queue[0].x)
if (baballe[i].y+baballe[i].incy == serpent.queue[0].y)
taperdu=1;//Si les prochaines coord. de la balle= position de la tete
//du serpent, alors on a perdu!!
//SI la prochaine coordonne de la balle est pratiquable dans la matrice:
if (MAT[baballe[i].y+baballe[i].incy][baballe[i].x+baballe[i].incx]==0)
{
if ((baballe[i].x+baballe[i].incx)>(78-abs(baballe[i].incx))||
(baballe[i].x+baballe[i].incx)<(1+abs(baballe[i].incx)))
{//Si on sort pas de l'ecran en X
baballe[i].incx = -baballe[i].incx;//on inverse l'incrementation X
}
if ((baballe[i].y+baballe[i].incy)>(41-abs(baballe[i].incy))||
(baballe[i].y+baballe[i].incy)<(1+abs(baballe[i].incy)))
{//Si on sort pas de l'ecran en Y
baballe[i].incy = -baballe[i].incy;//on inverse l'incrementation Y
}
}
else
{//Sinon c qu'on a un mur ou le serpent ou une balle ou un point a cet endroit
//Si la balle se deplace verticalement uniquement
if (baballe[i].incx == 0)
baballe[i].incy = -baballe[i].incy; //on inverse l'incrementation Y
baballe[i].incx = -baballe[i].incx; //on inverse l'incrementation Y
}
//RAZ du pt de la matrice a l'ancienne position de la balle
MAT[baballe[i].y][baballe[i].x]=0;
//Efface la balle de l'ecran
ScreenPutChar(' ', LIGHTRED | (BLUE<<4), baballe[i].x, baballe[i].y);
//Met a jour en X et Y les coordonnes de la balle
baballe[i].x = baballe[i].x + baballe[i].incx;
baballe[i].y = baballe[i].y + baballe[i].incy;
//Place la balle dans la matrice (en y mettant un 3)
MAT[baballe[i].y][baballe[i].x]=3;
//et Affiche a l'ecran la balle
ScreenPutChar('', LIGHTRED | (BLUE<<4), baballe[i].x, baballe[i].y);
}
}
/////////////////////////////////////////////////////////////////////////
// //
// Action Professionelle 2002: //
// //
// SERPENT //
// //
// PERNES Olivier BTSIG1 //
// //
// "MENU.C" //
// //
// //
/////////////////////////////////////////////////////////////////////////
#include "commun.h"
/////////////////////////////////////////////////////////////////////////
// //
// TRACE_FOND : remplit l'ecran d'un caractere pour //
// simuler un 'beau' fond d'ecran pour le menu //
// //
/////////////////////////////////////////////////////////////////////////
void trace_fond()
{
int x,y;
//Pour dessiner sur fond bleu:
textattr(BLUE<<4);
//On efface l'ecran
clrscr();
//Pour tous les caractres de l'ecran:
for(x=0;x<80;x++)
for(y=0;y<43;y++)
//Afficher ce caractere en gris sombre
ScreenPutChar('²', DARKGRAY | (BLUE << 4), x, y);
}
/////////////////////////////////////////////////////////////////////////
// //
// MENU: Affiche et gere le menu //
// //
/////////////////////////////////////////////////////////////////////////
int menu()
{
int x,y;
int choix=0;
int finmenu = 0;
int touche=0;
//Dessine le fond d'ecran
trace_fond();
while (finmenu == 0) //Tant que l'on a pas fini avec le menu
{
//Affiche le menu:
ScreenPutString("ÛÛÛÛÛÛÛÛÛÛÛÛÛ", WHITE | (BLUE << 4), 34, 20);
ScreenPutString("Û JOUER Û", WHITE | (BLUE << 4), 34, 21);
ScreenPutString("Û EDITEUR Û", WHITE | (BLUE << 4), 34, 22);
ScreenPutString("Û A PROPOS Û", WHITE | (BLUE << 4), 34, 23);
ScreenPutString("Û QUITTER Û", WHITE | (BLUE << 4), 34, 24);
ScreenPutString("ÛÛÛÛÛÛÛÛÛÛÛÛÛ", WHITE | (BLUE << 4), 34, 25);
//Selon le choix (choix MOD 4), on affiche dans une couleur differente
switch(abs(choix) % 4){
case 0:
ScreenPutString(" JOUER ", WHITE | (YELLOW << 4), 35, 21);
break;
case 1:
ScreenPutString(" EDITEUR ", WHITE | (YELLOW << 4), 35, 22);
break;
case 2:
ScreenPutString(" A PROPOS ", WHITE | (YELLOW << 4), 35, 23);
break;
case 3:
ScreenPutString(" QUITTER ", WHITE | (YELLOW << 4), 35, 24);
break;}
//Attend la prochaine touche
touche = getch();
if (touche==0) touche=getch(); //Si l'on a une touche tendue
switch (touche){ //Selon la touche:
case 'H': //Si c le haut:
choix--; //on dcrmente l'index du menu
if (choix<0) choix = 3; //Evite que le menu se droule dans le sens
break; // inverse lorsque l'on monte apres 'jouer'
case 'P':
choix++; //Si c le haut, simple incrementation de l'index
break;
case 13: //Si l'on appuie sur entree:
textattr((BLUE<<4)|WHITE); //change les couleurs (bleu derriere,blanc
clrscr(); //devant), et applique en effacant l'ecran.
//Mise a zero de la matrice
for (x=0;x<80;x++)
for (y=0;y<43;y++)
MAT[y][x] = 0;
//Selon le numro de menu:
switch(abs(choix)%4){
case 1: //EDITEUR:
Message("Editeur:","Veuillez entrer le numro","du niveau a editer:");
ScreenSetCursor(45/2,48);
scanf("%d",&touche);
return -touche;
break;
case 2: //A PROPOS:
Message("SERPENT:","AP BTSIG Nø1","2002 PERNES Olivier (opernes@wanadoo.fr)");
getkey();
trace_fond();
break;
case 3: //QUITTER:
Message("Merci d'avoir jou a SERPENT","(ok le nom n'est pas original)","Au Revoir!!!!!");
getkey();
return 2;
break;
case !2: //Quitte le menu sauf si on a fait a propos
return(0);
finmenu=1;
break;
}
}
}
}
Conclusion :
Bon ok, sur le site on voit pas les tabulations et les caractères ascii un peu speciaux...
Donc la mise en page est crade. Le mieux est de prendre le zip, y'a les sources, les niveaux et le mode d'emploi...
Compilé avec Rhide/djgpp
Si quelqu'un a le courage de réactiver les déplacements en diagonales des ennemis, et qu'il corrige le bug, qu'il me fasse signe, merci (y'avai un bug sur le test de collision, en diagonale, un ennemi pouvait sauter un obstacle).
Bon je pense avoir assez commenté le source, mais si vous avez des question, mailez...
Enjoy!
PS:Désolé ANSI/POSIX...
VOTEZ, PLEASE!!!!!
Codes Sources
A voir également
- Aha! serpent, en c tout court, avec editeur de niveaux, ennemis et mode d'emploi...
- Éditeur wysiwyg - Conseils pratiques -Javascript
- Créer emploi du temps en ligne - Forum Java
- Emploi delphi - Forum Delphi / Pascal
- Gestion d emploi du temps en java - Forum Java
- Emploi du temps - Forum Java
Vous n'êtes pas encore membre ?
inscrivez-vous, c'est gratuit et ça prend moins d'une minute !
Les membres obtiennent plus de réponses que les utilisateurs anonymes.
Le fait d'être membre vous permet d'avoir un suivi détaillé de vos demandes et codes sources.
Le fait d'être membre vous permet d'avoir des options supplémentaires.