Serpentsss

Soyez le premier à donner votre avis sur cette source.

Vue 4 438 fois - Téléchargée 157 fois

Description

Voici un serpent :
il ne faut rien attraper, il y a juste plusieurs serpents !
il faut survivre, les "autres" serpents sont diriges pas algorithme :
  • 2 qui bouge n'importe ou au hasard
  • 1 qui vous "suit"

Maintenant a vous d'inventer d'autre alogrithme (dites les moi !)

Bon alors il y a des bugs ! des fois un serpent travers un autres.
J'ai fais ce programme juste pour montrer que les serpents, on peut en mettre beaucoup ! (dans l'exemple il y en a 4) et que c'est interresant de faire des algorithmes pour un serpent !

Je tiens a remarquer que l'algorithme bebete ... he bien moi je trouve que le serpent a l'aire naturel ! poutant l'algo est tres simple ! Faites moi part de votre avis.

Source / Exemple :


#include <stdlib.h>
#include <stdio.h>
#include <conio.h>
#include <dos.h>
#include <time.h>
#include <stdlib.h>

/******************************************************/
#define TRUE 			1
#define FALSE 		0
/******************************************************/
#define SIZE_GROUND_X                       37
#define SIZE_GROUND_Y                       20

#define SIZE_SNAKE_BEGIN										5
#define SIZE_MAX_SNAKE                      20
#define NB_ITERATION_FOR_EXPAND_SNAKE       10
/******************************************************/
#define INVALID_NUM_SNAKE  			-1
#define QUIT 										1
#define LOST 										2
/******************************************************/
typedef unsigned UINT;

typedef struct TagCOOR
	{
	UINT x;
	UINT y;
	}COOR,*P_COOR;

typedef struct TagSNAKE
	{
	P_COOR 	snake;
	P_COOR 	pHead,pTail;
	P_COOR 	adresseEndSnake;
	COOR    dir;
	int    	sizeSnake;
	int     (*AdvanceSnake)(int [][SIZE_GROUND_Y],struct TagSNAKE*,struct TagSNAKE*);

	int    	colorSnake;
	int     numSnake;
	int     boolQuitIfLost;
	int     expandSnake;

	}SNAKE,*P_SNAKE;

/******************************************************/
#define Malloc(type,nb) (type*) _Malloc(sizeof(type)*(nb))
void *_Malloc(size_t size)
{
void *p;
if((p = malloc(size)) == NULL)
	{
	printf("Erreur !\nImpossible d'allouer %d octets de memoires\n",size);
	exit(1);
	}
return p;
}

