fonctions de base associées aux cases, à la carte et aux personnages +...

fonctions de base associées aux cases, à la carte et aux personnages + fonction déplacement sur cases hexagonales

src/case.c

+#include <stdio.h>
+#include <stdlib.h>
+#include "structures.h"
+#include "case.h"
+#include "personnage.h"
+#include "deplacements.h"
+
+Case* init_case(Case *c,int x, int y, type_terrain *t){
+    c->coord_x=x;
+    c->coord_y=y;
+    c->terrain=t;
+    c->occupee=0;
+    return c;
+}
+
+int get_x(Case *c){
+    return c->coord_x;
+}
+
+int get_y(Case *c){
+    return c->coord_y;
+}
+
+boolean est_occupee(Case *c){
+    return c->occupee;
+}
+
+boolean terrain_franchissable(type_terrain *t){
+    return t->franchissable;
+}
+
+boolean case_franchissable(Case *c){
+    return terrain_franchissable(c->terrain);
+}
+
+void marquer_occupee(Case *c){
+    if (c->occupee==vrai) printf("case dj occupe");
+    c->occupee=vrai;
+}
+
+void marquer_libre(Case *c){
+    if (c->occupee==faux) printf("case dj libre");
+    c->occupee=faux;
+}
+
+type_terrain* get_terrain(Case *c){
+    if (c->terrain==NULL){
+        fprintf(stderr,"pas de terrain");
+    }
+    return c->terrain;
+}
+
+int init_carte(carte* c,unsigned short int largeur, unsigned short int hauteur){
+    int i,j,n;
+    if (largeur*hauteur>TAILLE_MAX_CARTE){
+        printf("erreur : taille maximum de la carte dpasse");
+        return 1;
+    }
+    for (i=0;i<largeur;i++){
+        for (j=0;j<hauteur;j++){
+            init_case(c[n],i,j,NULL);
+            n++;
+        }
+    }
+    return 0;
+}

src/case.h

+#ifndef CASE_H_INCLUDED
+#define CASE_H_INCLUDED
+
+Case* init_case(Case *c,int x, int y, type_terrain *t);
+
+int get_x(Case *c);
+
+int get_y(Case *c);
+
+boolean est_occupee(Case *c);
+
+boolean terrain_franchissable(type_terrain *t);
+
+boolean case_franchissable(Case *c);
+
+void marquer_occupee(Case *c);
+
+void marquer_libre(Case *c);
+
+type_terrain* get_terrain(Case *c);
+
+int init_carte(carte* c,unsigned short int largeur, unsigned short int hauteur);
+
+
+#endif
+

src/deplacements.c

+#include <stdio.h>
+#include <stdlib.h>
+#include "structures.h"
+#include "case.h"
+#include "personnage.h"
+#include "deplacements.h"
+
+boolean case_a_cote(personnage *perso,Case *destination){ /* vérifie que la case hexagonale "destination" est contigue à la case du personnage */
+    Case *depart = getPosition(perso);
+    if (get_x(depart)>get_x(destination)+1||get_x(depart)<get_x(destination)-1||get_y(depart)>get_y(destination)+1||get_y(depart)>get_y(destination)-1){
+        return faux;
+    }
+    if (get_y(depart)==get_y(destination)+1&&get_x(depart)!=get_x(destination)){
+        return faux;
+    }
+    return vrai;
+}
+
+int deplacement_unitaire(personnage *perso,Case *destination){ /*déplace un personnage sur une case située à côté de la sienne, si cela est possible */
+    if (est_occupee(destination)){
+        printf("déplacement impossible : case déjà occupée par un personnage");
+        return 1;
+    }
+    if (case_franchissable(destination)==faux){
+        printf("déplacement impossible : case infranchissable");
+        return 1;
+    }
+    if (case_a_cote(perso,destination)==vrai){
+       return deplacer_personnage(perso, destination);
+    }
+    printf("déplacement impossible : case non contigue");
+    return 1;
+}

src/deplacements.h

