lalane/SAE11_2023
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

rangement git

Browse Source
This commit is contained in:
Maxim LALANE 2023-12-24 12:02:45 +01:00
parent be4518b53d
commit 69e6250b93
40 changed files with 0 additions and 4629 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

171
Direction.c
View File

@ -1,171 +0,0 @@
#include<stdlib.h>
#include<stdio.h>
#include<graph.h>
#include<time.h>
#define H 40
#define L 60
#define DELTA 1000000L
#define DELTO 1000L
void AfficheTab(int tab[H][L], int posx, int posy, int i, int j){
couleur c;
if(tab[i][j]==0){
c=CouleurParNom("green");
ChoisirCouleurDessin(c);
RemplirRectangle(posx,posy,20,20);
}
if(tab[i][j]==1||tab[i][j]==6||tab[i][j]==7||tab[i][j]==8||tab[i][j]==9){
c=CouleurParNom("yellow");
ChoisirCouleurDessin(c);
RemplirRectangle(posx,posy,20,20);
}
}
void Affiche(int tab[H][L]){
/*affichage du tableau pour rendu graphique*/
int i,j,posx=0,posy=0;
for(i=0;i<H;i++){
for(j=0;j<L;j++){
AfficheTab(tab, posx, posy, i, j);
posx=posx+20;
}
posx=0;
posy=posy+20;
}
posx=0;
posy=0;
}
int CliqueTouche(void){
int direction;
switch(Touche()){
case XK_Up:
if(direction!=0){
direction=2;
return direction;
}
case XK_Down:
if(direction!=2){
direction=0;
return direction;
}
break;
case XK_Right:
if(direction!=1){
direction=3;
return direction;
}
break;
case XK_Left:
if(direction!=3){
direction=1;
return direction;
}
}
}
void DessinerTimer(int n)
{
couleur c;
char buf[100];
c=CouleurParNom("white");
ChoisirCouleurDessin(c);
RemplirRectangle(0,850,200,100);
c=CouleurParNom("black");
ChoisirCouleurDessin(c);
snprintf(buf,100,"time : %d",n);
EcrireTexte(50,900,buf,2);
}
void init(int tab[H][L]){
/*creation page*/
InitialiserGraphique();
CreerFenetre(10,10,1700,1000);
couleur c;
c=CouleurParNom("green");
ChoisirCouleurDessin(c);
int i,j;
/*initialisation de la grille a 0(vert)*/
for(i=0;i<H;i++){
for(j=0;j<L;j++){
tab[i][j]=0;
}
}
/*initialisation du serpent*/
tab[0][1]=0;
tab[10][1]=1;
for(i=0;i<10;i++){
tab[i][1]=1;
}
}
void Direction(int direction,int tab[H][L],int sxmax, int symax){
}
int main(void){
/*partie graphique*/
int tab[H][L],direction=0;
int n=0,sxmin=0,symin=1,sxmax=10,symax=1,fin=0;
unsigned long suivant,suivant2;
suivant2=Microsecondes()+DELTO;
suivant=Microsecondes()+DELTA;
init(tab);
while(1){
Affiche(tab);
/*touche*/
if(ToucheEnAttente()==1){
direction=CliqueTouche();
}
/*timer*/
if(Microsecondes()>suivant){
n++;
DessinerTimer(n);
suivant=Microsecondes()+DELTA;
}
/*deplacement tete*/
if(Microsecondes()>suivant2){
/*haut*/
if(direction==2){
sxmax=sxmax-1;
tab[sxmax][symax]=1;
}
/*droite*/
if(direction==3){
symax=symax+1;
tab[sxmax][symax]=1;
}
/*gauche*/
if(direction==1){
symax=symax-1;
tab[sxmax][symax]=1;
}
/*bas*/
if(direction==0){
sxmax=sxmax+1;
tab[sxmax][symax]=1;
}
suivant2=Microsecondes()+DELTO;
}
if(fin==1){
return EXIT_SUCCESS;
}
}
}

231
Do/Obstacle.c
View File

@ -1,231 +0,0 @@
#include<stdlib.h>
#include<stdio.h>
#include<graph.h>
#include<time.h>
#define H 40
#define L 60
#define DELTA 1000000L
#define DELTO 1000L
void AfficheTab(int tab[H][L], int posx, int posy, int i, int j){
couleur c;
if(tab[i][j]==0){
c=CouleurParNom("green");
ChoisirCouleurDessin(c);
RemplirRectangle(posx,posy,20,20);
}
if(tab[i][j]==1||tab[i][j]==6||tab[i][j]==7||tab[i][j]==8||tab[i][j]==9){
c=CouleurParNom("yellow");
ChoisirCouleurDessin(c);
RemplirRectangle(posx,posy,20,20);
}
}
void Affiche(int tab[H][L]){
/*affichage du tableau pour rendu graphique*/
int i,j,posx=0,posy=0;
for(i=0;i<H;i++){
for(j=0;j<L;j++){
AfficheTab(tab, posx, posy, i, j);
posx=posx+20;
}
posx=0;
posy=posy+20;
}
posx=0;
posy=0;
}
int CliqueTouche(void){
int direction;
switch(Touche()){
case XK_Up:
if(direction!=0){
direction=2;
return direction;
}
case XK_Down:
if(direction!=2){
direction=0;
return direction;
}
break;
case XK_Right:
if(direction!=1){
direction=3;
return direction;
}
break;
case XK_Left:
if(direction!=3){
direction=1;
return direction;
}
}
}
void DessinerTimer(int n)
{
couleur c;
char buf[100];
c=CouleurParNom("white");
ChoisirCouleurDessin(c);
RemplirRectangle(0,850,200,100);
c=CouleurParNom("black");
ChoisirCouleurDessin(c);
snprintf(buf,100,"time : %d",n);
EcrireTexte(50,900,buf,2);
}
void init(int tab[H][L]){
InitialiserGraphique();
CreerFenetre(10,10,1700,1000);
couleur c;
c=CouleurParNom("green");
ChoisirCouleurDessin(c);
int i,j;
/*initialisation de la grille a 0(vert)*/
for(i=0;i<H;i++){
for(j=0;j<L;j++){
tab[i][j]=0;
}
}
/*initialisation du serpent*/
tab[0][1]=0;
tab[10][1]=1;
for(i=0;i<10;i++){
tab[i][1]=1;
}
}
int VerifCaseXPlus(int tab[H][L], int sxmax, int symax){
if(tab[sxmax+1][symax]==0){
return 0;
}else{
return 1;
}
}
int VerifCaseYPlus(int tab[H][L], int sxmax, int symax){
if(tab[sxmax][symax+1]==0){
return 0;
}else{
return 1;
}
}
int VerifCaseXMoins(int tab[H][L], int sxmax, int symax){
if(tab[sxmax-1][symax]==0){
return 0;
}else{
return 1;
}
}
int VerifCaseYMoins(int tab[H][L], int sxmax, int symax){
if(tab[sxmax][symax-1]==0){
return 0;
}else{
return 1;
}
}
void Direction(int direction,int tab[H][L],int sxmax, int symax){
}
int main(void){
/*partie graphique*/
int tab[H][L],direction;
int n=0,sxmin=0,symin=1,sxmax=10,symax=1,fin=0;
unsigned long suivant,suivant2;
suivant2=Microsecondes()+DELTO;
suivant=Microsecondes()+DELTA;
init(tab);
while(1){
Affiche(tab);
/*touche*/
if(ToucheEnAttente()==1){
direction=CliqueTouche();
}
/*timer*/
if(Microsecondes()>suivant){
n++;
DessinerTimer(n);
suivant=Microsecondes()+DELTA;
}
if(Microsecondes()>suivant2){
/*haut*/
if(direction==2){
if(VerifCaseYMoins(tab,sxmax,symax)==0){
sxmax=sxmax-1;
tab[sxmax][symax]=1;
}else{
fin=1;
}
}
/*droite*/
if(direction==3){
if(VerifCaseXPlus(tab,sxmax,symax)==0){
symax=symax+1;
tab[sxmax][symax]=1;
}else{
fin=1;
}
}
/*gauche*/
if(direction==1){
if(VerifCaseXMoins(tab,sxmax,symax)==0){
symax=symax-1;
tab[sxmax][symax]=1;
}else{
fin=1;
}
}
/*bas*/
if(direction==0){
if(VerifCaseYPlus(tab,sxmax,symax)==0){
sxmax=sxmax+1;
tab[sxmax][symax]=1;
}else{
fin=1;
}
}
suivant2=Microsecondes()+DELTO;
}
if(fin==1){
return EXIT_SUCCESS;
}
}
}

0
Do/Obstacle.c~
View File

BIN
Do/a.out
View File

Binary file not shown.

0
Do/do.txt
View File

25
Menu.c
View File

@ -1,25 +0,0 @@
#include<stdio.h>
#include<stdlib.h>
#include<graph.h>
int main(void){
InitialiserGraphique();
CreerFenetre(10,10,1700,1000);
couleur c=CouleurParNom("red");
ChoisirCouleurDessin(c);
RemplirRectangle(1300,100,300,200);
c=CouleurParNom("purple");
ChoisirCouleurDessin(c);
RemplirRectangle(1300,400,300,200);
while(1){
if(SourisCliquee()==1){
if(_X>=1300&&_Y>=100&&_X<=1600&&_Y<=300){
return EXIT_SUCCESS;
}
if(_X>=1300&&_Y>=300&&_X>=&&_Y<=){
return EXIT_SUCCESS;
}
}
}
}

426
Pause.c
View File

