jeu fini

#include "projet_simulation_partie2.h"
#include <stdlib.h>
#include <time.h>
#include <stdio.h>
#define NBPERS 2

// FONCTION GENERATION ALEATOIRE

int aleatoire(int limite){       //fonction qu'on utilise dans init_personnage pour générer des valeurs aléatoirement dans un                            intervalle défini
    return rand()   % limite;
}

// FONCTION INITIALISATION PERSONNAGE

struct personnage init_personnage (char clan) {


    struct personnage p;
    p.Point_De_Vie=aleatoire(101); //génération aléatoire des points de vie, pos, fdf, ... via la fonction aléatoire ci-dessus
    p.Position_X=aleatoire(50);
    p.Position_Y=aleatoire(50);
    p.Portee=aleatoire(16);
    p.Puissance_de_Frappe=aleatoire(50);
    p.Clan=clan;

    return p;
}


// FONCTION DECLARATION PERSONNAGES DANS CHAQUE CLAN

struct simulation init_simulation() {

    int NbPersonnageRouge=0;
    int NbPersonnageNoir=0;
    int x=0;
    struct simulation simu;
    while(x<NBPERS){
    simu.Rouge[NbPersonnageRouge]=init_personnage('R');
    simu.Noir[NbPersonnageNoir]=init_personnage('N');
    NbPersonnageRouge=NbPersonnageRouge+1;
    NbPersonnageNoir=NbPersonnageNoir+1;
    x=x+1;
    }

    return simu;
}
// FONCTION AFFICHER TABLEAU PERSONNAGE

void afficher_tableau_personnage(struct simulation simu) {

    int x=0;
    while (x<NBPERS) {
    printf("\nPersonnage %i du clan Rouge : " ,x);
    afficher_personnage(simu.Rouge[x]);
    printf("\nPersonnage %i du clan Noir : " ,x);
    afficher_personnage(simu.Noir[x]);
    x=x+1;
    }
}
// FONCTION AFFICHER PERSONNAGE

void afficher_personnage (struct personnage p) {
    if (p.Point_De_Vie!=0) {
    printf("\nPoints de vie : %d", p.Point_De_Vie); //affichage en décimal (%d) des variables via printf
    printf("\nPosition X: %d" , p.Position_X);
    printf("\nPosition Y: %d" , p.Position_Y);
    printf("\nPortee : %d", p.Portee);
    printf("\nPuissance de frappe : %d", p.Puissance_de_Frappe);
    printf("\nClan : %c", p.Clan);
    printf("\n");
    }
    else if (p.Point_De_Vie==0) {
	printf(" R.I.P");
	printf("\nLocalisation Cadavre :");
	printf("\nPosition X: %d" , p.Position_X);
        printf("\nPosition Y: %d" , p.Position_Y);
    }
}

// FONCTION DEPLACEMENT

struct personnage Deplacement (struct personnage p) {

    int deplacement;
    deplacement=aleatoire(4);

    if ((deplacement==0)&&(p.Position_Y!=0)&&(p.Point_De_Vie!=0)) {
        p.Position_Y=p.Position_Y-1;}
    else if ((deplacement==1)&&(p.Position_Y!=49)&&(p.Point_De_Vie!=0)) {
        p.Position_Y=p.Position_Y+1;}
    else if ((deplacement==2)&&(p.Position_X!=0)&&(p.Point_De_Vie!=0)) {
        p.Position_X=p.Position_X-1;}
    else if ((deplacement==3)&&(p.Position_X!=49)&&(p.Point_De_Vie!=0)) {
        p.Position_X=p.Position_X+1;}

    return p;
}

// FONCTION MODIFIANT LA STRUCTURE DE SIMULATION (Déplacement)

struct simulation ModificationPosition (struct simulation simu) {


    int x=0;
    int NbPersonnageRouge=0;
    int NbPersonnageNoir=0;
    while(x<NBPERS){
    simu.Rouge[NbPersonnageRouge]=Deplacement(simu.Rouge[NbPersonnageRouge]);
    simu.Noir[NbPersonnageNoir]=Deplacement(simu.Noir[NbPersonnageNoir]);
    NbPersonnageRouge=NbPersonnageRouge+1;
    NbPersonnageNoir=NbPersonnageNoir+1;
    x=x+1;
    }
    return simu;
}



// FONCTION POUR DETERMINER SI UN PERSONNAGE 1 PEUT ATTAQUER UN PERSONNAGE 2 (QUESTION 7)