+#ifndef DEPLACEMENTS_H_INCLUDED
+#define DEPLACEMENTS_H_INCLUDED
+
+boolean case_a_cote(personnage *perso,Case *destination);
+
+int deplacement_unitaire(personnage *perso,Case *destination);
+
+
+#endif

src/main.c

@@ -2,27 +2,6 @@
 #include <stdlib.h>
 #include "structures.h"
 
-Case* init_case(int x, int y, type_terrain t){
-    Case *c;
-    c->coord_x=x;
-    c->coord_y=y;
-    c->terrain=t;
-    c->occupee=0;
-    return c;
-}
-
-int init_carte(carte* c,unsigned short int largeur, unsigned short int hauteur){
-    int i,j,n;
-    for (i=0;i<largeur;i++){
-        for (j=0;j<hauteur;j++){
-            c[n]=init_case(i,j,0);
-            n++;
-        }
-    }
-    return 0;
-}
-
-
 
 int main()
 {

src/personnage.c

+#include <stdio.h>
+#include <stdlib.h>
+#include "structures.h"
+#include "case.h"
+#include "personnage.h"
+#include "deplacements.h"
+
+personnage* init_personnage(personnage *perso, classe *c, Case *casedepart){
+    perso->classe=*c;
+    perso->points_deplacement=c->points_deplacement_max;
+    perso->PV=c->PV_max;
+    perso->position=casedepart;
+    marquer_occupee(casedepart);
+    return perso;
+}
+
+Case* getPosition(personnage *p){
+    return p->position;
+}
+
+int get_PV(personnage *p){
+    return p->PV;
+}
+
+int get_PD(personnage *p){
+    return p->points_deplacement;
+}
+
+boolean est_paralyse(personnage *p){
+    return p->paralyse;
+}
+
+int deplacer_personnage (personnage *perso, Case *destination){ /*déplace un personnage d'une case à une autre. Ne vérifie pas si le déplacement est autorisé, cela doit être fait par la fonction qui l'appelle*/
+    marquer_libre(getPosition(perso));
+    perso->position=destination;
+    marquer_occupee(getPosition(perso));
+}
+
+

src/personnage.h

+#ifndef PERSONNAGE_H_INCLUDED
+#define PERSONNAGE_H_INCLUDED
+
+personnage* init_personnage(personnage *perso, classe *c, Case *casedepart);
+
+Case* getPosition(personnage *p);
+
+int get_PV(personnage *p);
+
+int get_PD(personnage *p);
+
+boolean est_paralyse(personnage *p);
+
+int deplacer_personnage (personnage *perso, Case *destination);
+
+#endif

src/structures.h

 #ifndef STRUCTURES_H_INCLUDED
 #define STRUCTURES_H_INCLUDED
 
+#define TAILLE_MAX_CARTE 256
+#define TAILLE_NOMS 16
 /* definition des structures ncessaires : case, classe, etc */
 
-typedef enum {plaine,eau,montagne,foret} type_terrain;
+typedef char type_nom[TAILLE_NOMS];
 
 typedef enum {faux, vrai} boolean;
 
+typedef struct {
+    type_nom nom;
+    boolean franchissable;
+    unsigned short int PD_requis;
+} type_terrain;
+
+
 typedef struct {
     unsigned short int coord_x;
     unsigned short int coord_y;
-    type_terrain terrain;
+    type_terrain *terrain;
     boolean occupee;
 } Case;
 
-typedef Case* carte;
-
+typedef Case carte[TAILLE_MAX_CARTE];
 
 typedef struct {
-    char nom[16];
+    type_nom nom;
     unsigned short int degats_directs;
     unsigned short int degats_permanents;
     boolean paralysie;
 } attaque;
 
 typedef struct {
-    char nom[16];
+    type_nom nom;
     attaque attaque;
     unsigned short int points_deplacement_max;
     unsigned short int PV_max;
 } classe;
 
 typedef struct {
-    char nom[16];
+    type_nom nom;
     classe classe;
     unsigned short int points_deplacement;
     unsigned short int PV;
     boolean paralyse;
-    Case position;
+    Case *position;
 } personnage;
 
 #endif