@ -1,426 +0,0 @@
#include<stdlib.h>
#include<stdio.h>
#include<graph.h>
#include<time.h>
/*taille 2 de plus pour avoir les bordures du plateau de jeu*/
#define H 42
#define L 62
/*initialisation des compteur(timer et deplacement du serpent*/
#define DELTA 1000000L
#define DELTO 1000L
#define DELTI 300000L
/*affichage di plateau de jeu en fonction du tableau*/
void AfficheTab(int tab[H][L], int posx, int posy, int i, int j){
couleur c;
if(tab[i][j]==0){
c=CouleurParNom("black");
ChoisirCouleurDessin(c);
RemplirRectangle(posx,posy,20,20);
}
if(tab[i][j]==40){
c=CouleurParNom("dark grey");
ChoisirCouleurDessin(c);
RemplirRectangle(posx,posy,20,20);
c=CouleurParNom("black");
ChoisirCouleurDessin(c);
DessinerRectangle(posx+2,posy+2,16,16);
}
if(tab[i][j]==1||tab[i][j]==9||tab[i][j]==7||tab[i][j]==8||tab[i][j]==6){
c=CouleurParNom("dark orange");
ChoisirCouleurDessin(c);
RemplirRectangle(posx,posy,20,20);
c=CouleurParNom("brown");
ChoisirCouleurDessin(c);
RemplirArc(posx+5,posy+5,10,10,360,360);
}
if(tab[i][j]==30){
c=CouleurParNom("red");
ChoisirCouleurDessin(c);
RemplirArc(posx,posy,20,20,360,360);
}
if(tab[i][j]==50){
c=CouleurParNom("purple");
ChoisirCouleurDessin(c);
RemplirArc(posx,posy,20,20,360,360);
}
}
/*parcours du tableau pour rendu graphique*/
void Affiche(int tab[H][L]){
int i,j,posx=0,posy=0;
for(i=0;i<=H;i++){
for(j=0;j<=L;j++){
AfficheTab(tab, posx, posy, i, j);
posx=posx+20;
}
posx=0;
posy=posy+20;
}
posx=0;
posy=0;
}
/*verifie les touches cliquée par le joueur*/
int CliqueTouche(int defaut,int* pause,int* fin){
switch(Touche()){
case XK_Up:
if(defaut!=0){
defaut=2;
return defaut;
}
case XK_Down:
if(defaut!=2){
defaut=0;
return defaut;
}
case XK_Right:
if(defaut!=1){
defaut=3;
return defaut;
}
case XK_Left:
if(defaut!=3){
defaut=1;
return defaut;
}
case XK_space:
if(*pause==1){
*pause=0;
}
else if(*pause==0){
*pause=1;
}
return defaut;
case XK_Escape:
*fin=1;
return defaut;
default :
return defaut;
}
}
/*affichage du timer*/
void DessinerTimer(int n){
couleur c;
char buf[100];
c=CouleurParNom("dark blue");
ChoisirCouleurDessin(c);
RemplirRectangle(0,875,200,100);
c=CouleurParNom("red");
ChoisirCouleurDessin(c);
snprintf(buf,100,"time : %d",n);
EcrireTexte(50,900,buf,2);
}
/*affichage du score*/
void DessinerScore(int n){
couleur c;
char buf[100];
c=CouleurParNom("dark blue");
ChoisirCouleurDessin(c);
RemplirRectangle(200,875,200,100);
c=CouleurParNom("yellow");
ChoisirCouleurDessin(c);
snprintf(buf,100,"score : %d",n);
EcrireTexte(250,900,buf,2);
}
/*Mise en place de pastilles le plateau de jeu
en fonction de ce que l'on veut placer */
int Pastille(int tab[H][L],int nb_de_pastilles,int type_pastille){
int ia,ja;
if(nb_de_pastilles==0){
return 1;
}
srand(time(NULL));
while(nb_de_pastilles!=0){
ia=rand()%40;
ja=rand()%60;
if(tab[ia][ja]==0){
if(type_pastille==1){
/*pommes*/
tab[ia][ja]=30;
}else if(type_pastille==2){
/*pommes pour mur*/
tab[ia][ja]=50;
}else if(type_pastille==3){
/*mur*/
tab[ia][ja]=40;
}
nb_de_pastilles=nb_de_pastilles-1;
}
}
}
/*initialisation du plateau de jeu*/
void init(int tab[H][L]){
/*creation de la page*/
InitialiserGraphique();
CreerFenetre(10,10,1700,1000);
int i,j;
couleur c;
c=CouleurParNom("dark blue");
ChoisirCouleurDessin(c);
RemplirRectangle(0,0,1700,1000);
DessinerScore(0);
DessinerTimer(0);
/*initialisation de la grille a 0(vert)*/
for(i=1;i<H;i++){
for(j=1;j<L;j++){
tab[i][j]=0;
}
}
/*initialisation bordure*/
for(i=0;i<=H;i++){
tab[i][L]=40;
tab[i][0]=40;
}
for(i=0;i<=L;i++){
tab[H][i]=40;
tab[0][i]=40;
}
/*initialisation du serpent*/
tab[2][2]=0;
tab[11][2]=1;
tab[11][2]=1;
for(i=2;i<11;i++){
tab[i][2]=1;
}
/*Initalisation des differences pastilles*/
Pastille(tab,5,1);
Pastille(tab,2,2);
}
/*verification de la case ou on va aller*/
int VerifChemin(int tab[H][L], int x, int y){
if(tab[x][y]==0){
return 1;
}else if(tab[x][y]==30){
return 3;
}else if(tab[x][y]==50){
return 2;
}else{
return 0;
}
}
/*regarde la case ou la queue est pour savoir ou elle va aller ensuite*/
int VoirCase(int tab[H][L],int x, int y,int defaut){
if(tab[x][y]==9){
return 3;
}
else if(tab[x][y]==8){
return 2;
}
else if(tab[x][y]==7){
return 1;
}
else if(tab[x][y]==6){
return 0;
}
else{
return defaut;
}
}
/*arrete la queue le temps que la tete avance un peu pour permettre au serpent de grandir*/
unsigned long TempsArret(int* temoin){
if(*temoin==1){
*temoin=0;
return Microsecondes()+DELTI;
}else if(*temoin==0){
return Microsecondes()+DELTO;
}
}
/*deplacement de la queue du serpent en fonction de la trace laissée par la tete*/
void DeplacementQueue(int tab[H][L],int* sxmin,int* symin,int* direc){
if(*direc==0){
*sxmin=*sxmin+1;
*direc=VoirCase(tab,*sxmin,*symin,*direc);
tab[*sxmin][*symin]=0;
}
else if(*direc==1){
*symin=*symin-1;
*direc=VoirCase(tab,*sxmin,*symin,*direc);
tab[*sxmin][*symin]=0;
}
else if(*direc==2){
*sxmin=*sxmin-1;
*direc=VoirCase(tab,*sxmin,*symin,*direc);
tab[*sxmin][*symin]=0;
}
else if(*direc==3){
*symin=*symin+1;
*direc=VoirCase(tab,*sxmin,*symin,*direc);
tab[*sxmin][*symin]=0;
}
}
/*Deplacement de la tete du seroent en fonction de la direction*/
void DeplacementTete(int tab[H][L],int* sxmax,int* symax,int direction,int* temoin,int* fin,int* point){
if(direction==2){
if(VerifChemin(tab,*sxmax-1,*symax)==1){
*sxmax=*sxmax-1;
tab[*sxmax][*symax]=1;
}else if(VerifChemin(tab,*sxmax-1,*symax)==3){
*sxmax=*sxmax-1;
tab[*sxmax][*symax]=1;
*point=*point+5;
DessinerScore(*point);
Pastille(tab,1,1);
*temoin=1;
}else if(VerifChemin(tab,*sxmax-1,*symax)==2){
*sxmax=*sxmax-1;
tab[*sxmax][*symax]=1;
Pastille(tab,5,3);
Pastille(tab,1,2);
}else{
*fin=1;
}
}
/*droite*/
if(direction==3){
if(VerifChemin(tab,*sxmax,*symax+1)==1){
*symax=*symax+1;
tab[*sxmax][*symax]=1;
}else if(VerifChemin(tab,*sxmax,*symax+1)==3){
*symax=*symax+1;
tab[*sxmax][*symax]=1;
*point=*point+5;
DessinerScore(*point);
Pastille(tab,1,1);
*temoin=1;
}else if(VerifChemin(tab,*sxmax,*symax+1)==2){
*symax=*symax+1;
tab[*sxmax][*symax]=1;;
Pastille(tab,5,3);
Pastille(tab,1,2);
}else{
*fin=1;
}
}
/*gauche*/
if(direction==1){
if(VerifChemin(tab,*sxmax,*symax-1)==1){
*symax=*symax-1;
tab[*sxmax][*symax]=1;
}
else if(VerifChemin(tab,*sxmax,*symax-1)==3){
*symax=*symax-1;
tab[*sxmax][*symax]=1;
*point=*point+5;
DessinerScore(*point);
Pastille(tab,1,1);
*temoin=1;
}else if(VerifChemin(tab,*sxmax,*symax-1)==2){
*symax=*symax-1;
tab[*sxmax][*symax]=1;;
Pastille(tab,5,3);
Pastille(tab,1,2);
}else{
*fin=1;
}
}
/*bas*/
if(direction==0){
if(VerifChemin(tab,*sxmax+1,*symax)==1){
*sxmax=*sxmax+1;
tab[*sxmax][*symax]=1;
}
else if(VerifChemin(tab,*sxmax+1,*symax)==3){
*sxmax=*sxmax+1;
tab[*sxmax][*symax]=1;
*point=*point+5;
DessinerScore(*point);
Pastille(tab,1,1);
*temoin=1;
}else if(VerifChemin(tab,*sxmax+1,*symax)==2){
*sxmax=*sxmax+1;
tab[*sxmax][*symax]=1;
Pastille(tab,5,3);
Pastille(tab,1,2);
}else{
*fin=1;
}
}
}
/*seme les angles pour dire a la queue où aller*/
int Semage(int tab[H][L],int direction,int sxmax,int symax,int* pause,int* fin){
int newdirec;
newdirec=CliqueTouche(direction,pause,fin);
if(newdirec!=direction){
if(newdirec==0){
tab[sxmax][symax]=6;
}
if(newdirec==1){
tab[sxmax][symax]=7;
}
if(newdirec==2){
tab[sxmax][symax]=8;
}
if(newdirec==3){
tab[sxmax][symax]=9;
}
direction=newdirec;
return direction;
}
}
int main(void){
int tab[H][L],direction=0,temoin=0,direc=0,pause=1;
int sxmin=1,symin=2,sxmax=11,symax=2,fin=0,point=0,Compteur_Temps=0;
int* pointeur_pause=&pause;
int* pointeur_sxmin=&sxmin;
int* pointeur_symin=&symin;
int* pointeur_direc=&direc;
int* pointeur_temoin=&temoin;
int* pointeur_sxmax=&sxmax;
int* pointeur_symax=&symax;
int* pointeur_fin=&fin;
int* pointeur_point=&point;
unsigned long suivant=Microsecondes()+DELTA,suivant2=Microsecondes()+DELTO,suivant3=Microsecondes()+DELTO;
init(tab);
while(1){
Affiche(tab);
/*touche*/
if(ToucheEnAttente()==1){
direction=Semage(tab,direction,sxmax,symax,pointeur_pause,pointeur_fin);
}
if(pause==1){
/*timer*/
if(Microsecondes()>suivant){
Compteur_Temps++;
DessinerTimer(Compteur_Temps);
suivant=Microsecondes()+DELTA;
}
/*deplacement queue*/
if(Microsecondes()>suivant3){
DeplacementQueue(tab,pointeur_sxmin,pointeur_symin,pointeur_direc);
suivant3=TempsArret(pointeur_temoin);
}
/*deplacement tete*/
if(Microsecondes()>suivant2){
DeplacementTete(tab,pointeur_sxmax,pointeur_symax,direction,pointeur_temoin,pointeur_fin,pointeur_point);
suivant2=Microsecondes()+DELTO;
}
}
if(fin==1){
return EXIT_SUCCESS;
}
}
}

391
Points.c
View File

@ -1,391 +0,0 @@
#include<stdlib.h>
#include<stdio.h>
#include<graph.h>
#include<time.h>
/*taille 2 de plus pour avoir les bordures du plateau de jeu*/
#define H 42
#define L 62
/*initialisation des compteur(timer et deplacement du serpent*/
#define DELTA 1000000L
#define DELTO 100L
/*affichage du plateau de jeu en fonction du tableau*/
void AfficheTab(int tab[H][L], int posx, int posy, int i, int j){
couleur c;
if(tab[i][j]==0){
c=CouleurParNom("black");
ChoisirCouleurDessin(c);
RemplirRectangle(posx,posy,20,20);
}
if(tab[i][j]==40){
c=CouleurParNom("dark grey");
ChoisirCouleurDessin(c);
RemplirRectangle(posx,posy,20,20);
c=CouleurParNom("black");
ChoisirCouleurDessin(c);
DessinerRectangle(posx+2,posy+2,16,16);
}
if(tab[i][j]==1){
c=CouleurParNom("dark orange");
ChoisirCouleurDessin(c);
RemplirRectangle(posx,posy,20,20);
c=CouleurParNom("brown");
ChoisirCouleurDessin(c);
RemplirArc(posx+5,posy+5,10,10,360,360);
}
if(tab[i][j]==9){
c=CouleurParNom("yellow");
ChoisirCouleurDessin(c);
RemplirRectangle(posx,posy,20,20);
}
if(tab[i][j]==7){
c=CouleurParNom("brown");
ChoisirCouleurDessin(c);
RemplirRectangle(posx,posy,20,20);
}
if(tab[i][j]==8){
c=CouleurParNom("green");
ChoisirCouleurDessin(c);
RemplirRectangle(posx,posy,20,20);
}
if(tab[i][j]==6){
c=CouleurParNom("purple");
ChoisirCouleurDessin(c);
RemplirRectangle(posx,posy,20,20);
}
if(tab[i][j]==30){
c=CouleurParNom("red");
ChoisirCouleurDessin(c);
RemplirArc(posx,posy,20,20,360,360);
}
if(tab[i][j]==50){
c=CouleurParNom("purple");
ChoisirCouleurDessin(c);
RemplirArc(posx,posy,20,20,360,360);
}
}
/*parcours du tableau pour rendu graphique*/
void Affiche(int tab[H][L]){
int i,j,posx=0,posy=0;
for(i=0;i<=H;i++){
for(j=0;j<=L;j++){
AfficheTab(tab, posx, posy, i, j);
posx=posx+20;
}
posx=0;
posy=posy+20;
}
posx=0;
posy=0;
}
int CliqueTouche(int defaut){
switch(Touche()){
case XK_Up:
if(defaut!=0){
defaut=2;
return defaut;
}
case XK_Down:
if(defaut!=2){
defaut=0;
return defaut;
}
case XK_Right:
if(defaut!=1){
defaut=3;
return defaut;
}
case XK_Left:
if(defaut!=3){
defaut=1;
return defaut;
}
default :
return defaut;
}
}
/*affichage du timer*/
void DessinerTimer(int n)
{
couleur c;
char buf[100];
c=CouleurParNom("dark blue");
ChoisirCouleurDessin(c);
RemplirRectangle(0,875,200,100);
c=CouleurParNom("white");
ChoisirCouleurDessin(c);
snprintf(buf,100,"time : %d",n);
EcrireTexte(50,900,buf,2);
}
/*affichage du score*/
void DessinerScore(int n){
couleur c;
char buf[100];
c=CouleurParNom("dark blue");
ChoisirCouleurDessin(c);
RemplirRectangle(200,875,200,100);
c=CouleurParNom("white");
ChoisirCouleurDessin(c);
snprintf(buf,100,"score : %d",n);
EcrireTexte(250,900,buf,2);
}
/*Mise en place de pastilles le plateau de jeu
en fonction de ce que l'on veut placer
*/
int Pastille(int tab[H][L],int nb,int type){
int ia,ja;
if(nb==0){
return 1;
}
srand(time(NULL));
while(nb!=0){
ia=rand()%40;
ja=rand()%60;
if(tab[ia][ja]==0){
if(type==1){
/*pommes*/
tab[ia][ja]=30;
}else if(type==2){
/*pommes pour mur*/
tab[ia][ja]=50;
}else if(type==3){
/*mur*/
tab[ia][ja]=40;
}
nb=nb-1;
}
}
}
/*initialisation du plateau de jeu*/
void init(int tab[H][L]){
/*creation page*/
InitialiserGraphique();
CreerFenetre(10,10,1700,1000);
int i,j;
couleur c;
c=CouleurParNom("dark blue");
ChoisirCouleurDessin(c);
RemplirRectangle(0,0,1700,1000);
DessinerScore(0);
/*initialisation de la grille a 0(vert)*/
for(i=1;i<H;i++){
for(j=1;j<L;j++){
tab[i][j]=0;
}
}
/*initialisation bordure*/
for(i=0;i<=H;i++){
tab[i][L]=40;
tab[i][0]=40;
}
for(i=0;i<=L;i++){
tab[H][i]=40;
tab[0][i]=40;
}
/*initialisation du serpent*/
tab[2][2]=0;
tab[10][2]=1;
tab[10][2]=1;
for(i=2;i<10;i++){
tab[i][2]=1;
}
/*Initalisation des differences pastilles*/
Pastille(tab,5,1);
Pastille(tab,2,2);
}
/*verification de la case ou on va aller*/
int VerifChemin(int tab[H][L], int x, int y){
if(tab[x][y]==0){
return 1;
}else if(tab[x][y]==30){
return 3;
}else if(tab[x][y]==50){
return 2;
}else{
return 0;
}
}
int VoirCase(int tab[H][L],int x, int y,int defaut){
if(tab[x][y]==7){
return 1;
}
if(tab[x][y]==6){
return 3;
}
if(tab[x][y]==8){
return 2;
}
if(tab[x][y]==9){
return 0;
}
}
int main(void){
int tab[H][L],direction=0,direc=0,newdirec=0;;
int n=0,sxmin=1,symin=2,sxmax=10,symax=2,fin=0,point=0;
unsigned long suivant,suivant2,suivant3;
suivant2=Microsecondes()+DELTO;
suivant=Microsecondes()+DELTA;
suivant3=Microsecondes()+DELTO;
init(tab);
while(1){
Affiche(tab);
/*touche*/
if(ToucheEnAttente()==1){
newdirec=CliqueTouche(direction);
if(newdirec!=direction){
if(newdirec==0){
tab[sxmax][symax]=6;
}
if(newdirec==1){
tab[sxmax][symax]=7;
}
if(newdirec==2){
tab[sxmax][symax]=8;
}
if(newdirec==3){
tab[sxmax][symax]=9;
}
direction=newdirec;
}
}
/*timer*/
if(Microsecondes()>suivant){
n++;
DessinerTimer(n);
suivant=Microsecondes()+DELTA;
}
if(Microsecondes()>suivant3){
if(direc==0){
sxmin=sxmin+1;
tab[sxmin][symin]=0;
direc=VoirCase(tab,sxmin,symin,direc);
}
if(direc==1){
symin=symin-1;
tab[sxmin][symin]=0;
direc=VoirCase(tab,sxmin,symin,direc);
}
if(direc==2){
sxmin=sxmin-1;
tab[sxmin][symin]=0;
direc=VoirCase(tab,sxmin,symin,direc);
}
if(direc==3){
symin=symin+1;
tab[sxmin][symin]=0;
direc=VoirCase(tab,sxmin,symin,direc);
}
suivant3=Microsecondes()+DELTO;
}
/*deplacement tete*/
if(Microsecondes()>suivant2){
/*haut*/
if(direction==2){
if(VerifChemin(tab,sxmax-1,symax)==1){
sxmax=sxmax-1;
tab[sxmax][symax]=1;
}else if(VerifChemin(tab,sxmax-1,symax)==3){
sxmax=sxmax-1;
tab[sxmax][symax]=1;
point=point+5;
DessinerScore(point);
Pastille(tab,1,1);
}else if(VerifChemin(tab,sxmax-1,symax)==2){
sxmax=sxmax-1;
tab[sxmax][symax]=1;
Pastille(tab,5,3);
Pastille(tab,1,2);
}else{
fin=1;
}
}
/*droite*/
if(direction==3){
if(VerifChemin(tab,sxmax,symax+1)==1){
symax=symax+1;
tab[sxmax][symax]=1;
}else if(VerifChemin(tab,sxmax,symax+1)==3){
symax=symax+1;
tab[sxmax][symax]=1;
point=point+5;
DessinerScore(point);
Pastille(tab,1,1);
}else if(VerifChemin(tab,sxmax,symax+1)==2){
symax=symax+1;
tab[sxmax][symax]=1;;
Pastille(tab,5,3);
Pastille(tab,1,2);
}else{
fin=1;
}
}
/*gauche*/
if(direction==1){
if(VerifChemin(tab,sxmax,symax-1)==1){
symax=symax-1;
tab[sxmax][symax]=1;
}
else if(VerifChemin(tab,sxmax,symax-1)==3){
symax=symax-1;
tab[sxmax][symax]=1;
point=point+5;
DessinerScore(point);
Pastille(tab,1,1);
}else if(VerifChemin(tab,sxmax,symax-1)==2){
symax=symax-1;
tab[sxmax][symax]=1;;
Pastille(tab,5,3);
Pastille(tab,1,2);
}else{
fin=1;
}
}
/*bas*/
if(direction==0){
if(VerifChemin(tab,sxmax+1,symax)==1){
sxmax=sxmax+1;
tab[sxmax][symax]=1;
}
else if(VerifChemin(tab,sxmax+1,symax)==3){
sxmax=sxmax+1;
tab[sxmax][symax]=1;
point=point+5;
DessinerScore(point);
Pastille(tab,1,1);
}else if(VerifChemin(tab,sxmax+1,symax)==2){
sxmax=sxmax+1;
tab[sxmax][symax]=1;;
Pastille(tab,5,3);
Pastille(tab,1,2);
}else{
fin=1;
}
}
suivant2=Microsecondes()+DELTO;
}
if(fin==1){
return EXIT_SUCCESS;
}
}
}

