Page principale | Liste des fichiers | Portée globale

jeu.c

Aller à la documentation de ce fichier.
00001 /*******************************************************************************\
00002  *                      SeaBattle - D.Bernaudeau, J. Vehent - 2006             *
00003  *                                                                             *
00004  *      fonctions jeu: implémentation de l'interface, des tours de jeu, des    *
00005  *              tirs et réponses, manipulation des matrices de jeu             *
00006  *                                                                             *
00007 \*******************************************************************************/ 
00008 
00018 #include <stdio.h>
00019 #include <stdlib.h>
00020 #include <string.h>
00021 #include <ncurses.h>
00022 
00023 #include "affichage.h"
00024 #include "test.h"
00025 #include "reseau.h"
00026 
00027 /*VARIABLES GLOBALES 
00028 */
00029 
00034 int goflag=0;
00035 
00040 int advgoflag=0;
00041 
00046 int flagjeu=0;
00047 
00052 int shoot_ligne=0;
00053 
00058 int shoot_colonne=0;
00059 
00060 
00061 
00082 int matrice_locale[10][10];
00083 
00088 int matrice_adverse[10][10];
00089 
00090 
00098 int bateaux_dispo[6]={1,1,1,1,1,1};
00099 
00100 /* FIN VARIABLES GLOBALES
00101 */
00102 
00103 
00104 /***************************************************************************************************************/
00105 
00107 
00110 int init_matrices(){
00111         int i,j;
00112         for(i=0;i<10;i++){
00113                 for(j=0;j<10;j++){
00114                         matrice_locale[i][j]=0;
00115                         matrice_adverse[i][j]=0;
00116                 }
00117         }
00118         return 0;
00119 }
00120 
00121 
00122 /***************************************************************************************************************/
00123 
00125 
00129 int interdit(int flag){
00130         switch(flag){
00131                 case 1: afficher_erreur("Début du jeu activé, les actions set et unset sont interdites");break;
00132                 case 2: afficher_erreur("Vous etes encore en préparation du jeu, shoot interdit");break;
00133                 case 3: afficher_erreur("Vous avez déjà débuté le jeu, action go interdite");break;
00134                 case 4: afficher_erreur("Vous n'avez pas placé tout vos bateaux, action go interdite");break;
00135                 case 5: afficher_erreur("Commande inconnue ou mal formulée");break;
00136                 case 6: afficher_erreur("Vous avez déjà joué ce coup ! Jouez un autre coup.");break;
00137                 case 7: afficher_erreur("Ce n'est pas à vous de jouer...");break;
00138 
00139                 default: return -1;
00140         }
00141         return 0;
00142 }
00143 
00144 
00145 /***************************************************************************************************************/
00146 
00148 
00152 int set(char *msg){
00153 
00154         // On stocke les informations de positions dans les variables ci-dessous
00155         char colonnec=msg[7]; int colonne;
00156         char typec=msg[5];int type, longueur;
00157         char lignec=msg[9];int ligne;
00158         int orientationc = msg[11];int orientation;
00159 
00160         //iterateur
00161         int i;
00162         
00163         //les conversions
00164         switch(colonnec){
00165                 case 'A': colonne = 0;break;
00166                 case 'B': colonne = 1;break;
00167                 case 'C': colonne = 2;break;
00168                 case 'D': colonne = 3;break;
00169                 case 'E': colonne = 4;break;
00170                 case 'F': colonne = 5;break;
00171                 case 'G': colonne = 6;break;
00172                 case 'H': colonne = 7;break;
00173                 case 'I': colonne = 8;break;
00174                 case 'J': colonne = 9;break;
00175                 default: interdit(5);return -1;
00176         }
00177 
00178         switch(typec){
00179                 case '1': type=1;break;
00180                 case '2': type=2;break;
00181                 case '3': type=3;break;
00182                 case '4': type=4;break;
00183                 case '5': type=5;break;
00184                 case '6': type=6;break;
00185                 default: interdit(5);return -1;
00186         }
00187         if (type==1)longueur=5;
00188         else{ if (type>4)longueur=2;else longueur=3;}
00189         
00190         switch(lignec){
00191                 case '0': ligne = 0;break;
00192                 case '1': ligne = 1;break;
00193                 case '2': ligne = 2;break;
00194                 case '3': ligne = 3;break;
00195                 case '4': ligne = 4;break;
00196                 case '5': ligne = 5;break;
00197                 case '6': ligne = 6;break;
00198                 case '7': ligne = 7;break;
00199                 case '8': ligne = 8;break;
00200                 case '9': ligne = 9;break;
00201                 default: interdit(5);return -1;
00202         }       
00203 
00204         switch(orientationc){
00205                 case 'H': orientation=0;break;
00206                 case 'V': orientation=1;break;
00207                 default: interdit(5);return -1;
00208         }
00209 
00210         /* CONTROLES D'INTEGRITE:
00211          * 1. vérification que le bateau tiens entierement dans la grille
00212          * 2. vérification que le bateau ne chevauche pas un autre bateau déjà en place
00213          */
00214         if(sortie_matrice(longueur,colonne,ligne,orientation)!=0){
00215 
00216                 afficher_erreur("Impossible de placer le bateau à l'emplacement demandé pour cause de sortie de territoire");
00217                 return -2;
00218         }else if(set_collision(matrice_locale,longueur,colonne,ligne,orientation)<0){
00219  
00220                 afficher_erreur("Impossible de placer le bateau à l'emplacement demandé pour cause de collision");
00221                 return -2;
00222         }
00223 
00224                 
00225         //on test la disponibilité du bateau, si il est dispo on le place dans la matrice
00226         //on numérote a partir de 0 donc il faut soustraire 1 à la valeur de type
00227         if (0 > (bateaux_dispo[type-1]-1)) {
00228                 afficher_erreur("Erreur ! bateau non disponible...");
00229         } else {
00230                 //On stocke ces informations dans la matrice, 2 est le numéro des bateaux intacts
00231                 matrice_locale[ligne][colonne]=type+3;
00232                 
00233                 //on décrémente la disponibilité
00234                 //on numérote a partir de 0 donc il faut soustraire 1 à la valeur de type
00235                 --bateaux_dispo[type-1];
00236                 
00237                 //et on place le bateau dans la matrice selon son orientation
00238                 //dans la matrice on numérote les type a partir de 4 donc il faut ajouter 3 a la valeur de type
00239                 if(orientation==0){
00240                         for(i=1;(colonne+i)<(colonne+longueur); i++) matrice_locale[ligne][colonne+i]=type+3;
00241                 }else{
00242                         if (orientation==1){
00243                                 for(i=1;(ligne+i)<(ligne+longueur); i++) matrice_locale[ligne+i][colonne]=type+3;
00244                         }else return -1;
00245                 }
00246         }
00247 
00248         //rafraichissement de l'affichage
00249         effacer_bateau(type);
00250         afficher_matrice(1, matrice_locale);
00251         
00252         return 0;
00253 }
00254 
00255 
00256 /***************************************************************************************************************/
00257 
00259 
00263 int unset(char *msg){
00264         afficher_erreur("cette fonctionnalité n'est pas encore disponible");
00265         return 0;
00266 }
00267 
00268 
00269 /***************************************************************************************************************/
00270 
00272 void demarre_jeu(){
00273         afficher_erreur("LES DEUX CAMPS SONT PRET.... DEMARRAGE DU JEU");
00274         afficher_etat(flagjeu);
00275 }
00276 
00277 
00278 /***************************************************************************************************************/
00279 
00281 void adv_go(){
00282         advgoflag=1;
00283         if (goflag==1) demarre_jeu();
00284 
00285 }
00286 
00287 /***************************************************************************************************************/
00288 
00290 
00293 int help(){
00294         move(28,1);clrtoeol();
00295         mvprintw(28,(COLS-67)/2,"Commande SET '/set' = PLACEMENT DES BATEAUX SUR LA GRILLE DU JOUEUR");
00296         move(29,1);clrtoeol();
00297         mvprintw(29,(COLS-77)/2, "utilisation: /set [TYPE BATEAU] [LETTRE COLONNE] [NUMERO LIGNE] [ORIENTATION]");
00298         move(30,1);clrtoeol();
00299         mvprintw(30,(COLS-104)/2,"TYPE BATEAU: numéro de gauche dans la colonne centrale   |   ORIENTATION: H pour horizontal, V pour vertical");
00300         move(31,1);clrtoeol();
00301         mvprintw(32,(COLS-102)/2,"exemples: /set 1 B 3 H place le porte avion de B3 a F3  |   /set 3 E 4 V place le croiseur n°2 de E4 a E6");
00302         
00303         refresh();
00304         return 0;
00305 }
00306 
00307 
00308 /***************************************************************************************************************/
00309 
00311 
00315 /* on récupére la colonne et la ligne du tir et on effectue un controle sur
00316  * matrice_adverse pour voir si ca n'a pas déjà été joué
00317  * 
00318  * si le controle est négatif, on envoie le tir a l'adversaire par le réseau
00319 */
00320 int shoot(char *msg){
00321         char colonnec=msg[7];
00322         char lignec=msg[9];
00323 
00324         //les conversions
00325         //on utilise des variables globales car elles sont rappelés dans rep_shoot
00326         switch(colonnec){
00327                 case 'A': shoot_colonne = 0;break;
00328                 case 'B': shoot_colonne = 1;break;
00329                 case 'C': shoot_colonne = 2;break;
00330                 case 'D': shoot_colonne = 3;break;
00331                 case 'E': shoot_colonne = 4;break;
00332                 case 'F': shoot_colonne = 5;break;
00333                 case 'G': shoot_colonne = 6;break;
00334                 case 'H': shoot_colonne = 7;break;
00335                 case 'I': shoot_colonne = 8;break;
00336                 case 'J': shoot_colonne = 9;break;
00337                 default: interdit(5);return -1;
00338         }
00339         switch(lignec){
00340                 case '0': shoot_ligne = 0;break;
00341                 case '1': shoot_ligne = 1;break;
00342                 case '2': shoot_ligne = 2;break;
00343                 case '3': shoot_ligne = 3;break;
00344                 case '4': shoot_ligne = 4;break;
00345                 case '5': shoot_ligne = 5;break;
00346                 case '6': shoot_ligne = 6;break;
00347                 case '7': shoot_ligne = 7;break;
00348                 case '8': shoot_ligne = 8;break;
00349                 case '9': shoot_ligne = 9;break;
00350                 default: interdit(5);return -1;
00351         }
00352         
00353         //si la case n'a pas déjà été jouée, on envoie le coup a l'adversaire
00354         if(matrice_adverse[shoot_ligne][shoot_colonne] > -1 && matrice_adverse[shoot_ligne][shoot_colonne]!=1){
00355                 send_shoot(msg);
00356         //sinon on refuse le coup
00357         }else interdit(6);
00358         return 0;
00359 }
00360 
00361 
00362 /***************************************************************************************************************/
00363 
00365 
00368 /* on modifie l'état de la matrice au coordonnées saisie
00369  * et on appelle la fonction de mise à jour de l'affichage
00370 */
00371 void recv_shoot(char *msg){
00372         char colonnec=msg[7];
00373         char lignec=msg[9];
00374         
00375         int colonne,ligne, i;
00376 
00377         //les conversions
00378         switch(colonnec){
00379                 case 'A': colonne = 0;break;
00380                 case 'B': colonne = 1;break;
00381                 case 'C': colonne = 2;break;
00382                 case 'D': colonne = 3;break;
00383                 case 'E': colonne = 4;break;
00384                 case 'F': colonne = 5;break;
00385                 case 'G': colonne = 6;break;
00386                 case 'H': colonne = 7;break;
00387                 case 'I': colonne = 8;break;
00388                 case 'J': colonne = 9;break;
00389                 default: break;
00390         }
00391         switch(lignec){
00392                 case '0': ligne = 0;break;
00393                 case '1': ligne = 1;break;
00394                 case '2': ligne = 2;break;
00395                 case '3': ligne = 3;break;
00396                 case '4': ligne = 4;break;
00397                 case '5': ligne = 5;break;
00398                 case '6': ligne = 6;break;
00399                 case '7': ligne = 7;break;
00400                 case '8': ligne = 8;break;
00401                 case '9': ligne = 9;break;
00402                 default: break;
00403         }
00404 
00405         //on test les coups dans l'eau
00406         if (matrice_locale[ligne][colonne]==0) matrice_locale[ligne][colonne]=1;
00407 
00408         //on test les bateaux touchés, si un bateau est touché, son chiffre est opposé
00409         else {  if(matrice_locale[ligne][colonne]>3){
00410                         matrice_locale[ligne][colonne] = matrice_locale[ligne][colonne]*(-1);
00411                 
00412                         //on verifie s'il ne reste plus de cases intactes pour ce bateau 
00413                         if( 1 ==  couler(matrice_locale, ligne, colonne) )
00414                         {
00417 
00418                                 // Bateau horizontal
00419                                 for(i=0;i<10;i++){
00420                                         if(     (matrice_locale[ligne][i] == matrice_locale[ligne][colonne]) 
00421                                                 && 
00422                                                 (i != colonne) 
00423                                         )
00424                                                 matrice_locale[ligne][i] = (matrice_locale[ligne][i] - 10);
00425                                 }
00426                                 // Bateau vertical
00427                                 for(i=0;i<10;i++){
00428                                         if(     (matrice_locale[i][colonne]== matrice_locale[ligne][colonne])
00429                                                 && 
00430                                                 (i != ligne)
00431                                         )
00432                                                 matrice_locale[i][colonne] = (matrice_locale[i][colonne] - 10);
00433                                 }
00434                                 
00435                                 //on a coulé les autres cases, on coule enfin la case visée
00436                                 matrice_locale[ligne][colonne] = (matrice_locale[ligne][colonne] - 10);
00437         
00438                                 //si on a perdu, la partie est finie
00439                                 if( 1 == perdu(matrice_locale)){
00440                                         flagjeu=-10;
00441                                         afficher_erreur("DOMMAGE !!! VOUS AVEZ PERDU LA PARTIE !!!");
00442                                 }
00443                         }
00444                 }
00445         }
00446         //on envoie la réponse à l'adversaire par le réseau 
00447         send_rep_shoot(matrice_locale[ligne][colonne]);
00448 
00449         //et on raffraichit l'affichage
00450         afficher_matrice(1,matrice_locale);
00451 
00452         //enfin donne la main au joueur
00453         if (flagjeu != -10) flagjeu=1;
00454         afficher_etat(flagjeu);
00455 }
00456 
00457 
00458 /***************************************************************************************************************/
00459 
00461 
00464 void rep_shoot(char *msg){
00465         int reponse = atoi(msg), i;
00466 
00467         /* on test le code de retour et on édite la grille adverse en fonction
00468          */
00469         switch(reponse){
00470                 case 1: afficher_erreur("raté ! un coup dans l'eau");
00471                         matrice_adverse[shoot_ligne][shoot_colonne]=1;
00472                         break;
00473                 
00474                 case -4 : case -5 : case -6 : case -7 : case -8 : case -9 : 
00475                         afficher_erreur("vous avez touché un bateau adverse !"); 
00476                         matrice_adverse[shoot_ligne][shoot_colonne] = reponse;
00477                         break;
00478         
00480                 case -14 : case -15 : case -16 : case -17 : case -18 : case -19 : 
00481                         afficher_erreur("vous avez coulé un bateau adverse !"); 
00482                         matrice_adverse[shoot_ligne][shoot_colonne]=reponse;
00483                         
00486                         // Bateau horizontal
00487                         for(i=0;i<10;i++){
00488                                 if(     (matrice_adverse[shoot_ligne][i] == (reponse+10)) 
00489                                         && 
00490                                         (i != shoot_colonne) 
00491                                 )
00492                                         matrice_adverse[shoot_ligne][i] = reponse;
00493                         }
00494                         // Bateau vertical
00495                         for(i=0;i<10;i++){
00496                                 if(     (matrice_adverse[i][shoot_colonne]== (reponse+10))
00497                                         && 
00498                                         (i != shoot_ligne)
00499                                 )
00500                                         matrice_adverse[i][shoot_colonne] = reponse;
00501                         }
00502                         
00503                         if (1 == perdu(matrice_adverse)){
00504                                 afficher_erreur("BRAVO, VOUS AVEZ GAGNE LA PARTIE !!!!");
00505                                 flagjeu=10;
00506                         }
00507                         break;
00508                         
00509                 default : afficher_erreur("erreur lors de la lecture de la réponse");break;
00510         }       
00511 
00512         //on raffraichit l'affichage
00513         afficher_matrice(2, matrice_adverse);
00514         
00515         //on rend la main au joueur
00516         if( flagjeu != 10) flagjeu=0;
00517         afficher_etat(flagjeu);
00518 }
00519 
00521 
00525 int interpretation(char *msg){
00526 
00527 
00528         //definition des chaines d'actions
00529         char set_c[]="/set", unset_c[]="/unset", go_c[]="/go", help_c[]="/help", shoot_c[]="/shoot";
00530 
00531         //      TEST DE L'ACTION A EFFECTUER. on compare la chaine saisie avec les paterns précédent 
00532 
00533         //test de /set
00534         if (0 == strncmp(msg, set_c,4)){ 
00535                 if (goflag == 0){ if(-1 == set(msg)) return -1;} 
00536                 else interdit(1);}
00537 
00538         else{   //test de "unset"
00539                 if (0 == strncmp(msg, unset_c,6)){ 
00540                         if (goflag==0) unset(msg); 
00541                         else interdit(1);}
00542 
00543                 else{   //test de "go" et démarre le jeu si l'adversaire a déjà lancé /go
00544                         if (0 == strncmp(msg, go_c,3)){ 
00545                                 //on ne peut démarrer que si tous les bateaux sont placés
00546                                 if (bateaux_dispo[2]==0 && bateaux_dispo[3]==0 && bateaux_dispo[5]==0){
00547                                         //celui qui passe /go en premier commence a jouer
00548                                         if (goflag == 0){ 
00549                                                 goflag=1; 
00550                                                 if(advgoflag==0){ 
00551                                                         flagjeu=1;
00552                                                         afficher_erreur("Vous êtes pret a jouer, attente de l'adversaire");
00553                                                         return 0;
00554                                                 } else demarre_jeu(); 
00555                                         }else interdit(3);
00556                                 } else {interdit(4);return -2;}}
00557                         else{   //test de "help"
00558                                 if (0 == strncmp(msg, help_c,5)){ help();}
00559 
00560                                 else{   //test de "shoot"
00561                                         if (0 == strncmp(msg, shoot_c,6)){ 
00562                                                 //verification que c'est bien au joueur de jouer
00563                                                 if (flagjeu == 1){
00564                                                         //verification que l'on est en mode jeu
00565                                                         if (goflag!=0 && advgoflag!=0) shoot(msg); 
00566                                                         else interdit(2);
00567                                                 }else interdit(7);}
00568 
00569                                         else {  //si la chaine ne correspond a rien de connu, on affiche une erreur
00570                                                 interdit(5);}
00571                                 }
00572                         }
00573                 }
00574         }
00575         return 0;
00576 }
00577 

Généré le Sun Apr 30 17:46:01 2006 pour SeaBattle par  doxygen 1.4.4