/******************************************************/
/*

  • Une case represente 2 caracteres => cela forme un "carre"
  • Il y a une cadre, d'ou les '1+...'
  • /
void Gotoxy(COOR *pCoor) { gotoxy(3+(pCoor->x << 1),2+pCoor->y); } /******************************************************/ void DrawCadre(int color) { int i; textcolor(color); /* ligne du haut */ gotoxy(1,1); i = 5+2*SIZE_GROUND_X; while(--i) cprintf("Û"); /* ligne du bas */ gotoxy(1,2+SIZE_GROUND_Y); i = 5+2*SIZE_GROUND_X; while(--i) cprintf("Û"); /* ligne a gauche et a droite */ for(i=2;i<=1+SIZE_GROUND_Y;i++) { gotoxy(1,i); cprintf("ÛÛ"); gotoxy(3+2*SIZE_GROUND_X,i); cprintf("ÛÛ"); } } /******************************************************/ int GetValueGround(int ppGround[][SIZE_GROUND_Y],COOR *pCoor) { return ppGround[pCoor->x][pCoor->y]; } /******************************************************/ void SetValueGround(int ppGround[][SIZE_GROUND_Y],COOR *pCoor,int value) { ppGround[pCoor->x][pCoor->y] = value; } /******************************************************/ void NewSnake( int ppGround[][SIZE_GROUND_Y], P_SNAKE pSnake, int colorSnake, int numSnake, int boolQuitIfLost, int (*func)(int [][SIZE_GROUND_Y],P_SNAKE,P_SNAKE) ) { P_COOR snake; pSnake->snake = snake = Malloc(COOR,SIZE_MAX_SNAKE); pSnake->pHead = snake; pSnake->pTail = snake; pSnake->sizeSnake = SIZE_SNAKE_BEGIN - 1; pSnake->dir.x = 1; pSnake->dir.y = 0; pSnake->adresseEndSnake = snake + SIZE_MAX_SNAKE - 1; pSnake->numSnake = numSnake; pSnake->AdvanceSnake = func; pSnake->colorSnake = colorSnake; pSnake->boolQuitIfLost = boolQuitIfLost; pSnake->expandSnake = NB_ITERATION_FOR_EXPAND_SNAKE; snake->x = 1; snake->y = numSnake; ppGround[1][1] = numSnake; } /******************************************************/ void PrintTailSnake(int ground[][SIZE_GROUND_Y],P_SNAKE pSnake) { Gotoxy(pSnake->pTail); cprintf(" "); SetValueGround(ground,pSnake->pTail,0); pSnake->pTail = (pSnake->pTail >= pSnake->adresseEndSnake ? pSnake->snake : pSnake->pTail + 1); } /******************************************************/ int PrintHeadSnake(int ground[][SIZE_GROUND_Y],P_SNAKE pSnake) { P_COOR pOldHead; pOldHead = pSnake->pHead; pSnake->pHead = (pSnake->pHead >= pSnake->adresseEndSnake ? pSnake->snake : pSnake->pHead + 1); pSnake->pHead->x = (pOldHead->x + pSnake->dir.x + SIZE_GROUND_X) % SIZE_GROUND_X; pSnake->pHead->y = (pOldHead->y + pSnake->dir.y + SIZE_GROUND_Y) % SIZE_GROUND_Y; if(GetValueGround(ground,pSnake->pHead) != 0) { return 0; } Gotoxy(pSnake->pHead); cprintf("ÛÛ"); SetValueGround(ground,pSnake->pHead,pSnake->numSnake); return 1; } /******************************************************/ void DeleteSnake(int ground[][SIZE_GROUND_Y],P_SNAKE pSnake) { while((--(pSnake->sizeSnake)) >= 0) { PrintTailSnake(ground,pSnake); } free(pSnake->snake); } /******************************************************/ void PrintSnake(int ground[][SIZE_GROUND_Y],P_SNAKE pSnake) { int i; i = pSnake->sizeSnake; textcolor(pSnake->colorSnake); while((--i) >= 0) { PrintHeadSnake(ground,pSnake); } } /******************************************************/ void NewGround(int ground[][SIZE_GROUND_Y]) { int i,j; for(i=0;i<SIZE_GROUND_X;i++) { for(j=0;j<SIZE_GROUND_X;j++) { ground[i][j] = 0; } } } /******************************************************/ int serpent( int ground[][SIZE_GROUND_Y], unsigned temp, int colorCadre, int bkcolor, int nbSnake, P_SNAKE tabSnake, P_SNAKE pSnakeGood ) { int i; /* initialisations */ textbackground(bkcolor); clrscr(); DrawCadre(colorCadre); for(i=0;i<nbSnake;i++) { PrintSnake(ground,tabSnake + i); } do { for(i=0;i<nbSnake;i++) { P_SNAKE pSnake; pSnake = tabSnake + i; /* si le serpent est 'invalide' */ if(pSnake->numSnake == INVALID_NUM_SNAKE) { continue; } textcolor(pSnake->colorSnake); if(!(-- pSnake->expandSnake)) { pSnake->expandSnake = NB_ITERATION_FOR_EXPAND_SNAKE; if((++ pSnake->sizeSnake) >= SIZE_MAX_SNAKE) { int boolQuit; /* si le serpent est trop long */ boolQuit = pSnake->boolQuitIfLost; DeleteSnake(ground,pSnake); if(boolQuit) { return ; } } PrintHeadSnake(ground,pSnake); } if(pSnake->AdvanceSnake(ground,pSnake,pSnakeGood)) { return; } /* on efface la queue */ PrintTailSnake(ground,pSnake); /* on affiche la nouvelle tete */ if(!PrintHeadSnake(ground,pSnake)) { int boolQuit; /* on perd */ boolQuit = pSnake->boolQuitIfLost; DeleteSnake(ground,pSnake); pSnake->numSnake = INVALID_NUM_SNAKE; if(boolQuit) { /* si on veut quitter lorque ce serpent est mort */ return ; } } } /* on deplace le curseur pendant l'attente */ gotoxy(1,1); delay(temp); }while(1 == 1); } /******************************************************/ /******************************************************/ /******************************************************/ int AdvanceSnakePlayer(int ground[][SIZE_GROUND_Y],P_SNAKE pSnake,P_SNAKE pSnakeGood) { P_COOR pDir; (void) ground; (void) pSnakeGood; pDir = &(pSnake->dir); if(kbhit()) { switch(getch()) { case '5': /* ATTENT */ getch(); break; case '4': /* GAUCHE */ pDir->x = -1; pDir->y = 0; break; case '6': /* DROITE */ pDir->x = +1; pDir->y = 0; break; case '8': /* HAUT */ pDir->x = 0; pDir->y = -1; break; case '2': /* BAS */ pDir->x = 0; pDir->y = +1; break; case 'q': /* on veut quitter a tout prix */ return QUIT; } } return 0; } /******************************************************/ int AdvanceSnakeAlgo1(int ground[][SIZE_GROUND_Y],P_SNAKE pSnake,P_SNAKE pSnakeGood) { (void) ground; (void) pSnakeGood; /*
  • on change la direction (X -> Y ou Y -> X)
  • selon la valeur d'un 'rand'
  • Ici il y a 1 chance sur 16 :
  • on fait le modulo 16 ( & 15 pour etre plus rapide !)
  • /
if(!(rand() & 15)) { P_COOR pDir; /* 'val' vaut soit +1 soit -1 */ int val; val = (rand() & 1) ? +1 : -1; pDir = &(pSnake->dir); /* si le serpent se deplace suivant l'axe verticale */ if(pDir->x) { pDir->x = 0; pDir->y = val; } /* si le serpent se deplace suivant l'axe horizontale */ else { pDir->x = val; pDir->y = 0; } } return 0; } /******************************************************/ int AdvanceSnakeAlgo2(int ground[][SIZE_GROUND_Y],P_SNAKE pSnake,P_SNAKE pSnakeGood) { (void) ground; /*
  • le serpent suit le joueur
  • /
pSnake->dir.x = pSnakeGood->dir.x; pSnake->dir.y = pSnakeGood->dir.y; return 0; } /******************************************************/ /******************************************************/ /******************************************************/ int main(void) { /* la plateau de jeu */ int ground[SIZE_GROUND_X][SIZE_GROUND_Y]; SNAKE tabSnake[4]; /* initialisation du random pour les algorithmes */ randomize(); NewGround(ground); /* * * * * * * * * * * * * * * * */ /* UN */ NewSnake( ground, tabSnake + 0, YELLOW, 2, TRUE, AdvanceSnakePlayer ); /* * * * * * * * * * * * * * * * */ /* DEUX */ NewSnake( ground, tabSnake + 1, LIGHTGREEN, 6, FALSE, AdvanceSnakeAlgo1 ); /* * * * * * * * * * * * * * * * */ /* TROIS */ NewSnake( ground, tabSnake + 2, RED, 12, FALSE, AdvanceSnakeAlgo2 ); /* * * * * * * * * * * * * * * * */ /* QUATRE */ NewSnake( ground, tabSnake + 3, LIGHTGREEN, 16, FALSE, AdvanceSnakeAlgo1 ); serpent( ground, /* le plateau de jeu */ 5000, /* delai */ LIGHTBLUE, /* couleur du cadre */ BLACK, /* couleur du fond */ 4, /* nombre de serpents mechants */ tabSnake, /* tous les serpents */ tabSnake+0 /* le serpent 'gentil' */ ); return 0; }

Codes Sources

A voir également

Ajouter un commentaire

Commentaires

Messages postés
1138
Date d'inscription
mardi 10 juin 2003
Statut
Membre
Dernière intervention
25 janvier 2009
3
Heu oui mais le seul probleme c'est que j'ai programmer ce jeu sur un PC de 20 MHz, qui n'a pas Window, c'est juste en mode console, il date de 1986 ...
DONC GetTickCount n'existe pas !
Messages postés
3006
Date d'inscription
dimanche 14 avril 2002
Statut
Membre
Dernière intervention
31 décembre 2008

ds la lignée des non portables, utiliser GetTickCount() est pratique.
Messages postés
1267
Date d'inscription
mercredi 1 janvier 2003
Statut
Membre
Dernière intervention
28 février 2007
3
L'idée est bonne mais ça rend pas très bien chez moi : je sais même pas quel serpent je contrôle !!
Sinon, pour Wett, je viens de chercher : timeGetTime() n'est pas ANSI : c'est uniquement dans windows.h et donc non portable :(
Messages postés
104
Date d'inscription
dimanche 2 mars 2003
Statut
Membre
Dernière intervention
12 juin 2005

Dans ces cas là utilise plutot un timeGetTime() (definit dans time.h je crois) pour calculer le temps espacé entre 2 frames du jeu : une variable contient le temps de la frame precedente et du calcule l'intervalle. Comme ca tu peux par exemple multiplier tes deplacement par le temps ecoulé : plus l'ordi est rapide plus le tps d'expacement est petit, et donc plus les mouvements sont fluides... Enfin ca ca marche super avec des flotants, apres il faut faire attention si tu travaille avec des entiers, si l'ordi est trop rapide le temps ecoulé est trop faible et tu obtient un deplacement < 1, qui arrondi en entier donne 0. Bon voila en esperant que ca peut t'adier ;)
Messages postés
1905
Date d'inscription
mercredi 22 janvier 2003
Statut
Membre
Dernière intervention
17 septembre 2012
2
ah ok.
Afficher les 8 commentaires

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.