2
README.md
View File

@ -1,2 +0,0 @@
dans do on met les truc qu'on doit faire(fichier ou autre)
dans archives on met les codes qu'on a fait(genre le truc qui marchent on les garde au cas ou)

418
SerpentFonction.c
View File

@ -1,418 +0,0 @@
#include<stdlib.h>
#include<stdio.h>
#include<graph.h>
#include<time.h>
/*taille 2 de plus pour avoir les bordures du plateau de jeu*/
#define H 42
#define L 62
/*initialisation des compteur(timer et deplacement du serpent*/
#define DELTA 1000000L
#define DELTO 1000L
#define DELTI 300000L
/*affichage di plateau de jeu en fonction du tableau*/
void AfficheTab(int tab[H][L], int posx, int posy, int i, int j){
couleur c;
if(tab[i][j]==0){
c=CouleurParNom("black");
ChoisirCouleurDessin(c);
RemplirRectangle(posx,posy,20,20);
}
if(tab[i][j]==40){
c=CouleurParNom("dark grey");
ChoisirCouleurDessin(c);
RemplirRectangle(posx,posy,20,20);
c=CouleurParNom("black");
ChoisirCouleurDessin(c);
DessinerRectangle(posx+2,posy+2,16,16);
}
if(tab[i][j]==1||tab[i][j]==9||tab[i][j]==7||tab[i][j]==8||tab[i][j]==6){
c=CouleurParNom("dark orange");
ChoisirCouleurDessin(c);
RemplirRectangle(posx,posy,20,20);
c=CouleurParNom("brown");
ChoisirCouleurDessin(c);
RemplirArc(posx+5,posy+5,10,10,360,360);
}
if(tab[i][j]==30){
c=CouleurParNom("red");
ChoisirCouleurDessin(c);
RemplirArc(posx,posy,20,20,360,360);
}
if(tab[i][j]==50){
c=CouleurParNom("purple");
ChoisirCouleurDessin(c);
RemplirArc(posx,posy,20,20,360,360);
}
}
/*parcours du tableau pour rendu graphique*/
void Affiche(int tab[H][L]){
int i,j,posx=0,posy=0;
for(i=0;i<=H;i++){
for(j=0;j<=L;j++){
AfficheTab(tab, posx, posy, i, j);
posx=posx+20;
}
posx=0;
posy=posy+20;
}
posx=0;
posy=0;
}
/*verifie les touches cliquée par le joueur*/
int CliqueTouche(int defaut,int* pause,int* fin){
switch(Touche()){
case XK_Up:
if(defaut!=0){
defaut=2;
return defaut;
}
case XK_Down:
if(defaut!=2){
defaut=0;
return defaut;
}
case XK_Right:
if(defaut!=1){
defaut=3;
return defaut;
}
case XK_Left:
if(defaut!=3){
defaut=1;
return defaut;
}
default :
return defaut;
}
}
/*affichage du timer*/
void DessinerTimer(int n)
{
couleur c;
char buf[100];
c=CouleurParNom("dark blue");
ChoisirCouleurDessin(c);
RemplirRectangle(0,875,200,100);
c=CouleurParNom("red");
ChoisirCouleurDessin(c);
snprintf(buf,100,"time : %d",n);
EcrireTexte(50,900,buf,2);
}
/*affichage du score*/
void DessinerScore(int n){
couleur c;
char buf[100];
c=CouleurParNom("dark blue");
ChoisirCouleurDessin(c);
RemplirRectangle(200,875,200,100);
c=CouleurParNom("yellow");
ChoisirCouleurDessin(c);
snprintf(buf,100,"score : %d",n);
EcrireTexte(250,900,buf,2);
}
/*Mise en place de pastilles le plateau de jeu
en fonction de ce que l'on veut placer */
int Pastille(int tab[H][L],int nb_de_pastilles,int type_pastille){
int ia,ja;
if(nb_de_pastilles==0){
return 1;
}
srand(time(NULL));
while(nb_de_pastilles!=0){
ia=rand()%40;
ja=rand()%60;
if(tab[ia][ja]==0){
if(type_pastille==1){
/*pommes*/
tab[ia][ja]=30;
}else if(type_pastille==2){
/*pommes pour mur*/
tab[ia][ja]=50;
}else if(type_pastille==3){
/*mur*/
tab[ia][ja]=40;
}
nb_de_pastilles=nb_de_pastilles-1;
}
}
}
/*initialisation du plateau de jeu*/
void init(int tab[H][L]){
/*creation de la page*/
InitialiserGraphique();
CreerFenetre(10,10,1700,1000);
int i,j;
couleur c;
c=CouleurParNom("dark blue");
ChoisirCouleurDessin(c);
RemplirRectangle(0,0,1700,1000);
DessinerScore(0);
DessinerTimer(0);
/*initialisation de la grille a 0(vert)*/
for(i=1;i<H;i++){
for(j=1;j<L;j++){
tab[i][j]=0;
}
}
/*initialisation bordure*/
for(i=0;i<=H;i++){
tab[i][L]=40;
tab[i][0]=40;
}
for(i=0;i<=L;i++){
tab[H][i]=40;
tab[0][i]=40;
}
/*initialisation du serpent*/
tab[2][2]=0;
tab[11][2]=1;
tab[11][2]=1;
for(i=2;i<11;i++){
tab[i][2]=1;
}
/*Initalisation des differences pastilles*/
Pastille(tab,5,1);
Pastille(tab,2,2);
}
/*verification de la case ou on va aller*/
int VerifChemin(int tab[H][L], int x, int y){
if(tab[x][y]==0){
return 1;
}else if(tab[x][y]==30){
return 3;
}else if(tab[x][y]==50){
return 2;
}else{
return 0;
}
}
/*regarde la case ou la queue est pour savoir ou elle va aller ensuite*/
int VoirCase(int tab[H][L],int x, int y,int defaut){
if(tab[x][y]==9){
return 3;
}
else if(tab[x][y]==8){
return 2;
}
else if(tab[x][y]==7){
return 1;
}
else if(tab[x][y]==6){
return 0;
}
else{
return defaut;
}
}
/*arrete la queue le temps que la tete avance un peu pour permettre au serpent de grandir*/
unsigned long TempsArret(int* temoin){
if(*temoin==1){
*temoin=0;
return Microsecondes()+DELTI;
}else if(*temoin==0){
return Microsecondes()+DELTO;
}
}
/*deplacement de la queue du serpent en fonction de la trace laissée par la tete*/
void DeplacementQueue(int tab[H][L],int* sxmin,int* symin,int* direc){
if(*direc==0){
*sxmin=*sxmin+1;
*direc=VoirCase(tab,*sxmin,*symin,*direc);
tab[*sxmin][*symin]=0;
}
else if(*direc==1){
*symin=*symin-1;
*direc=VoirCase(tab,*sxmin,*symin,*direc);
tab[*sxmin][*symin]=0;
}
else if(*direc==2){
*sxmin=*sxmin-1;
*direc=VoirCase(tab,*sxmin,*symin,*direc);
tab[*sxmin][*symin]=0;
}
else if(*direc==3){
*symin=*symin+1;
*direc=VoirCase(tab,*sxmin,*symin,*direc);
tab[*sxmin][*symin]=0;
}
}
/*Deplacement de la tete du seroent en fonction de la direction*/
void DeplacementTete(int tab[H][L],int* sxmax,int* symax,int direction,int* temoin,int* fin,int* point){
if(direction==2){
if(VerifChemin(tab,*sxmax-1,*symax)==1){
*sxmax=*sxmax-1;
tab[*sxmax][*symax]=1;
}else if(VerifChemin(tab,*sxmax-1,*symax)==3){
*sxmax=*sxmax-1;
tab[*sxmax][*symax]=1;
*point=*point+5;
DessinerScore(*point);
Pastille(tab,1,1);
*temoin=1;
}else if(VerifChemin(tab,*sxmax-1,*symax)==2){
*sxmax=*sxmax-1;
tab[*sxmax][*symax]=1;
Pastille(tab,5,3);
Pastille(tab,1,2);
}else{
*fin=1;
}
}
/*droite*/
if(direction==3){
if(VerifChemin(tab,*sxmax,*symax+1)==1){
*symax=*symax+1;
tab[*sxmax][*symax]=1;
}else if(VerifChemin(tab,*sxmax,*symax+1)==3){
*symax=*symax+1;
tab[*sxmax][*symax]=1;
*point=*point+5;
DessinerScore(*point);
Pastille(tab,1,1);
*temoin=1;
}else if(VerifChemin(tab,*sxmax,*symax+1)==2){
*symax=*symax+1;
tab[*sxmax][*symax]=1;;
Pastille(tab,5,3);
Pastille(tab,1,2);
}else{
*fin=1;
}
}
/*gauche*/
if(direction==1){
if(VerifChemin(tab,*sxmax,*symax-1)==1){
*symax=*symax-1;
tab[*sxmax][*symax]=1;
}
else if(VerifChemin(tab,*sxmax,*symax-1)==3){
*symax=*symax-1;
tab[*sxmax][*symax]=1;
*point=*point+5;
DessinerScore(*point);
Pastille(tab,1,1);
*temoin=1;
}else if(VerifChemin(tab,*sxmax,*symax-1)==2){
*symax=*symax-1;
tab[*sxmax][*symax]=1;;
Pastille(tab,5,3);
Pastille(tab,1,2);
}else{
*fin=1;
}
}
/*bas*/
if(direction==0){
if(VerifChemin(tab,*sxmax+1,*symax)==1){
*sxmax=*sxmax+1;
tab[*sxmax][*symax]=1;
}
else if(VerifChemin(tab,*sxmax+1,*symax)==3){
*sxmax=*sxmax+1;
tab[*sxmax][*symax]=1;
*point=*point+5;
DessinerScore(*point);
Pastille(tab,1,1);
*temoin=1;
}else if(VerifChemin(tab,*sxmax+1,*symax)==2){
*sxmax=*sxmax+1;
tab[*sxmax][*symax]=1;
Pastille(tab,5,3);
Pastille(tab,1,2);
}else{
*fin=1;
}
}
}
/*seme les angles pour dire a la queue où aller*/
int Semage(int tab[H][L],int direction,int sxmax,int symax,int* pause,int* fin){
int newdirec;
newdirec=CliqueTouche(direction,pause,fin);
if(newdirec!=direction){
if(newdirec==0){
tab[sxmax][symax]=6;
}
if(newdirec==1){
tab[sxmax][symax]=7;
}
if(newdirec==2){
tab[sxmax][symax]=8;
}
if(newdirec==3){
tab[sxmax][symax]=9;
}
direction=newdirec;
return direction;
}
}
int main(void){
int tab[H][L],direction=0,temoin=0,direc=0,pause=1;
int sxmin=1,symin=2,sxmax=11,symax=2,fin=0,point=0,Compteur_Temps=0;
int* pointeur_pause=&pause;
int* pointeur_sxmin=&sxmin;
int* pointeur_symin=&symin;
int* pointeur_direc=&direc;
int* pointeur_temoin=&temoin;
int* pointeur_sxmax=&sxmax;
int* pointeur_symax=&symax;
int* pointeur_fin=&fin;
int* pointeur_point=&point;
unsigned long suivant=Microsecondes()+DELTA,suivant2=Microsecondes()+DELTO,suivant3=Microsecondes()+DELTO;
init(tab);
while(1){
Affiche(tab);
/*touche*/
if(ToucheEnAttente()==1){
direction=Semage(tab,direction,sxmax,symax,pointeur_pause,pointeur_fin);
}
if(pause==1){
/*timer*/
if(Microsecondes()>suivant){
Compteur_Temps++;
DessinerTimer(Compteur_Temps);
suivant=Microsecondes()+DELTA;
}
/*deplacement queue*/
if(Microsecondes()>suivant3){
DeplacementQueue(tab,pointeur_sxmin,pointeur_symin,pointeur_direc);
suivant3=TempsArret(pointeur_temoin);
}
/*deplacement tete*/
if(Microsecondes()>suivant2){
DeplacementTete(tab,pointeur_sxmax,pointeur_symax,direction,pointeur_temoin,pointeur_fin,pointeur_point);
suivant2=Microsecondes()+DELTO;
}
}
if(fin==1){
return EXIT_SUCCESS;
}
}
}

89
Snake_ancien/Afficher.c
View File