int A_Portee_De_Tir(struct personnage a, struct personnage b) {

    int PossibiliteDattaque;
    if ((abs(a.Position_X-b.Position_X)<=a.Portee)&&(abs(a.Position_Y-b.Position_Y)<=a.Portee)) {
        PossibiliteDattaque=1;
    }
    else {
        PossibiliteDattaque=0;
    }
    return PossibiliteDattaque;
}





// FONCTION POUR DECREMENTER LES POINTS DE VIE

struct personnage Blessure(struct personnage a, struct personnage b) {


    if ((A_Portee_De_Tir(a,b)==1)&&(a.Point_De_Vie!=0)) {
        b.Point_De_Vie=b.Point_De_Vie-a.Puissance_de_Frappe;
	}
    if (b.Point_De_Vie<0) {
        b.Point_De_Vie=0;
        }

    return b;

}

// FONCTION MODIFIANT LA STRUCTURE DE SIMULATION (Attaque)

struct simulation Tir(struct simulation simu) {


    int y=0;
    while (y<NBPERS) {
     int x=0;
     while (x<NBPERS){
      simu.Noir[y]=Blessure(simu.Rouge[x] , simu.Noir[y]);
      simu.Rouge[y]=Blessure(simu.Noir[x] , simu.Rouge[y]);
      x=x+1;
     }
     y=y+1;
    }

    return simu;

}

/////////////////////////////////////// QUESTION 8 //////////////////////////////////

int TestFin(struct personnage p) {  // on teste si les points de vie du personnage sont à zéro

    int mort=0;
    if (p.Point_De_Vie==0) {
        mort=1;
    }
    return mort;
}


int mort (struct simulation simu) {

    int Fin=0;
    int CompteurMortRouge=0;
    int CompteurMortNoir=0;
    int x=0;

    while (x<NBPERS) {
        if (TestFin(simu.Rouge[x])==1) {
        CompteurMortRouge=CompteurMortRouge+1;
        }
    x=x+1;
    }
    x=0;

    while (x<NBPERS) {
        if (TestFin(simu.Noir[x])==1) {
        CompteurMortNoir=CompteurMortNoir+1;
        }
    x=x+1;
    }

    if ((CompteurMortRouge==NBPERS)||(CompteurMortNoir==NBPERS)) {
        printf ("\nsimulation finie\n");
        Fin=1;
    }
        else {
        printf("\nle combat continue\n");

    }
    return Fin;
}
===============================================================================
//déclaration des fonctions
#define NBPERS 2

int aleatoire(int limite); // Fonction génération aléatoire (Partie 1)

typedef struct personnage personnage; //definition du type struct personnage

    struct personnage {

     int Point_De_Vie;            // déclaration de la structure et ses variables
     int Position_X;
     int Position_Y;
     int Portee;
     int Puissance_de_Frappe;
     char Clan;
     };

typedef personnage clan[NBPERS];


    struct simulation {
        clan Rouge;
        clan Noir;
    int NbTourSimulation;
    };

// fonction initialisation personnage (Partie 1)

struct personnage init_personnage (char clan);

// fonction affichage personnage (partie 1)

void afficher_personnage (struct personnage p);

// fonction pour afficher un tableau de personnage

void afficher_tableau_personnage (struct simulation simu);

//initialisation simulation

struct simulation init_simulation();

// fonction déplacement

struct personnage Deplacement(struct personnage p);

//modification deplacement

struct simulation ModificationPosition(struct simulation simu);


// FONCTION POUR DETERMINER SI UN PERSONNAGE A PEUT ATTAQUER UN PERSONNAGE B (QUESTION 7)

int A_Portee_De_Tir(struct personnage a, struct personnage b);

struct personnage Blessure(struct personnage a, struct personnage b);

struct simulation Tir(struct simulation simu);

// TEST SI UN CLAN EST MORT (QUESTION 8)

int TestFin(struct personnage p);

int mort (struct simulation simu);
==============================================================
#include "projet_simulation_partie2.h"
#include <stdlib.h>
#include <time.h>
#include <stdio.h>

int main() {

     srand(time(NULL));
     typedef struct simulation simulation;
     struct simulation simu;

     printf("\nInitialisation de la simulation\n");

     simu = init_simulation();
     afficher_tableau_personnage(simu);
     int Fin=0;
     int NbTour=0;
     while (Fin!=1) {

     printf("\nTour %d \n", NbTour);
     NbTour = NbTour+1;
     simu = ModificationPosition(simu);
     simu = Tir(simu);
     afficher_tableau_personnage(simu);
     Fin = mort(simu);

     }


}