@ -1,89 +0,0 @@
#include <stdlib.h>
#include <stdio.h>
#include <graph.h>
#include "Afficher.h"
/*affichage du plateau de jeu en fonction du tableau*/
void AfficheTab(int tab[H][L], int posx, int posy, int i, int j){
couleur c;
if(tab[i][j]==0){
c=CouleurParNom("black");
ChoisirCouleurDessin(c);
RemplirRectangle(posx,posy,20,20);
}
if(tab[i][j]==40){
c=CouleurParNom("dark grey");
ChoisirCouleurDessin(c);
RemplirRectangle(posx,posy,20,20);
c=CouleurParNom("black");
ChoisirCouleurDessin(c);
DessinerRectangle(posx+2,posy+2,16,16);
}
if(tab[i][j]==1||tab[i][j]==9||tab[i][j]==7||tab[i][j]==8||tab[i][j]==6){
c=CouleurParNom("dark orange");
ChoisirCouleurDessin(c);
RemplirRectangle(posx,posy,20,20);
c=CouleurParNom("brown");
ChoisirCouleurDessin(c);
RemplirArc(posx+5,posy+5,10,10,360,360);
}
if(tab[i][j]==30){
c=CouleurParNom("black");
ChoisirCouleurDessin(c);
RemplirRectangle(posx,posy,20,20);
c=CouleurParNom("red");
ChoisirCouleurDessin(c);
RemplirArc(posx,posy,20,20,360,360);
}
if(tab[i][j]==50){
c=CouleurParNom("black");
ChoisirCouleurDessin(c);
RemplirRectangle(posx,posy,20,20);
c=CouleurParNom("purple");
ChoisirCouleurDessin(c);
RemplirArc(posx,posy,20,20,360,360);
}
}
/*parcours du tableau pour rendu graphique*/
void Affiche(int tab[H][L]){
int i,j,posx=0,posy=0;
for(i=0;i<=H;i++){
for(j=0;j<=L;j++){
AfficheTab(tab, posx, posy, i, j);
posx=posx+20;
}
posx=0;
posy=posy+20;
}
posx=0;
posy=0;
}
/*affichage du score*/
void DessinerScore(int n){
couleur c;
char buf[100];
c=CouleurParNom("dark blue");
ChoisirCouleurDessin(c);
RemplirRectangle(200,875,200,100);
c=CouleurParNom("yellow");
ChoisirCouleurDessin(c);
snprintf(buf,100,"score : %d",n);
EcrireTexte(250,900,buf,2);
}
/*affichage du timer*/
void DessinerTimer(int n){
couleur c;
char buf[100];
c=CouleurParNom("dark blue");
ChoisirCouleurDessin(c);
RemplirRectangle(0,875,200,100);
c=CouleurParNom("red");
ChoisirCouleurDessin(c);
snprintf(buf,100,"time : %d",n);
EcrireTexte(50,900,buf,2);
}

17
Snake_ancien/Afficher.h
View File

@ -1,17 +0,0 @@
#ifndef AFFICHER_H
#define AFFICHER_H
#include <stdlib.h>
#include <stdio.h>
#include <graph.h>
#include <time.h>
#define H 42
#define L 62
void AfficheTab(int tab[H][L], int posx, int posy, int i, int j);
void Affiche(int tab[H][L]);
void DessinerScore(int n);
void DessinerTimer(int n);
#endif // AFFICHER_H

82
Snake_ancien/Chemin.c
View File

@ -1,82 +0,0 @@
#include "Chemin.h"
#include "Deplacement.h"
#include <stdlib.h>
#include <stdio.h>
#include <graph.h>
/*seme les angles pour dire a la queue où aller*/
int Semage(int tab[H][L],int direction,int sxmax,int symax,int* pause,int* fin){
int newdirec;
newdirec=CliqueTouche(direction,pause,fin);
if(newdirec!=direction){
if(newdirec==0){
tab[sxmax][symax]=6;
}
if(newdirec==1){
tab[sxmax][symax]=7;
}
if(newdirec==2){
tab[sxmax][symax]=8;
}
if(newdirec==3){
tab[sxmax][symax]=9;
}
direction=newdirec;
return direction;
}
}
/*arrete la queue le temps que la tete avance un peu pour permettre au serpent de grandir*/
unsigned long TempsArret(int* temoin){
if(*temoin==1){
*temoin=0;
return Microsecondes()+DELTI;
}else if(*temoin==0){
return Microsecondes()+DELTO;
}
}
/*verification de la case ou on va aller*/
int VerifChemin(int tab[H][L], int x, int y){
if(tab[x][y]==0){
return 1;
}else if(tab[x][y]==30){
return 3;
}else if(tab[x][y]==50){
return 2;
}else{
return 0;
}
}
/*Verification sir le joueuer a gagner ou perdu*/
int Gagne(int tab[H][L]){
int i,j;
for(i=0;i<=H;i++){
for(j=0;j<=L;j++){
if(tab[i][j]==0||tab[i][j]==30||tab[i][j]==30){
return 1;
}
}
}
return 0;
}
/*regarde la case ou la queue est pour savoir ou elle va aller ensuite*/
int VoirCase(int tab[H][L],int x, int y,int defaut){
if(tab[x][y]==9){
return 3;
}
else if(tab[x][y]==8){
return 2;
}
else if(tab[x][y]==7){
return 1;
}
else if(tab[x][y]==6){
return 0;
}
else{
return defaut;
}
}

20
Snake_ancien/Chemin.h
View File

@ -1,20 +0,0 @@
#ifndef CHEMIN_H
#define CHEMIN_H
#include <stdlib.h>
#include <stdio.h>
#include <graph.h>
#include <time.h>
#define H 42
#define L 62
#define DELTO 1000L
#define DELTI 900000L
int Semage(int tab[H][L], int direction, int sxmax, int symax, int *pause, int *fin);
unsigned long TempsArret(int *temoin);
int VerifChemin(int tab[H][L], int x, int y);
int VoirCase(int tab[H][L], int x, int y, int defaut);
int Gagne(int tab[H][L]);
#endif // CHEMIN_H

208
Snake_ancien/Deplacement.c
View File

@ -1,208 +0,0 @@
#include "Deplacement.h"
#include <stdio.h>
#include <stdlib.h>
#include <graph.h>
#include "Chemin.h"
#include "Afficher.h"
#include "ModifTab.h"
/*verifie les touches cliquée par le joueur*/
int CliqueTouche(int defaut,int* pause,int* fin){
switch(Touche()){
case XK_Up:
if(defaut!=0){
defaut=2;
return defaut;
}else{
return defaut;
}
case XK_Down:
if(defaut!=2){
defaut=0;
return defaut;
}else{
return defaut;
}
case XK_Right:
if(defaut!=1){
defaut=3;
return defaut;
}else{
return defaut;
}
case XK_Left:
if(defaut!=3){
defaut=1;
return defaut;
}else{
return defaut;
}
case XK_space:
if(*pause==1){
*pause=0;
return defaut;
}
else if(*pause==0){
*pause=1;
return defaut;
}
case XK_Escape:
*fin=1;
return defaut;
default :
return defaut;
}
}
/*deplacement de la queue du serpent en fonction de la trace laissée par la tete*/
void DeplacementQueue(int tab[H][L],int* sxmin,int* symin,int* direc, int menu){
if(menu==3){
if(*direc==0){
*sxmin=*sxmin+1;
*direc=VoirCase(tab,*sxmin,*symin,*direc);
tab[*sxmin][*symin]=40;
}
else if(*direc==1){
*symin=*symin-1;
*direc=VoirCase(tab,*sxmin,*symin,*direc);
tab[*sxmin][*symin]=40;
}
else if(*direc==2){
*sxmin=*sxmin-1;
*direc=VoirCase(tab,*sxmin,*symin,*direc);
tab[*sxmin][*symin]=40;
}
else if(*direc==3){
*symin=*symin+1;
*direc=VoirCase(tab,*sxmin,*symin,*direc);
tab[*sxmin][*symin]=40;
}
}else{
if(*direc==0){
*sxmin=*sxmin+1;
*direc=VoirCase(tab,*sxmin,*symin,*direc);
tab[*sxmin][*symin]=0;
}
else if(*direc==1){
*symin=*symin-1;
*direc=VoirCase(tab,*sxmin,*symin,*direc);
tab[*sxmin][*symin]=0;
}
else if(*direc==2){
*sxmin=*sxmin-1;
*direc=VoirCase(tab,*sxmin,*symin,*direc);
tab[*sxmin][*symin]=0;
}
else if(*direc==3){
*symin=*symin+1;
*direc=VoirCase(tab,*sxmin,*symin,*direc);
tab[*sxmin][*symin]=0;
}
}
}
/*Deplacement de la tete du seroent en fonction de la direction*/
void DeplacementTete(int tab[H][L],int* sxmax,int* symax,int direction,int* temoin,int* fin,int* point,int mode){
if(direction==2){
if(VerifChemin(tab,*sxmax-1,*symax)==1){
*sxmax=*sxmax-1;
tab[*sxmax][*symax]=1;
}else if(VerifChemin(tab,*sxmax-1,*symax)==3){
*sxmax=*sxmax-1;
tab[*sxmax][*symax]=1;
*point=*point+5;
DessinerScore(*point);
Pastille(tab,1,1);
*temoin=1;
}else if(VerifChemin(tab,*sxmax-1,*symax)==2){
*sxmax=*sxmax-1;
tab[*sxmax][*symax]=1;
if(mode==3){
Pastille(tab,20,3);
}else{
Pastille(tab,5,3);
}
Pastille(tab,1,2);
}else{
*fin=1;
}
}
/*droite*/
if(direction==3){
if(VerifChemin(tab,*sxmax,*symax+1)==1){
*symax=*symax+1;
tab[*sxmax][*symax]=1;
}else if(VerifChemin(tab,*sxmax,*symax+1)==3){
*symax=*symax+1;
tab[*sxmax][*symax]=1;
*point=*point+5;
DessinerScore(*point);
Pastille(tab,1,1);
*temoin=1;
}else if(VerifChemin(tab,*sxmax,*symax+1)==2){
*symax=*symax+1;
tab[*sxmax][*symax]=1;
if(mode==3){
Pastille(tab,20,3);
}else{
Pastille(tab,5,3);
}
Pastille(tab,1,2);
}else{
*fin=1;
}
}
/*gauche*/
if(direction==1){
if(VerifChemin(tab,*sxmax,*symax-1)==1){
*symax=*symax-1;
tab[*sxmax][*symax]=1;
}
else if(VerifChemin(tab,*sxmax,*symax-1)==3){
*symax=*symax-1;
tab[*sxmax][*symax]=1;
*point=*point+5;
DessinerScore(*point);
Pastille(tab,1,1);
*temoin=1;
}else if(VerifChemin(tab,*sxmax,*symax-1)==2){
*symax=*symax-1;
tab[*sxmax][*symax]=1;
if(mode==3){
Pastille(tab,20,3);
}else{
Pastille(tab,5,3);
}
Pastille(tab,1,2);
}else{
*fin=1;
}
}
/*bas*/
if(direction==0){
if(VerifChemin(tab,*sxmax+1,*symax)==1){
*sxmax=*sxmax+1;
tab[*sxmax][*symax]=1;
}
else if(VerifChemin(tab,*sxmax+1,*symax)==3){
*sxmax=*sxmax+1;
tab[*sxmax][*symax]=1;
*point=*point+5;
DessinerScore(*point);
Pastille(tab,1,1);
*temoin=1;
}else if(VerifChemin(tab,*sxmax+1,*symax)==2){
*sxmax=*sxmax+1;
tab[*sxmax][*symax]=1;
if(mode==3){
Pastille(tab,20,3);
}else{
Pastille(tab,5,3);
}
Pastille(tab,1,2);
}else{
*fin=1;
}
}
}

16
Snake_ancien/Deplacement.h
View File

@ -1,16 +0,0 @@
#ifndef DEPLACEMENT_H
#define DEPLACEMENT_H
#include <stdlib.h>
#include <stdio.h>
#include <graph.h>
#include <time.h>
#define H 42
#define L 62
int CliqueTouche(int defaut, int *pause, int *fin);
void DeplacementQueue(int tab[H][L], int *sxmin, int *symin, int *direc,int);
void DeplacementTete(int tab[H][L], int *sxmax, int *symax, int direction, int *temoin, int *fin, int *point,int menu);
#endif // DEPLACEMENT_H

74
Snake_ancien/Jeu.c
View File

@ -1,74 +0,0 @@
#include <stdlib.h>
#include <stdio.h>
#include <graph.h>
#include <time.h>
#include "Afficher.h"
#include "ModifTab.h"
#include "Deplacement.h"
#include "Chemin.h"
#include "Menu.h"
#include "Jeu.h"
#define DELTA 1000000L;
#define DELTO 1000L
#define DELTI 900000L
void LancerJeu(void)
{
int tab[H][L], direction = 0, temoin = 0, direc = 0, pause = 1,mode=0;
int sxmin = 17, symin = 30, sxmax = 27, symax = 30, fin = 0, point = 0, Compteur_Temps = 0;
int *pointeur_pause = &pause;
int *pointeur_sxmin = &sxmin;
int *pointeur_symin = &symin;
int *pointeur_direc = &direc;
int *pointeur_temoin = &temoin;
int *pointeur_sxmax = &sxmax;
int *pointeur_symax = &symax;
int *pointeur_fin = &fin;
int *pointeur_point = &point;
unsigned long suivant = Microsecondes() + DELTA;
unsigned long suivant2 = Microsecondes() + DELTO;
unsigned long suivant3 = Microsecondes() + DELTO;
InitEcran();
mode=MenuDebut();
init(tab,mode);
while (1)
{
if(fin!=1)
{
Affiche(tab);
if (ToucheEnAttente() == 1)
{
direction = Semage(tab, direction, sxmax, symax, pointeur_pause, pointeur_fin);
}
if (pause == 1) {
if (Microsecondes() > suivant) {
Compteur_Temps++;
DessinerTimer(Compteur_Temps);
suivant = Microsecondes() + DELTA;
}
if (Microsecondes() > suivant3) {
DeplacementQueue(tab, pointeur_sxmin, pointeur_symin, pointeur_direc,mode);
suivant3 = TempsArret(pointeur_temoin);
}
if (Microsecondes() > suivant2) {
DeplacementTete(tab, pointeur_sxmax, pointeur_symax, direction, pointeur_temoin, pointeur_fin, pointeur_point,mode);
suivant2 = Microsecondes() + DELTO;
}
MenuPause(pause);
}else{
MenuPause(pause);
}
}
else if (fin == 1) {
if(Gagne(tab)==0){
MenuFinGagne();
}else{
MenuFinPerdu();
}
}
}
}

11
Snake_ancien/Jeu.h
View File

@ -1,11 +0,0 @@
#ifndef JEU_H
#define JEU_H
#include <stdlib.h>
#include <stdio.h>
#include <graph.h>
#include <time.h>
void LancerJeu(void);
#endif

170
Snake_ancien/Menu.c
View File

@ -1,170 +0,0 @@
#include<stdio.h>
#include<stdlib.h>
#include<graph.h>
#include "Menu.h"
#include "Jeu.h"
int MenuDebut(void){
couleur c=CouleurParNom("green");
ChoisirCouleurDessin(c);
RemplirRectangle(1300,100,300,200);
c=CouleurParNom("purple");
ChoisirCouleurDessin(c);
RemplirRectangle(1300,400,300,200);
c=CouleurParNom("red");
ChoisirCouleurDessin(c);
RemplirRectangle(1300,700,300,200);
c=CouleurParNom("white");
ChoisirCouleurDessin(c);
EcrireTexte(1400,150,"Normal",1);
EcrireTexte(1400,450,"Mirror",1);
EcrireTexte(1400,750,"Hard",1);
EcrireTexte(50,100,"Snake de Maxim Lalane et Raphael Beau",2);
EcrireTexte(200,200,"Choisissez un mode de jeu : ",1);
EcrireTexte(250,250,"-Normal, un jeu snake tout ce qu'il y a de plus basique",1);
EcrireTexte(250,300,"-Mirror, les murs sur les cotes tombent, les boules violettes font leur apparition !",1);
EcrireTexte(250,350,"-Hard, Bon courage !! (vraiment)",1);
EcrireTexte(200,450,"Les regles sont simples :",1);
c=CouleurParNom("dark blue");
ChoisirCouleurDessin(c);
RemplirRectangle(650,483,20,20);
c=CouleurParNom("red");
ChoisirCouleurDessin(c);
RemplirArc(650,483,20,20,360,360);
c=CouleurParNom("dark blue");
ChoisirCouleurDessin(c);
RemplirRectangle(803,582,20,20);
c=CouleurParNom("purple");
ChoisirCouleurDessin(c);
RemplirArc(803,582,20,20,360,360);
c=CouleurParNom("dark grey");
ChoisirCouleurDessin(c);
RemplirRectangle(615,530,20,20);
c=CouleurParNom("black");
ChoisirCouleurDessin(c);
DessinerRectangle(617,532,16,16);
c=CouleurParNom("white");
ChoisirCouleurDessin(c);
EcrireTexte(250,500,"Regle n1-Mangez un maximum de pommes pour grandir",1);
c=CouleurParNom("white");
ChoisirCouleurDessin(c);
EcrireTexte(250,550,"Regle n2-Ne vous prennez pas de murs , ou vous perdrez !",1);
c=CouleurParNom("white");
ChoisirCouleurDessin(c);
EcrireTexte(250,600,"Regle n3-Malheur a vous si vous prennez une prune surprise .",1);
c=CouleurParNom("white");
ChoisirCouleurDessin(c);
EcrireTexte(250,650,"Regle n4-N'oubliez pas de vous amuser ;)",1);
while(1){
if(SourisCliquee()==1){
if(_X>=1300&&_Y>=100&&_X<=1600&&_Y<=300){
return 1;
}
if(_X>=1300&&_Y>=400&&_X<=1600&&_Y<=600){
return 2;
}
if(_X>=1300&&_Y>=700&&_X<=1600&&_Y<=900){
return 3;
}
}
}
}
/*Initialisation de la page*/
void InitEcran(void){
InitialiserGraphique();
CreerFenetre(10,10,1700,1000);
couleur c;
c=CouleurParNom("dark blue");
ChoisirCouleurDessin(c);
RemplirRectangle(0,0,1700,1000);
}
void MenuPause(int pause){
couleur c;
if(pause == 0){
c=CouleurParNom("white");
ChoisirCouleurDessin(c);
EcrireTexte(1330,450,"Menu pause (appuyez sur espace)",1);
}else{
c=CouleurParNom("dark blue");
ChoisirCouleurDessin(c);
RemplirRectangle(1330,300,500,500);
}
}
int MenuFinPerdu(void){
couleur c=CouleurParNom("purple");
ChoisirCouleurDessin(c);
RemplirRectangle(1300,400,300,200);
c=CouleurParNom("red");
ChoisirCouleurDessin(c);
RemplirRectangle(1300,700,300,200);
c=CouleurParNom("white");
ChoisirCouleurDessin(c);
EcrireTexte(1400,450,"Recommencer",1);
EcrireTexte(1400,750,"Quitter",1);
EcrireTexte(1350,200,"Dommage !",2);
EcrireTexte(1280,250,"Peut-etre une prochaine fois",2);
while(1){
if(SourisCliquee()==1){
if(_X>=1300&&_Y>=400&&_X<=1600&&_Y<=600)
{
FermerGraphique();
LancerJeu();
}
if(_X>=1300&&_Y>=700&&_X<=1600&&_Y<=900)
{
FermerGraphique();
return EXIT_SUCCESS;
}
}
}
}
int MenuFinGagne(void){
couleur c=CouleurParNom("purple");
ChoisirCouleurDessin(c);
RemplirRectangle(1300,400,300,200);
c=CouleurParNom("red");
ChoisirCouleurDessin(c);
RemplirRectangle(1300,700,300,200);
c=CouleurParNom("white");
ChoisirCouleurDessin(c);
EcrireTexte(1400,450,"Recommencer",1);
EcrireTexte(1400,750,"Quitter",1);
EcrireTexte(1350,200,"Felicitations !",2);
EcrireTexte(1280,200,"Vous etes trop fort !!",2);
while(1){
if(SourisCliquee()==1){
if(_X>=1300&&_Y>=400&&_X<=1600&&_Y<=600)
{
FermerGraphique();
LancerJeu();
}
if(_X>=1300&&_Y>=700&&_X<=1600&&_Y<=900)
{
FermerGraphique();
return EXIT_SUCCESS;
}
}
}
}

15
Snake_ancien/Menu.h
View File

@ -1,15 +0,0 @@
#ifndef MENU_H
#define MENU_H
#include <stdio.h>
#include <stdlib.h>
#include <graph.h>
#include <time.h>
int MenuDebut(void);
void InitEcran(void);
int MenuFinPerdu(void);
int MenuFinGagne(void);
void MenuPause(int pause);
#endif // MENU_H

81
Snake_ancien/ModifTab.c
View File

@ -1,81 +0,0 @@
#include "ModifTab.h"
#include "Afficher.h"
#include <stdio.h>
#include <stdlib.h>
#include <graph.h>
/*initialisation du plateau de jeu*/
void init(int tab[H][L], int mode){
int i,j;
couleur c;
c=CouleurParNom("dark blue");
ChoisirCouleurDessin(c);
RemplirRectangle(0,0,1700,1000);
DessinerScore(0);
DessinerTimer(0);
/*initialisation de la grille a 0(noir)*/
for(i=1;i<H;i++){
for(j=1;j<L;j++){
tab[i][j]=0;
}
}
/*initialisation bordure*/
if(mode==2){
for(i=0;i<=H;i++){
tab[i][L]=0;
tab[i][0]=0;
}
}
else{
for(i=0;i<=H;i++){
tab[i][L]=40;
tab[i][0]=40;
}
}
for(i=0;i<=L;i++){
tab[H][i]=40;
tab[0][i]=40;
}
/*initialisation du serpent*/
tab[18][30]=0;
tab[18][30]=0;
tab[27][30]=1;
for(i=18;i<28;i++){
tab[i][30]=1;
}
/*Initalisation des differences pastilles*/
if(mode==3||mode==2){
Pastille(tab,2,2);
}
Pastille(tab,5,1);
}
/*Mise en place de pastilles le plateau de jeu
en fonction de ce que l'on veut placer */
int Pastille(int tab[H][L],int nb_de_pastilles,int type_pastille){
int ia,ja;
if(nb_de_pastilles==0){
return 1;
}
srand(time(NULL));
while(nb_de_pastilles!=0){
ia=rand()%40;
ja=rand()%60;
if(tab[ia][ja]==0){
if(type_pastille==1){
/*pommes*/
tab[ia][ja]=30;
}else if(type_pastille==2){
/*pommes pour mur*/
tab[ia][ja]=50;
}else if(type_pastille==3){
/*mur*/
tab[ia][ja]=40;
}
nb_de_pastilles=nb_de_pastilles-1;
}
}
}

15
Snake_ancien/ModifTab.h
View File

@ -1,15 +0,0 @@
#ifndef MODIFTAB_H
#define MODIFTAB_H
#include <stdlib.h>
#include <stdio.h>
#include <graph.h>
#include <time.h>
#define H 42
#define L 62
int Pastille(int tab[H][L], int nb_de_pastilles, int type_pastille);
void init(int tab[H][L],int);
#endif // MODIFTAB_H

5
Snake_ancien/main.c
View File

@ -1,5 +0,0 @@
#include "Jeu.h"
int main(void) {
LancerJeu();
}

22
Snake_ancien/makefile
View File

@ -1,22 +0,0 @@
exec : Chemin.o Deplacement.o Afficher.o ModifTab.o main.o Menu.o Jeu.o
gcc -ansi -o exec Chemin.o Deplacement.o Afficher.o ModifTab.o main.o Menu.o Jeu.o -lgraph
run : exec
./exec
Chemin.o : Chemin.c
gcc -c Chemin.c -lgraph
Deplacement.o : Deplacement.c
gcc -c Deplacement.c -lgraph
Afficher.o : Afficher.c
gcc -c Afficher.c -lgraph
ModifTab.o : ModifTab.c
gcc -c ModifTab.c -lgraph
main.o : main.c
gcc -c main.c -lgraph
Menu.o : Menu.c
gcc -c Menu.c -lgraph
Jeu.o : Jeu.c
gcc -c Jeu.c -lgraph
clean :
rm -f *~
rm -f *.o
rm exec

196
Suivre.c
View File

@ -1,196 +0,0 @@
#include<stdlib.h>
#include<stdio.h>
#include<graph.h>
#include<time.h>
#include<unistd.h>
#define H 40
#define L 60
#define DELTA 1000000L
#define DELTO 1000000L
/*recuperation des couleurs en fonction des chiffres dans le tableau*/
void AfficheTab(int tab[H][L], int posx, int posy, int i, int j){
couleur c;
if(tab[i][j]==0){
c=CouleurParNom("black");
ChoisirCouleurDessin(c);
RemplirRectangle(posx,posy,20,20);
}
/*
6>droite
7>gauche
8>haut
8>bas
*/
if(tab[i][j]==1||tab[i][j]==6||tab[i][j]==7||tab[i][j]==8||tab[i][j]==9){
c=CouleurParNom("dark orange");
ChoisirCouleurDessin(c);
RemplirRectangle(posx,posy,20,20);
}
}
/*affichage du tableau pour rendu graphique*/
void Affiche(int tab[H][L]){
int i,j,posx=0,posy=0;
for(i=0;i<H;i++){
for(j=0;j<L;j++){
AfficheTab(tab, posx, posy, i, j);
posx=posx+20;
}
posx=0;
posy=posy+20;
}
posx=0;
posy=0;
}
/*recuperation de la direction en fonction des touches*/
int CliqueTouche(int tab[H][L],int direction){
switch(Touche()){
case XK_Up:
if(direction!=0){
printf("aaaaaaa");
direction=2;
return direction;
}
case XK_Down:
if(direction!=2){
printf("zzzzzzz");
direction=0;
return direction;
}
case XK_Right:
if(direction!=1){
printf("eeeeeeeee");
direction=3;
return direction;
}
case XK_Left:
if(direction!=3){
printf("rrrrrrrr");
direction=1;
return direction;
}
}
}
int DepXTete(unsigned long suivant2,int sxmax,int symax,int direction,int tab[H][L]){
/*haut*/
if(direction==2){
sxmax=sxmax-1;
tab[sxmax][symax]=1;
return sxmax;
}
/*bas*/
if(direction==0){
sxmax=sxmax+1;
tab[sxmax][symax]=1;
return sxmax;
}
}
int DepYTete(unsigned long suivant2,int sxmax,int symax,int direction,int tab[H][L]){
/*droite*/
if(direction==3){
symax=symax+1;
tab[sxmax][symax]=1;
return symax;
}
/*gauche*/
if(direction==1){
symax=symax-1;
tab[sxmax][symax]=1;
return symax;
}
}
/*mvmt du serpent*/
void Serpent(int tab[H][L]){
int sxmax=10,sxmin=1,symin=1,symax=1,direction=0;
unsigned long suivant2=Microsecondes()+DELTO;
/*deplacement tete*/
if(Microsecondes()>=suivant2){
if(direction==0||direction==2){
sxmax=DepXTete(suivant2,sxmax,symax,direction,tab);
}
else if(direction==1||direction==3){
symax=DepYTete(suivant2,sxmax,symax,direction,tab);
}
suivant2=Microsecondes()+DELTO;
}
}
/*affichage du timer*/
void DessinerTimer(int n){
couleur c;
char buf[100];
c=CouleurParNom("white");
ChoisirCouleurDessin(c);
RemplirRectangle(0,850,200,100);
c=CouleurParNom("black");
ChoisirCouleurDessin(c);
snprintf(buf,100,"time : %d",n);
EcrireTexte(50,900,buf,2);
}
/*initialisation de la grille et de la fenetre*/
void init(int tab[H][L]){
/*creation page*/
InitialiserGraphique();
CreerFenetre(10,10,1700,1000);
couleur c;
c=CouleurParNom("green");
ChoisirCouleurDessin(c);
int i,j;
/*initialisation de la grille a 0(vert)*/
for(i=0;i<H;i++){
for(j=0;j<L;j++){
tab[i][j]=0;
}
}
/*initialisation du serpent*/
tab[0][1]=0;
tab[10][1]=1;
for(i=0;i<10;i++){
tab[i][1]=1;
}
}
int main(void){
int tab[H][L];
int n=0,fin=0;
unsigned long suivant;
suivant=Microsecondes()+DELTA;
init(tab);
while(1){
Affiche(tab);
Serpent(tab);
/*timer*/
if(Microsecondes()>suivant){
n++;
DessinerTimer(n);
suivant=Microsecondes()+DELTA;
}
if(fin==1){
return EXIT_SUCCESS;
}
}
}

BIN
a.out
View File

Binary file not shown.

93
archive/Avance.c
View File

@ -1,93 +0,0 @@
#include<stdlib.h>
#include<stdio.h>
#include<graph.h>
#include<time.h>
#define H 40
#define L 60
#define DELTA 1000000L
void Affiche(int tab[H][L], int posx, int posy, int i, int j){
couleur c;
if(tab[i][j]==0){
c=CouleurParNom("green");
ChoisirCouleurDessin(c);
RemplirRectangle(posx,posy,20,20);
}
if(tab[i][j]==1){
c=CouleurParNom("yellow");
ChoisirCouleurDessin(c);
RemplirRectangle(posx,posy,20,20);
}
}
void DessinerScene(int n)
{
couleur c;
char buf[100];
c=CouleurParNom("white");
ChoisirCouleurDessin(c);
RemplirRectangle(0,850,200,100);
c=CouleurParNom("black");
ChoisirCouleurDessin(c);
snprintf(buf,100,"time : %d",n);
EcrireTexte(50,900,buf,2);
}
int main(void){
/*partie graphique*/
InitialiserGraphique();
CreerFenetre(10,10,1700,1000);
couleur c;
c=CouleurParNom("green");
ChoisirCouleurDessin(c);
int tab[H][L];
int i,j,posx=0,posy=0,n=0,sxmin=0,symin=1,sxmax=10,symax=1;
unsigned long suivant,suivant2;
suivant2=Microsecondes()+DELTA;
suivant=Microsecondes()+DELTA;
for(i=0;i<H;i++){
for(j=0;j<L;j++){
tab[i][j]=0;
}
}
tab[sxmin][symin]=0;
tab[sxmax][symax]=1;
for(i=0;i<10;i++){
tab[i][1]=1;
}
while(1){
if(Microsecondes()>suivant){
n++;
DessinerScene(n);
suivant=Microsecondes()+DELTA;
}
if(Microsecondes()>suivant2){
/*tab[sxmax][symax]=0;*/
sxmax=sxmax+1;
tab[sxmax][symax]=1;
tab[sxmin][symin]=0;
sxmin=sxmin+1;
suivant2=Microsecondes()+DELTA;
}
for(i=0;i<H;i++){
for(j=0;j<L;j++){
Affiche(tab, posx, posy, i, j);
posx=posx+20;
}
posx=0;
posy=posy+20;
}
posx=0;
posy=0;
}
}

48
archive/Decouverte.c
View File

@ -1,48 +0,0 @@
#include<stdlib.h>
#include<stdio.h>
#include<graph.h>
#include<time.h>
#define H 40
#define L 60
int main(void){
/*partie graphique*/
InitialiserGraphique();
CreerFenetre(10,10,1700,1000);
couleur c;
c=CouleurParNom("green");
ChoisirCouleurDessin(c);
int tab[H][L];
int i,j,posx=0,posy=0;
for(i=0;i<H;i++){
for(j=0;j<L;j++){
tab[i][j]=0;
}
}
for(i=0;i<H;i++){
for(j=0;j<L;j++){
if(tab[i][j]==0){
c=CouleurParNom("green");
ChoisirCouleurDessin(c);
RemplirRectangle(posx,posy,20,20);
}
posx=posx+20;
}
posx=0;
posy=posy+20;
}
posx=0;
posy=0;
c=CouleurParNom("yellow");
ChoisirCouleurDessin(c);
for(i=0;i<10;i++){
RemplirRectangle(posx,20,20,20);
posx=posx+20;
}
while(1){
}
}

171
archive/Direction.c
View File

@ -1,171 +0,0 @@
#include<stdlib.h>
#include<stdio.h>
#include<graph.h>
#include<time.h>
#define H 40
#define L 60
#define DELTA 1000000L
#define DELTO 1000L
void AfficheTab(int tab[H][L], int posx, int posy, int i, int j){
couleur c;
if(tab[i][j]==0){
c=CouleurParNom("green");
ChoisirCouleurDessin(c);
RemplirRectangle(posx,posy,20,20);
}
if(tab[i][j]==1||tab[i][j]==6||tab[i][j]==7||tab[i][j]==8||tab[i][j]==9){
c=CouleurParNom("yellow");
ChoisirCouleurDessin(c);
RemplirRectangle(posx,posy,20,20);
}
}
void Affiche(int tab[H][L]){
/*affichage du tableau pour rendu graphique*/
int i,j,posx=0,posy=0;
for(i=0;i<H;i++){
for(j=0;j<L;j++){
AfficheTab(tab, posx, posy, i, j);
posx=posx+20;
}
posx=0;
posy=posy+20;
}
posx=0;
posy=0;
}
int CliqueTouche(void){
int direction;
switch(Touche()){
case XK_Up:
if(direction!=0){
direction=2;
return direction;
}
case XK_Down:
if(direction!=2){
direction=0;
return direction;
}
break;
case XK_Right:
if(direction!=1){
direction=3;
return direction;
}
break;
case XK_Left:
if(direction!=3){
direction=1;
return direction;
}
}
}
void DessinerTimer(int n)
{
couleur c;
char buf[100];
c=CouleurParNom("white");
ChoisirCouleurDessin(c);
RemplirRectangle(0,850,200,100);
c=CouleurParNom("black");
ChoisirCouleurDessin(c);
snprintf(buf,100,"time : %d",n);
EcrireTexte(50,900,buf,2);
}
void init(int tab[H][L]){
/*creation page*/
InitialiserGraphique();
CreerFenetre(10,10,1700,1000);
couleur c;
c=CouleurParNom("green");
ChoisirCouleurDessin(c);
int i,j;
/*initialisation de la grille a 0(vert)*/
for(i=0;i<H;i++){
for(j=0;j<L;j++){
tab[i][j]=0;
}
}
/*initialisation du serpent*/
tab[0][1]=0;
tab[10][1]=1;
for(i=0;i<10;i++){
tab[i][1]=1;
}
}
void Direction(int direction,int tab[H][L],int sxmax, int symax){
}
int main(void){
/*partie graphique*/
int tab[H][L],direction=0;
int n=0,sxmin=0,symin=1,sxmax=10,symax=1,fin=0;
unsigned long suivant,suivant2;
suivant2=Microsecondes()+DELTO;
suivant=Microsecondes()+DELTA;
init(tab);
while(1){
Affiche(tab);
/*touche*/
if(ToucheEnAttente()==1){
direction=CliqueTouche();
}
/*timer*/
if(Microsecondes()>suivant){
n++;
DessinerTimer(n);
suivant=Microsecondes()+DELTA;
}
/*deplacement tete*/
if(Microsecondes()>suivant2){
/*haut*/
if(direction==2){
sxmax=sxmax-1;
tab[sxmax][symax]=1;
}
/*droite*/
if(direction==3){
symax=symax+1;
tab[sxmax][symax]=1;
}
/*gauche*/
if(direction==1){
symax=symax-1;
tab[sxmax][symax]=1;
}
/*bas*/
if(direction==0){
sxmax=sxmax+1;
tab[sxmax][symax]=1;
}
suivant2=Microsecondes()+DELTO;
}
if(fin==1){
return EXIT_SUCCESS;
}
}
}

205
archive/Obstable.c
View File

@ -1,205 +0,0 @@
#include<stdlib.h>
#include<stdio.h>
#include<graph.h>
#include<time.h>
/*taille 2 de plus pour avoir les bordures du plateau de jeu*/
#define H 42
#define L 62
/*initialisation des compteur(timer et deplacement du serpent*/
#define DELTA 1000000L
#define DELTO 100L
/*affichage du plateau de jeu en fonction du tableau*/
void AfficheTab(int tab[H][L], int posx, int posy, int i, int j){
couleur c;
if(tab[i][j]==0){
c=CouleurParNom("black");
ChoisirCouleurDessin(c);
RemplirRectangle(posx,posy,20,20);
}
if(tab[i][j]==40){
c=CouleurParNom("dark grey");
ChoisirCouleurDessin(c);
RemplirRectangle(posx,posy,20,20);
}
if(tab[i][j]==1||tab[i][j]==6||tab[i][j]==7||tab[i][j]==8||tab[i][j]==9){
c=CouleurParNom("dark orange");
ChoisirCouleurDessin(c);
RemplirRectangle(posx,posy,20,20);
}
}
/*parcours du tableau pour rendu graphique*/
void Affiche(int tab[H][L]){
int i,j,posx=0,posy=0;
for(i=0;i<=H;i++){
for(j=0;j<=L;j++){
AfficheTab(tab, posx, posy, i, j);
posx=posx+20;
}
posx=0;
posy=posy+20;
}
posx=0;
posy=0;
}
/*test des touches pour le deplacement*/
int CliqueTouche(int defaut){
switch(Touche()){
case XK_Up:
if(defaut!=0){
defaut=2;
return defaut;
}
case XK_Down:
if(defaut!=2){
defaut=0;
return defaut;
}
case XK_Right:
if(defaut!=1){
defaut=3;
return defaut;
}
case XK_Left:
if(defaut!=3){
defaut=1;
return defaut;
}
default :
return defaut;
}
}
/*affichage du timer*/
void DessinerTimer(int n)
{
couleur c;
char buf[100];
c=CouleurParNom("white");
ChoisirCouleurDessin(c);
RemplirRectangle(0,875,200,100);
c=CouleurParNom("black");
ChoisirCouleurDessin(c);
snprintf(buf,100,"time : %d",n);
EcrireTexte(50,900,buf,2);
}
/*initialisation du plateau de jeu*/
void init(int tab[H][L]){
/*creation page*/
InitialiserGraphique();
CreerFenetre(10,10,1700,1000);
int i,j;
/*initialisation de la grille a 0(vert)*/
for(i=1;i<H;i++){
for(j=1;j<L;j++){
tab[i][j]=0;
}
}
/*initialisation bordure*/
for(i=0;i<=H;i++){
tab[i][L]=40;
tab[i][0]=40;
}
for(i=0;i<=L;i++){
tab[H][i]=40;
tab[0][i]=40;
}
/*initialisation du serpent*/
tab[2][2]=0;
tab[10][2]=1;
for(i=2;i<10;i++){
tab[i][2]=1;
}
}
/*verification de la case ou on va aller*/
int VerifChemin(int tab[H][L], int x, int y){
if(tab[x][y]!=0){
return 0;
}else{
return 1;
}
}
int main(void){
int tab[H][L],direction=0;
int n=0,sxmin=0,symin=1,sxmax=10,symax=2,fin=0;
unsigned long suivant,suivant2;
suivant2=Microsecondes()+DELTO;
suivant=Microsecondes()+DELTA;
init(tab);
while(1){
Affiche(tab);
/*touche*/
if(ToucheEnAttente()==1){
direction=CliqueTouche(direction);
}
/*timer*/
if(Microsecondes()>suivant){
n++;
DessinerTimer(n);
suivant=Microsecondes()+DELTA;
}
/*deplacement tete*/
if(Microsecondes()>suivant2){
/*haut*/
if(direction==2){
if(VerifChemin(tab,sxmax-1,symax)==1){
sxmax=sxmax-1;
tab[sxmax][symax]=1;
}else{
fin=1;
}
}
/*droite*/
if(direction==3){
if(VerifChemin(tab,sxmax,symax+1)==1){
symax=symax+1;
tab[sxmax][symax]=1;
}else{
fin=1;
}
}
/*gauche*/
if(direction==1){
if(VerifChemin(tab,sxmax,symax-1)==1){
symax=symax-1;
tab[sxmax][symax]=1;
}
else{
fin=1;
}
}
/*bas*/
if(direction==0){
if(VerifChemin(tab,sxmax+1,symax)==1){
sxmax=sxmax+1;
tab[sxmax][symax]=1;
}
else{
fin=1;
}
}
suivant2=Microsecondes()+DELTO;
}
if(fin==1){
return EXIT_SUCCESS;
}
}
}

247
archive/Points.c
View File

@ -1,247 +0,0 @@
#include<stdlib.h>
#include<stdio.h>
#include<graph.h>
#include<time.h>
/*taille 2 de plus pour avoir les bordures du plateau de jeu*/
#define H 42
#define L 62
/*initialisation des compteur(timer et deplacement du serpent*/
#define DELTA 1000000L
#define DELTO 100L
/*affichage du plateau de jeu en fonction du tableau*/
void AfficheTab(int tab[H][L], int posx, int posy, int i, int j){
couleur c;
if(tab[i][j]==0){
c=CouleurParNom("black");
ChoisirCouleurDessin(c);
RemplirRectangle(posx,posy,20,20);
}
if(tab[i][j]==40){
c=CouleurParNom("dark grey");
ChoisirCouleurDessin(c);
RemplirRectangle(posx,posy,20,20);
}
if(tab[i][j]==1||tab[i][j]==6||tab[i][j]==7||tab[i][j]==8||tab[i][j]==9){
c=CouleurParNom("dark orange");
ChoisirCouleurDessin(c);
RemplirRectangle(posx,posy,20,20);
}
if(tab[i][j]==30){
c=CouleurParNom("light green");
ChoisirCouleurDessin(c);
RemplirRectangle(posx,posy,20,20);
}
}
/*parcours du tableau pour rendu graphique*/
void Affiche(int tab[H][L]){
int i,j,posx=0,posy=0;
for(i=0;i<=H;i++){
for(j=0;j<=L;j++){
AfficheTab(tab, posx, posy, i, j);
posx=posx+20;
}
posx=0;
posy=posy+20;
}
posx=0;
posy=0;
}
/*test des touches pour le deplacement*/
int CliqueTouche(int defaut){
switch(Touche()){
case XK_Up:
if(defaut!=0){
defaut=2;
return defaut;
}
case XK_Down:
if(defaut!=2){
defaut=0;
return defaut;
}
case XK_Right:
if(defaut!=1){
defaut=3;
return defaut;
}
case XK_Left:
if(defaut!=3){
defaut=1;
return defaut;
}
default :
return defaut;
}
}
/*affichage du timer*/
void DessinerTimer(int n)
{
couleur c;
char buf[100];
c=CouleurParNom("white");
ChoisirCouleurDessin(c);
RemplirRectangle(0,875,200,100);
c=CouleurParNom("black");
ChoisirCouleurDessin(c);
snprintf(buf,100,"time : %d",n);
EcrireTexte(50,900,buf,2);
}
void DessinerScore(int n){
couleur c;
char buf[100];
c=CouleurParNom("white");
ChoisirCouleurDessin(c);
RemplirRectangle(0,875,200,100);
c=CouleurParNom("black");
ChoisirCouleurDessin(c);
snprintf(buf,100,"score : %d",n);
EcrireTexte(250,900,buf,2);
}
/*Initialisation des pastilles dans le plateau de jeu*/
int Pastille(int tab[H][L],int nb){
int ia,ja;
if(nb==0){
return 1;
}
srand(time(NULL));
while(nb!=0){
ia=rand()%40;
ja=rand()%60;
if(tab[ia][ja]==0){
tab[ia][ja]=30;
nb=nb-1;
}
}}
/*initialisation du plateau de jeu*/
void init(int tab[H][L]){
/*creation page*/
InitialiserGraphique();
CreerFenetre(10,10,1700,1000);
int i,j;
/*initialisation de la grille a 0(vert)*/
for(i=1;i<H;i++){
for(j=1;j<L;j++){
tab[i][j]=0;
}
}
}
/*initialisation bordure*/
for(i=0;i<=H;i++){
tab[i][L]=40;
tab[i][0]=40;
}
for(i=0;i<=L;i++){
tab[H][i]=40;
tab[0][i]=40;
}
/*initialisation du serpent*/
tab[2][2]=0;
tab[10][2]=1;
for(i=2;i<10;i++){
tab[i][2]=1;
}
Pastille(tab,5);
}
/*verification de la case ou on va aller*/
int VerifChemin(int tab[H][L], int x, int y){
if(tab[x][y]==0){
return 1;
}else if(tab[x][y]==30){
return 3;
}else{
return 0;
}
}
int main(void){
int tab[H][L],direction=0;
int n=0,sxmin=0,symin=1,sxmax=10,symax=2,fin=0,point=0;
unsigned long suivant,suivant2;
suivant2=Microsecondes()+DELTO;
suivant=Microsecondes()+DELTA;
init(tab);
while(1){
Affiche(tab);
/*touche*/
if(ToucheEnAttente()==1){
direction=CliqueTouche(direction);
}
/*timer*/
if(Microsecondes()>suivant){
n++;
DessinerTimer(n);
suivant=Microsecondes()+DELTA;
}
/*deplacement tete*/
if(Microsecondes()>suivant2){
/*haut*/
if(direction==2){
if(VerifChemin(tab,sxmax-1,symax)==1){
sxmax=sxmax-1;
tab[sxmax][symax]=1;
}else{
fin=1;
}
}
/*droite*/
if(direction==3){
if(VerifChemin(tab,sxmax,symax+1)==1){
symax=symax+1;
tab[sxmax][symax]=1;
}else{
fin=1;
}
}
/*gauche*/
if(direction==1){
if(VerifChemin(tab,sxmax,symax-1)==1){
symax=symax-1;
tab[sxmax][symax]=1;
}
else{
fin=1;
}
}
/*bas*/
if(direction==0){
if(VerifChemin(tab,sxmax+1,symax)==1){
sxmax=sxmax+1;
tab[sxmax][symax]=1;
}
else{
fin=1;
}
}
suivant2=Microsecondes()+DELTO;
}
if(fin==1){
return EXIT_SUCCESS;
}
}
}

70
archive/STime.c
View File

@ -1,70 +0,0 @@
#include<stdlib.h>
#include<stdio.h>
#include<graph.h>
#include<time.h>
#define H 40
#define L 60
#define DELTA 1000000L ;
void DessinerScene(int n)
{
couleur c;
char buf[100];
c=CouleurParNom("white");
ChoisirCouleurDessin(c);
RemplirRectangle(0,850,200,100);
c=CouleurParNom("black");
ChoisirCouleurDessin(c);
snprintf(buf,100,"time : %d",n);
EcrireTexte(50,900,buf,2);
}
int main(void){
/*partie graphique*/
InitialiserGraphique();
CreerFenetre(10,10,1700,1000);
couleur c;
c=CouleurParNom("green");
ChoisirCouleurDessin(c);
int tab[H][L];
int i,j,posx=0,posy=0,n=0;
unsigned long suivant;
suivant=Microsecondes()+DELTA;
for(i=0;i<H;i++){
for(j=0;j<L;j++){
tab[i][j]=0;
}
}
for(i=0;i<H;i++){
for(j=0;j<L;j++){
if(tab[i][j]==0){
c=CouleurParNom("green");
ChoisirCouleurDessin(c);
RemplirRectangle(posx,posy,20,20);
}
posx=posx+20;
}
posx=0;
posy=posy+20;
}
posx=0;
posy=0;
c=CouleurParNom("yellow");
ChoisirCouleurDessin(c);
for(i=0;i<10;i++){
RemplirRectangle(posx,20,20,20);
posx=posx+20;
}
while(1){
if (Microsecondes()>suivant)
{
n++;
DessinerScene(n);
suivant=Microsecondes()+DELTA;
}
}
}

392
archive/Suivre.c
View File

@ -1,392 +0,0 @@
#include<stdlib.h>
#include<stdio.h>
#include<graph.h>
#include<time.h>
/*taille 2 de plus pour avoir les bordures du plateau de jeu*/
#define H 42
#define L 62
/*initialisation des compteur(timer et deplacement du serpent*/
#define DELTA 1000000L
#define DELTO 100L
/*affichage du plateau de jeu en fonction du tableau*/
void AfficheTab(int tab[H][L], int posx, int posy, int i, int j){
couleur c;
if(tab[i][j]==0){
c=CouleurParNom("black");
ChoisirCouleurDessin(c);
RemplirRectangle(posx,posy,20,20);
}
if(tab[i][j]==40){
c=CouleurParNom("dark grey");
ChoisirCouleurDessin(c);
RemplirRectangle(posx,posy,20,20);
c=CouleurParNom("black");
ChoisirCouleurDessin(c);
DessinerRectangle(posx+2,posy+2,16,16);
}
if(tab[i][j]==1){
c=CouleurParNom("dark orange");
ChoisirCouleurDessin(c);
RemplirRectangle(posx,posy,20,20);
c=CouleurParNom("brown");
ChoisirCouleurDessin(c);
RemplirArc(posx+5,posy+5,10,10,360,360);
}
if(tab[i][j]==9){
c=CouleurParNom("yellow");
ChoisirCouleurDessin(c);
RemplirRectangle(posx,posy,20,20);
}
if(tab[i][j]==7){
c=CouleurParNom("brown");
ChoisirCouleurDessin(c);
RemplirRectangle(posx,posy,20,20);
}
if(tab[i][j]==8){
c=CouleurParNom("green");
ChoisirCouleurDessin(c);
RemplirRectangle(posx,posy,20,20);
}
if(tab[i][j]==6){
c=CouleurParNom("purple");
ChoisirCouleurDessin(c);
RemplirRectangle(posx,posy,20,20);
}
if(tab[i][j]==30){
c=CouleurParNom("red");
ChoisirCouleurDessin(c);
RemplirArc(posx,posy,20,20,360,360);
}
if(tab[i][j]==50){
c=CouleurParNom("purple");
ChoisirCouleurDessin(c);
RemplirArc(posx,posy,20,20,360,360);
}
}
/*parcours du tableau pour rendu graphique*/
void Affiche(int tab[H][L]){
int i,j,posx=0,posy=0;
for(i=0;i<=H;i++){
for(j=0;j<=L;j++){
AfficheTab(tab, posx, posy, i, j);
posx=posx+20;
}
posx=0;
posy=posy+20;
}
posx=0;
posy=0;
}
int CliqueTouche(int defaut){
switch(Touche()){
case XK_Up:
if(defaut!=0){
defaut=2;
return defaut;
}
case XK_Down:
if(defaut!=2){
defaut=0;
return defaut;
}
case XK_Right:
if(defaut!=1){
defaut=3;
return defaut;
}
case XK_Left:
if(defaut!=3){
defaut=1;
return defaut;
}
default :
return defaut;
}
}
/*affichage du timer*/
void DessinerTimer(int n)
{
couleur c;
char buf[100];
c=CouleurParNom("dark blue");
ChoisirCouleurDessin(c);
RemplirRectangle(0,875,200,100);
c=CouleurParNom("white");
ChoisirCouleurDessin(c);
snprintf(buf,100,"time : %d",n);
EcrireTexte(50,900,buf,2);
}
/*affichage du score*/
void DessinerScore(int n){
couleur c;
char buf[100];
c=CouleurParNom("dark blue");
ChoisirCouleurDessin(c);
RemplirRectangle(200,875,200,100);
c=CouleurParNom("white");
ChoisirCouleurDessin(c);
snprintf(buf,100,"score : %d",n);
EcrireTexte(250,900,buf,2);
}
/*Mise en place de pastilles le plateau de jeu
en fonction de ce que l'on veut placer
*/
int Pastille(int tab[H][L],int nb,int type){
int ia,ja;
if(nb==0){
return 1;
}
srand(time(NULL));
while(nb!=0){
ia=rand()%40;
ja=rand()%60;
if(tab[ia][ja]==0){
if(type==1){
/*pommes*/
tab[ia][ja]=30;
}else if(type==2){
/*pommes pour mur*/
tab[ia][ja]=50;
}else if(type==3){
/*mur*/
tab[ia][ja]=40;
}
nb=nb-1;
}
}
}
/*initialisation du plateau de jeu*/
void init(int tab[H][L]){
/*creation page*/
InitialiserGraphique();
CreerFenetre(10,10,1700,1000);
int i,j;
couleur c;
c=CouleurParNom("dark blue");
ChoisirCouleurDessin(c);
RemplirRectangle(0,0,1700,1000);
DessinerScore(0);
/*initialisation de la grille a 0(vert)*/
for(i=1;i<H;i++){
for(j=1;j<L;j++){
tab[i][j]=0;
}
}
/*initialisation bordure*/
for(i=0;i<=H;i++){
tab[i][L]=40;
tab[i][0]=40;
}
for(i=0;i<=L;i++){
tab[H][i]=40;
tab[0][i]=40;
}
/*initialisation du serpent*/
tab[2][2]=0;
tab[10][2]=1;
tab[10][2]=1;
for(i=2;i<10;i++){
tab[i][2]=1;
}
/*Initalisation des differences pastilles*/
Pastille(tab,5,1);
Pastille(tab,2,2);
}
/*verification de la case ou on va aller*/
int VerifChemin(int tab[H][L], int x, int y){
if(tab[x][y]==0){
return 1;
}else if(tab[x][y]==30){
return 3;
}else if(tab[x][y]==50){
return 2;
}else{
return 0;
}
}
int VoirCase(int tab[H][L],int x, int y,int defaut){
if(tab[x][y]==7){
return 1;
}
if(tab[x][y]==6){
return 3;
}
if(tab[x][y]==8){
return 2;
}
if(tab[x][y]==9){
return 0;
}
}
int main(void){
int tab[H][L],direction=0,direc=0,newdirec=0;;
int n=0,sxmin=1,symin=2,sxmax=10,symax=2,fin=0,point=0;
unsigned long suivant,suivant2,suivant3;
suivant2=Microsecondes()+DELTO;
suivant=Microsecondes()+DELTA;
suivant3=Microsecondes()+DELTO;
init(tab);
while(1){
Affiche(tab);
/*touche*/
if(ToucheEnAttente()==1){
newdirec=CliqueTouche(direction);
if(newdirec!=direction){
if(newdirec==0){
tab[sxmax][symax]=6;
}
if(newdirec==1){
tab[sxmax][symax]=7;
}
if(newdirec==2){
tab[sxmax][symax]=8;
}
if(newdirec==3){
tab[sxmax][symax]=9;
}
direction=newdirec;
}
}
/*timer*/
if(Microsecondes()>suivant){
n++;
DessinerTimer(n);
suivant=Microsecondes()+DELTA;
}
if(Microsecondes()>suivant3){
if(direc==0){
sxmin=sxmin+1;
tab[sxmin][symin]=0;
direc=VoirCase(tab,sxmin,symin,direc);
}
if(direc==1){
symin=symin-1;
tab[sxmin][symin]=0;
direc=VoirCase(tab,sxmin,symin,direc);
}
if(direc==2){
sxmin=sxmin-1;
tab[sxmin][symin]=0;
direc=VoirCase(tab,sxmin,symin,direc);
}
if(direc==3){
symin=symin+1;
tab[sxmin][symin]=0;
direc=VoirCase(tab,sxmin,symin,direc);
}
suivant3=Microsecondes()+DELTO;
}
/*deplacement tete*/
if(Microsecondes()>suivant2){
/*haut*/
if(direction==2){
if(VerifChemin(tab,sxmax-1,symax)==1){
sxmax=sxmax-1;
tab[sxmax][symax]=1;
}else if(VerifChemin(tab,sxmax-1,symax)==3){
sxmax=sxmax-1;
tab[sxmax][symax]=1;
point=point+5;
DessinerScore(point);
Pastille(tab,1,1);
}else if(VerifChemin(tab,sxmax-1,symax)==2){
sxmax=sxmax-1;
tab[sxmax][symax]=1;
Pastille(tab,5,3);
Pastille(tab,1,2);
}else{
fin=1;
}
}
/*droite*/
if(direction==3){
if(VerifChemin(tab,sxmax,symax+1)==1){
symax=symax+1;
tab[sxmax][symax]=1;
}else if(VerifChemin(tab,sxmax,symax+1)==3){
symax=symax+1;
tab[sxmax][symax]=1;
point=point+5;
DessinerScore(point);
Pastille(tab,1,1);
}else if(VerifChemin(tab,sxmax,symax+1)==2){
symax=symax+1;
tab[sxmax][symax]=1;;
Pastille(tab,5,3);
Pastille(tab,1,2);
}else{
fin=1;
}
}
/*gauche*/
if(direction==1){
if(VerifChemin(tab,sxmax,symax-1)==1){
symax=symax-1;
tab[sxmax][symax]=1;
}
else if(VerifChemin(tab,sxmax,symax-1)==3){
symax=symax-1;
tab[sxmax][symax]=1;
point=point+5;
DessinerScore(point);
Pastille(tab,1,1);
}else if(VerifChemin(tab,sxmax,symax-1)==2){
symax=symax-1;
tab[sxmax][symax]=1;;
Pastille(tab,5,3);
Pastille(tab,1,2);
}else{
fin=1;
}
}
/*bas*/
if(direction==0){
if(VerifChemin(tab,sxmax+1,symax)==1){
sxmax=sxmax+1;
tab[sxmax][symax]=1;
}
else if(VerifChemin(tab,sxmax+1,symax)==3){
sxmax=sxmax+1;
tab[sxmax][symax]=1;
point=point+5;
DessinerScore(point);
Pastille(tab,1,1);
}else if(VerifChemin(tab,sxmax+1,symax)==2){
sxmax=sxmax+1;
tab[sxmax][symax]=1;;
Pastille(tab,5,3);
Pastille(tab,1,2);
}else{
fin=1;
}
}
suivant2=Microsecondes()+DELTO;
}
if(fin==1){
return EXIT_SUCCESS;
}
}
}

403
archive/Suivre2.c
View File

@ -1,403 +0,0 @@
#include<stdlib.h>
#include<stdio.h>
#include<graph.h>
#include<time.h>
/*taille 2 de plus pour avoir les bordures du plateau de jeu*/
#define H 42
#define L 62
/*initialisation des compteur(timer et deplacement du serpent*/
#define DELTA 1000000L
#define DELTO 100L
/*affichage du plateau de jeu en fonction du tableau*/
void AfficheTab(int tab[H][L], int posx, int posy, int i, int j){
couleur c;
if(tab[i][j]==0){
c=CouleurParNom("black");
ChoisirCouleurDessin(c);
RemplirRectangle(posx,posy,20,20);
}
if(tab[i][j]==40){
c=CouleurParNom("dark grey");
ChoisirCouleurDessin(c);
RemplirRectangle(posx,posy,20,20);
c=CouleurParNom("black");
ChoisirCouleurDessin(c);
DessinerRectangle(posx+2,posy+2,16,16);
}
if(tab[i][j]==1){
c=CouleurParNom("dark orange");
ChoisirCouleurDessin(c);
RemplirRectangle(posx,posy,20,20);
c=CouleurParNom("brown");
ChoisirCouleurDessin(c);
RemplirArc(posx+5,posy+5,10,10,360,360);
}
if(tab[i][j]==9){
c=CouleurParNom("yellow");
ChoisirCouleurDessin(c);
RemplirRectangle(posx,posy,20,20);
}
if(tab[i][j]==7){
c=CouleurParNom("brown");
ChoisirCouleurDessin(c);
RemplirRectangle(posx,posy,20,20);
}
if(tab[i][j]==8){
c=CouleurParNom("green");
ChoisirCouleurDessin(c);
RemplirRectangle(posx,posy,20,20);
}
if(tab[i][j]==6){
c=CouleurParNom("purple");
ChoisirCouleurDessin(c);
RemplirRectangle(posx,posy,20,20);
}
if(tab[i][j]==30){
c=CouleurParNom("red");
ChoisirCouleurDessin(c);
RemplirArc(posx,posy,20,20,360,360);
}
if(tab[i][j]==50){
c=CouleurParNom("purple");
ChoisirCouleurDessin(c);
RemplirArc(posx,posy,20,20,360,360);
}
}
/*parcours du tableau pour rendu graphique*/
void Affiche(int tab[H][L]){
int i,j,posx=0,posy=0;
for(i=0;i<=H;i++){
for(j=0;j<=L;j++){
AfficheTab(tab, posx, posy, i, j);
posx=posx+20;
}
posx=0;
posy=posy+20;
}
posx=0;
posy=0;
}
int CliqueTouche(int defaut){
switch(Touche()){
case XK_Up:
if(defaut!=0){
defaut=2;
return defaut;
}
case XK_Down:
if(defaut!=2){
defaut=0;
return defaut;
}
case XK_Right:
if(defaut!=1){
defaut=3;
return defaut;
}
case XK_Left:
if(defaut!=3){
defaut=1;
return defaut;
}
default :
return defaut;
}
}
/*affichage du timer*/
void DessinerTimer(int n)
{
couleur c;
char buf[100];
c=CouleurParNom("dark blue");
ChoisirCouleurDessin(c);
RemplirRectangle(0,875,200,100);
c=CouleurParNom("red");
ChoisirCouleurDessin(c);
snprintf(buf,100,"time : %d",n);
EcrireTexte(50,900,buf,2);
}
/*affichage du score*/
void DessinerScore(int n){
couleur c;
char buf[100];
c=CouleurParNom("dark blue");
ChoisirCouleurDessin(c);
RemplirRectangle(200,875,200,100);
c=CouleurParNom("yellow");
ChoisirCouleurDessin(c);
snprintf(buf,100,"score : %d",n);
EcrireTexte(250,900,buf,2);
}
/*Mise en place de pastilles le plateau de jeu
en fonction de ce que l'on veut placer
*/
int Pastille(int tab[H][L],int nb,int type){
int ia,ja;
if(nb==0){
return 1;
}
srand(time(NULL));
while(nb!=0){
ia=rand()%40;
ja=rand()%60;
if(tab[ia][ja]==0){
if(type==1){
/*pommes*/
tab[ia][ja]=30;
}else if(type==2){
/*pommes pour mur*/
tab[ia][ja]=50;
}else if(type==3){
/*mur*/
tab[ia][ja]=40;
}
nb=nb-1;
}
}
}
/*initialisation du plateau de jeu*/
void init(int tab[H][L]){
/*creation page*/
InitialiserGraphique();
CreerFenetre(10,10,1700,1000);
int i,j;
couleur c;
c=CouleurParNom("dark blue");
ChoisirCouleurDessin(c);
RemplirRectangle(0,0,1700,1000);
DessinerScore(0);
DessinerTimer(0);
/*initialisation de la grille a 0(vert)*/
for(i=1;i<H;i++){
for(j=1;j<L;j++){
tab[i][j]=0;
}
}
/*initialisation bordure*/
for(i=0;i<=H;i++){
tab[i][L]=40;
tab[i][0]=40;
}
for(i=0;i<=L;i++){
tab[H][i]=40;
tab[0][i]=40;
}
/*initialisation du serpent*/
tab[2][2]=0;
tab[10][2]=1;
tab[10][2]=1;
for(i=2;i<10;i++){
tab[i][2]=1;
}
/*Initalisation des differences pastilles*/
Pastille(tab,5,1);
Pastille(tab,2,2);
}
/*verification de la case ou on va aller*/
int VerifChemin(int tab[H][L], int x, int y){
if(tab[x][y]==0){
return 1;
}else if(tab[x][y]==30){
return 3;
}else if(tab[x][y]==50){
return 2;
}else{
return 0;
}
}
int VoirCase(int tab[H][L],int x, int y,int defaut){
if(tab[x][y]==9){
return 3;
}
if(tab[x][y]==8){
return 2;
}
if(tab[x][y]==7){
return 1;
}
if(tab[x][y]==6){
return 0;
}
else{
return defaut;
}
}
int main(void){
int tab[H][L],direction=0,direc=0,newdirec=0;;
int n=0,sxmin=1,symin=2,sxmax=10,symax=2,fin=0,point=0;
unsigned long suivant,suivant2,suivant3;
suivant2=Microsecondes()+DELTO;
suivant=Microsecondes()+DELTA;
suivant3=Microsecondes()+DELTO;
init(tab);
while(1){
Affiche(tab);
/*touche*/
if(ToucheEnAttente()==1){
/*seme les angles pour dire a la queue où aller*/
newdirec=CliqueTouche(direction);
if(newdirec!=direction){
if(newdirec==0){
tab[sxmax][symax]=6;
}
if(newdirec==1){
tab[sxmax][symax]=7;
}
if(newdirec==2){
tab[sxmax][symax]=8;
}
if(newdirec==3){
tab[sxmax][symax]=9;
}
direction=newdirec;
}
}
/*timer*/
if(Microsecondes()>suivant){
n++;
DessinerTimer(n);
suivant=Microsecondes()+DELTA;
}
/*socre*/
DessinerScore(point);
/*deplacement queue*/
if(Microsecondes()>suivant3){
if(direc==0){
sxmin=sxmin+1;
direc=VoirCase(tab,sxmin,symin,direc);
tab[sxmin][symin]=0;
}
if(direc==1){
symin=symin-1;
direc=VoirCase(tab,sxmin,symin,direc);
tab[sxmin][symin]=0;
}
if(direc==2){
sxmin=sxmin-1;
direc=VoirCase(tab,sxmin,symin,direc);
tab[sxmin][symin]=0;
}
if(direc==3){
symin=symin+1;
direc=VoirCase(tab,sxmin,symin,direc);
tab[sxmin][symin]=0;
}
suivant3=Microsecondes()+DELTO;
}
/*deplacement tete*/
if(Microsecondes()>suivant2){
/*haut*/
if(direction==2){
if(VerifChemin(tab,sxmax-1,symax)==1){
sxmax=sxmax-1;
tab[sxmax][symax]=1;
}else if(VerifChemin(tab,sxmax-1,symax)==3){
sxmax=sxmax-1;
tab[sxmax][symax]=1;
point=point+5;
DessinerScore(point);
Pastille(tab,1,1);
}else if(VerifChemin(tab,sxmax-1,symax)==2){
sxmax=sxmax-1;
tab[sxmax][symax]=1;
Pastille(tab,5,3);
Pastille(tab,1,2);
}else{
fin=1;
}
}
/*droite*/
if(direction==3){
if(VerifChemin(tab,sxmax,symax+1)==1){
symax=symax+1;
tab[sxmax][symax]=1;
}else if(VerifChemin(tab,sxmax,symax+1)==3){
symax=symax+1;
tab[sxmax][symax]=1;
point=point+5;
DessinerScore(point);
Pastille(tab,1,1);
}else if(VerifChemin(tab,sxmax,symax+1)==2){
symax=symax+1;
tab[sxmax][symax]=1;;
Pastille(tab,5,3);
Pastille(tab,1,2);
}else{
fin=1;
}
}
/*gauche*/
if(direction==1){
if(VerifChemin(tab,sxmax,symax-1)==1){
symax=symax-1;
tab[sxmax][symax]=1;
}
else if(VerifChemin(tab,sxmax,symax-1)==3){
symax=symax-1;
tab[sxmax][symax]=1;
point=point+5;
DessinerScore(point);
Pastille(tab,1,1);
}else if(VerifChemin(tab,sxmax,symax-1)==2){
symax=symax-1;
tab[sxmax][symax]=1;;
Pastille(tab,5,3);
Pastille(tab,1,2);
}else{
fin=1;
}
}
/*bas*/
if(direction==0){
if(VerifChemin(tab,sxmax+1,symax)==1){
sxmax=sxmax+1;
tab[sxmax][symax]=1;
}
else if(VerifChemin(tab,sxmax+1,symax)==3){
sxmax=sxmax+1;
tab[sxmax][symax]=1;
point=point+5;
DessinerScore(point);
Pastille(tab,1,1);
}else if(VerifChemin(tab,sxmax+1,symax)==2){
sxmax=sxmax+1;
tab[sxmax][symax]=1;;
Pastille(tab,5,3);
Pastille(tab,1,2);
}else{
fin=1;
}
}
suivant2=Microsecondes()+DELTO;
}
if(fin==1){
return EXIT_SUCCESS;
}
}
}

69
archive/TestFinProg.c
View File

@ -1,69 +0,0 @@
#include<stdlib.h>
#include<stdio.h>
#include<graph.h>
#include<time.h>
#define H 40
#define L 60
#define DELTA 1000000L ;
void DessinerScene(int n)
{
couleur c;
char buf[100];
c=CouleurParNom("white");
ChoisirCouleurDessin(c);
RemplirRectangle(0,850,200,100);
c=CouleurParNom("black");
ChoisirCouleurDessin(c);
snprintf(buf,100,"time : %d",n);
EcrireTexte(50,900,buf,2);
}
int main(void){
/*partie graphique*/
InitialiserGraphique();
CreerFenetre(10,10,1700,1000);
couleur c;
c=CouleurParNom("green");
ChoisirCouleurDessin(c);
int tab[H][L];
int i,j,posx=0,posy=0,n=0;
unsigned long suivant;
suivant=Microsecondes()+DELTA;
for(i=0;i<H;i++){
for(j=0;j<L;j++){
tab[i][j]=0;
}
}
while(1){
if (Microsecondes()>suivant)
{
n++;
DessinerScene(n);
suivant=Microsecondes()+DELTA;
}
for(i=0;i<H;i++){
for(j=0;j<L;j++){
if(tab[i][j]==0){
c=CouleurParNom("green");
ChoisirCouleurDessin(c);
RemplirRectangle(posx,posy,20,20);
}
if(tab[i][j]==1){
c=CouleurParNom("yellow");
ChoisirCouleurDessin(c);
RemplirRectangle(posx,posy,20,20);
}
posx=posx+20;
}
posx=0;
posy=posy+20;
}
posx=0;
posy=0;
}
}

48
archive/Timer.c
View File

@ -1,48 +0,0 @@
#include<stdlib.h>
#include<graph.h>
#include<stdio.h>
#define DELTA 1000000L;
void DessinerScene(int n)
{
couleur c;
char buf[100];
c=CouleurParNom("white");
ChoisirCouleurDessin(c);
RemplirRectangle(0,0,100,100);
c=CouleurParNom("black");
ChoisirCouleurDessin(c);
snprintf(buf,100,"temps : %05d",n);
EcrireTexte(10,20,buf,0);
}
int main()
{
int n;
couleur c;
unsigned long suivant;
InitialiserGraphique();
CreerFenetre(10,10,800,500);
n=0;
suivant=Microsecondes()+DELTA;
while(1){
if (Microsecondes()>suivant)
{
n++;
DessinerScene(n);
suivant=Microsecondes()+DELTA;
}
}
Touche();
FermerGraphique();
return EXIT_SUCCESS;
}

BIN
archive/a.out
View File

Binary file not shown.

BIN
cc
View File

Binary file not shown.

BIN
exec
View File

Binary file not shown.

198
virage.c
View File

@ -1,198 +0,0 @@
#include<stdlib.h>
#include<stdio.h>
#include<graph.h>
#include<time.h>
#include<unistd.h>
#define H 40
#define L 60
#define DELTA 1000000L
#define DELTO 1000000L
/*recuperation des couleurs en fonction des chiffres dans le tableau*/
void AfficheTab(int tab[H][L], int posx, int posy, int i, int j){
couleur c;
if(tab[i][j]==0){
c=CouleurParNom("black");
ChoisirCouleurDessin(c);
RemplirRectangle(posx,posy,20,20);
}
/*
6>droite
7>gauche
8>haut
8>bas
*/
if(tab[i][j]==1||tab[i][j]==6||tab[i][j]==7||tab[i][j]==8||tab[i][j]==9){
c=CouleurParNom("dark orange");
ChoisirCouleurDessin(c);
RemplirRectangle(posx,posy,20,20);
}
}
/*affichage du tableau pour rendu graphique*/
void Affiche(int tab[H][L]){
int i,j,posx=0,posy=0;
for(i=0;i<H;i++){
for(j=0;j<L;j++){
AfficheTab(tab, posx, posy, i, j);
posx=posx+20;
}
posx=0;
posy=posy+20;
}
posx=0;
posy=0;
}
/*recuperation de la direction en fonction des touches*/
int CliqueTouche(int tab[H][L],int direction){
switch(Touche()){
case XK_Up:
if(direction!=0){
printf("aaaaaaa");
direction=2;
return direction;
}
case XK_Down:
if(direction!=2){
printf("zzzzzzz");
direction=0;
return direction;
}
case XK_Right:
if(direction!=1){
printf("eeeeeeeee");
direction=3;
return direction;
}
case XK_Left:
if(direction!=3){
printf("rrrrrrrr");
direction=1;
return direction;
}
}
}
int DepXTete(int* sxmax,int* symax,int direction,int tab[H][L]){
/*haut*/
if(direction==2){
*sxmax=*sxmax-1;
tab[*sxmax][*symax]=1;
return *sxmax;
}
/*bas*/
if(direction==0){
*sxmax=*sxmax+1;
tab[*sxmax][*symax]=1;
return *sxmax;
}
}
int DepYTete(int* sxmax,int* symax,int* direction,int tab[H][L]){
/*droite*/
if(direction==3){
symax=symax+1;
tab[sxmax][symax]=1;
return symax;
}
/*gauche*/
if(direction==1){
symax=symax-1;
tab[sxmax][symax]=1;
return symax;
}
}
/*mvmt du serpent*/
void Serpent(int tab[H][L], int* psxmax, int* psxmin, int* psymax, int* psymin, int* pdirection){
unsigned long suivant2=Microsecondes()+DELTO;
*pdirection = CliqueTouche(tab,pdirection);
/*deplacement tete*/
if(Microsecondes()>=suivant2){
if(*pdirection==0||*pdirection==2){
*psxmax=DepXTete(psxmax,psymax,pdirection,tab);
}
else if(*pdirection==1||*pdirection==3){
*psymax=DepYTete(psxmax,psymax,pdirection,tab);
}
suivant2=Microsecondes()+DELTO;
}
}
/*affichage du timer*/
void DessinerTimer(int n){
couleur c;
char buf[100];
c=CouleurParNom("white");
ChoisirCouleurDessin(c);
RemplirRectangle(0,850,200,100);
c=CouleurParNom("black");
ChoisirCouleurDessin(c);
snprintf(buf,100,"time : %d",n);
EcrireTexte(50,900,buf,2);
}
/*initialisation de la grille et de la fenetre*/
void init(int tab[H][L]){
/*creation page*/
InitialiserGraphique();
CreerFenetre(10,10,1700,1000);
couleur c;
c=CouleurParNom("green");
ChoisirCouleurDessin(c);
int i,j;
/*initialisation de la grille a 0(vert)*/
for(i=0;i<H;i++){
for(j=0;j<L;j++){
tab[i][j]=0;
}
}
/*initialisation du serpent*/
tab[0][1]=0;
tab[10][1]=1;
for(i=0;i<10;i++){
tab[i][1]=1;
}
}
int main(void){
int tab[H][L];
int n=0,fin=0;
int sxmax=10,sxmin=1,symin=1,symax=1,direction=0;
int* psxmax = &sxmax, psxmin = &sxmin, psymin = &symin, psymax = &symax, pdirection = &direction;
unsigned long suivant;
suivant=Microsecondes()+DELTA;
init(tab);
while(1){
Affiche(tab);
Serpent(tab, *psxmax, *psxmin, *psymax,*psymin,*pdirection);
/*timer*/
if(Microsecondes()>suivant){
n++;
DessinerTimer(n);
suivant=Microsecondes()+DELTA;
}
if(fin==1){
return EXIT_SUCCESS;
}
}
}