Etudes/BTS/C/Premiere annee/sano/sao.c

/*********************************************************************
Nom du projet : sao
Nom du fichier : sao.c
Auteur : dbernard
Date de création : Friday 2015-12-04-13.57
------------------------------------------
Edition : therbron
Date d'edition : Thursday 2015-12-10-13.28
------------------------------------------
Copyright 2013 par depinfo.touchard
Description fonctionnelle de la bibliotheque :



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

#include "sao.h"
#include <stdlib.h>
#include <stdio.h>
#include <errno.h>
#include <string.h>
#include <sys/timeb.h>
#include <math.h>
#include <ctype.h>
#include <unistd.h>
#include <time.h>

// attendre un maxTime millisecondes
void msleep(unsigned int maxTime)
{
    /*
    struct timespec {
    time_t tv_sec;        // secondes
    long   tv_nsec;       // nanosecondes
    };
    */
    struct timespec req;
    struct timespec rem;
    time_t secondes=0;
    long nanoSecondes=0;
    if (maxTime>=1000)
    {
        do
        {
            secondes++;
            maxTime-=1000;
        }
        while(maxTime>=1000);
    }
    nanoSecondes=maxTime*1000000;
    req.tv_sec=secondes;
    req.tv_nsec=nanoSecondes;
    nanosleep(&req,&rem);

}

//retourne une valeur entiere E[0..maxAlea[
unsigned int aleatoire(unsigned int maxAlea )
{
    /* struct timeb {
        time_t         time;
        unsigned short millitm;
        short          timezone;
        short          dstflag;
    };*/

    struct timeb t;
    float a, b ;
    unsigned int nbmilli;
    ftime( &t );
    nbmilli = t.time * 1000 + t.millitm;
    srand( nbmilli );
    a = rand();
    b = ( maxAlea * a ) / RAND_MAX;
    msleep(50);
    return( ( unsigned int )b );


}


void afficherMenu(typePersonnage *joueur1, typePersonnage *joueur2)
{
    if(joueur1 == NULL)
    {
        printf("1 - Creer personnage joueur 1\n");
        printf("2 - Charger joueur 1\n");
    }

    if(joueur2 == NULL)
    {
        printf("3 - Creer personnage joueur 2\n");
        printf("4 - Charger joueur 2\n");
    }

    if((joueur1 != NULL) && (joueur2 != NULL))
    {
        printf("5 - joueur 1 vs joueur 2\n");
        printf("6 - joueur 1 vs joueur 2 X10\n");
        printf("7 - joueur 2 vs joueur 1\n");
        printf("8 - joueur 2 vs joueur 1 X 10\n");
        printf("9 - Afficher joueur 1\n");
        printf("10 - Afficher joueur 2\n");
        printf("11 - Sauvegarder joueur 1\n");
        printf("12 - Sauvegarder joueur 2\n");
    }

    printf("13 - Quitter\n");
}


int calculAttaque(typePersonnage *att)
{
    double bonus;
    double attaque;
    switch (att->competence)
    {
    case PALADIN:
        bonus=BONUSATTPALA;
        break;
    case SAMOURAI:
        bonus=BONUSATTSAM;
        break;
    case BERSERK:
        bonus=BONUSATTBER;
        break;
    case BRETTEUR:
        bonus=BONUSATTBRE;
        break;
    case GUERRIER:
        bonus=BONUSATTGUE;
        break;
    case ASSASSIN:
        bonus=BONUSATTASS;
        break;
    }

    attaque=att->niveau*( (att->poids*att->taille)/ (double)att->age)*bonus;
    // je personnage possede une arme a 2 mains
    if (att->armes.deuxMains!=NIL)
    {
        attaque=attaque+att->armes.deuxMains;
    }
    else    // le personnage ne possede pas d'arme a 2 mains
    {
        // le perso n'a pas de bouclier
        if (att->armes.mainDroite!=BOUCLIER && att->armes.mainGauche!=BOUCLIER)
        {
            attaque=attaque+att->armes.mainDroite+att->armes.mainGauche;
        }
        else    // un bouclier dans l'une des mains
        {
            attaque=attaque+att->armes.mainDroite+att->armes.mainGauche-BOUCLIER+2;
        }
    }
    attaque=attaque*(0.5+aleatoire(10)/10.0);
    return (int)attaque;
}


int calculDefense(typePersonnage *def)
{
    double bonus;
    double defense;
    switch (def->competence)
    {
    case PALADIN:
        bonus=BONUSDEFPALA;
        break;
    case SAMOURAI:
        bonus=BONUSDEFSAM;
        break;
    case BERSERK:
        bonus=BONUSDEFBER;
        break;
    case BRETTEUR:
        bonus=BONUSDEFBRE;
        break;
    case GUERRIER:
        bonus=BONUSDEFGUE;
        break;
    case ASSASSIN:
        bonus=BONUSDEFASS;
        break;
    }

    defense=def->niveau*( (def->poids*def->taille)/ (double)def->age)*bonus;
    // je personnage possede une arme a 2 mains
    if (def->armes.deuxMains!=NIL)
    {
        defense=defense-(def->armes.deuxMains)/2;
    }
    else    // le personnage ne possede pas d'arme a 2 mains
    {
        // le perso n'a pas de bouclier
        if (def->armes.mainDroite!=BOUCLIER && def->armes.mainGauche!=BOUCLIER)
        {
            defense=defense-(def->armes.mainDroite+def->armes.mainGauche)/3;
        }
        else    // un bouclier dans l'une des mains
        {
            defense=defense-BOUCLIER;
        }
    }
    defense=defense*(0.5+aleatoire(10)/10.0);
    return (int)defense;

}


void mettreAJourNiveau(typePersonnage *perso, unsigned int exp)
{
    perso->experience+=exp;
    if (perso->experience>=EXPERIENCEPASSAGE)
    {
        perso->niveau++;
        perso->experience-=EXPERIENCEPASSAGE;
        perso->pvMax+=PVMAXINIT/perso->niveau;
        perso->pv=perso->pvMax;
        switch (perso->competence)
        {
        case PALADIN:
            perso->resistancePhysique+=RESPALADIN;
            break;
        case SAMOURAI:
            perso->resistancePhysique+=RESSAMOURAI;
            break;
        case BERSERK:
            perso->resistancePhysique+=RESBERSERK;
            break;
        case BRETTEUR:
            perso->resistancePhysique+=RESBRETTEUR;
            break;
        case GUERRIER:
            perso->resistancePhysique+=RESGUERRIER;
            break;
        case ASSASSIN:
            perso->resistancePhysique+=RESASSASSIN;
            break;
        }
    }

}


unsigned int calculerGainExperience(typePersonnage *p1,typePersonnage *p2,booleen victoire,unsigned int tours)
{
    unsigned int exp=0;
    if (victoire)
    {
        exp=2*(p2->niveau-p1->niveau+1)*tours;

    }
    else
    {
        exp=(p2->niveau-p1->niveau+1)*tours;

    }
    return exp;

}


void afficherClasse(competenceDeClasse c)
{
    switch(c)
    {
    case PALADIN:
        printf("Paladin \n");
        break;
    case SAMOURAI:
        printf("Samourai\n");
        break;
    case BERSERK:
        printf("Berserk\n");
        break;
    case BRETTEUR:
        printf("Bretteur\n");
        break;
    case GUERRIER:
        printf("Guerrier\n");
        break;
    case ASSASSIN:
        printf("Assassin\n");
        break;
    }
}


void afficherArmeUneMain(armesUneMain aum)
{
    switch (aum)
    {
    case DAGUE:
        printf("Dague - degats : %d\n",DAGUE);
        break;
    case WAKIZASHI:
        printf("Wakizashi - degats : %d\n",WAKIZASHI);
        break;
    case GLAIVE:
        printf("Glaive - degats : %d\n",GLAIVE);
        break;
    case XIPHOS:
        printf("Xiphos - degats : %d\n",XIPHOS);
        break;
    case CLADIO:
        printf("Cladio - degats : %d\n",CLADIO);
        break;
    case RAPIERE:
        printf("Rapiere - degats : %d\n",RAPIERE);
        break;
    case BOUCLIER:
        printf("Bouclier - protection : %d\n",-BOUCLIER);
        break;
    case RIEN:
        printf("Vide - degats : 1\n");
        break;
    }
}

void afficherArmeDeuxMains(armesDeuxMains adm)
{
    switch (adm)
    {
    case NIL:
        printf("Nil - degats : %d\n",NIL);
        break;
    case BATARDE:
        printf("Batarde - degats : %d\n",BATARDE);
        break;
    case KATANA:
        printf("Katana - degats : %d\n",KATANA);
        break;
    case CLAYMORE:
        printf("Claymore - degats : %d\n",CLAYMORE);
        break;
    case FLAMBERGE:
        printf("Flamberge - degats : %d\n",FLAMBERGE);
        break;
    }
}

void afficherArmement(typeArmement arm)
{
    // il possede une arme a 2 mains
    if (arm.deuxMains!=NIL)
    {
        printf("2 mains : ");
        afficherArmeDeuxMains(arm.deuxMains);
    }
    else
    {
        printf("Main gauche : ");
        afficherArmeUneMain(arm.mainGauche);
        printf("Main droite : ");
        afficherArmeUneMain(arm.mainDroite);
    }
}


void afficherPersonnage(typePersonnage *perso)
{
    printf("Classe  : ");
    afficherClasse(perso->competence);
    printf("Nom: %s\nPrenom : %s\nAge : %d\nTaille : %.2f\nPoids : %.2f\n",perso->nom,perso->prenom,perso->age,perso->taille,perso->poids);
    printf("Resistance : %d\nPoints de vie : [%d/%d]\n",perso->resistancePhysique,perso->pv,perso->pvMax);
    printf("Niveau : %d\nExperience dans le niveau : %d/%d\n",perso->niveau,perso->experience,EXPERIENCEPASSAGE);
    afficherArmement(perso->armes);
}


armesUneMain choisirArmeUneMain()
{
    armesUneMain arme;
    int choix;
    do
    {
        printf("Choix de l'arme :\n");
        printf(" 1 :");
        afficherArmeUneMain(DAGUE);
        printf(" 2 :");
        afficherArmeUneMain(WAKIZASHI);
        printf(" 3 :");
        afficherArmeUneMain(GLAIVE);
        printf(" 4 :");
        afficherArmeUneMain(XIPHOS);
        printf(" 5 :");
        afficherArmeUneMain(CLADIO);
        printf(" 6 :");
        afficherArmeUneMain(RAPIERE);
        printf("\n votre choix : ");
        scanf("%d",&choix);
    }
    while(choix<1 || choix >6);
    switch(choix)
    {
    case 1:
        arme=DAGUE;
        break;
    case 2:
        arme=WAKIZASHI;
        break;
    case 3:
        arme=GLAIVE;
        break;
    case 4:
        arme=XIPHOS;
        break;
    case 5:
        arme=CLADIO;
        break;
    case 6:
        arme=RAPIERE;
        break;
    }
    return arme;

}


armesDeuxMains choisirArmeDeuxMains()
{
    armesDeuxMains arme;
    int choix;
    do
    {
        printf("Choix de l'arme : \n");
        printf(" 1 :");
        afficherArmeDeuxMains(BATARDE);
        printf(" 2 :");
        afficherArmeDeuxMains(KATANA);
        printf(" 3 :");
        afficherArmeDeuxMains(CLAYMORE);
        printf(" 4 :");
        afficherArmeDeuxMains(FLAMBERGE);
        printf("\n votre choix : ");
        scanf("%d",&choix);
    }
    while(choix<1 || choix >4);
    switch(choix)
    {
    case 1:
        arme=BATARDE;
        break;
    case 2:
        arme=KATANA;
        break;
    case 3:
        arme=CLAYMORE;
        break;
    case 4:
        arme=FLAMBERGE;
        break;
    }
    return arme;

}


unsigned int determinerResistance(competenceDeClasse c)
{
    unsigned int res;

    switch(c)
    {
    case PALADIN:
        res=RESPALADIN;
        break;
    case SAMOURAI:
        res=RESSAMOURAI;
        break;
    case BERSERK:
        res=RESBERSERK;
        break;
    case BRETTEUR:
        res=RESBRETTEUR;
        break;
    case GUERRIER:
        res=RESGUERRIER;
        break;
    case ASSASSIN:
        res=RESASSASSIN;
        break;
    }
    return res;
}


typePersonnage* creerPersonnage()
{
    typePersonnage* p=malloc(sizeof(typePersonnage));
    int choix;
    char unOuDeux;
    do
    {
        printf("choix de la classe :\n");
        printf(" 1 - Bretteur\n");
        printf(" 2 - Paladin\n");
        printf(" 3 - Berserk\n");
        printf(" 4 - Assassin\n");
        printf(" 5 - Guerrier\n");
        printf(" 6 - Samourai\n");
        printf("Votre choix : ");
        scanf("%d",&choix);
    }
    while(choix<1 || choix >6);

    switch (choix)
    {
    case 1:
        p->competence=BRETTEUR;
        break;
    case 2:
        p->competence=PALADIN;
        break;
    case 3:
        p->competence=BERSERK;
        break;
    case 4:
        p->competence=ASSASSIN;
        break;
    case 5:
        p->competence=GUERRIER;
        break;
    case 6:
        p->competence=SAMOURAI;
        break;
    }
    printf("Nom :");
    scanf(" %s",p->nom);
    printf("Prenom :");
    scanf(" %s",p->prenom);
    printf("Age :");
    scanf("%d",&p->age);
    printf("Taille :");
    scanf("%f",&p->taille);
    printf("Poids :");
    scanf("%f",&p->poids);


    p->pv=PVMAXINIT;
    p->pvMax=PVMAXINIT;
    p->experience=0;
    p->niveau=1;

    p->resistancePhysique=determinerResistance(p->competence);
    // si berserk ne peut avoir qu'une arme a 2 mains
    if (p->competence==BERSERK)
    {

        p->armes.deuxMains=choisirArmeDeuxMains();
    }
    else    // pas berserk
    {
        p->armes.deuxMains=NIL;
        if (p->competence==PALADIN ||  p->competence==SAMOURAI)
        {
            do
            {
                printf("Voulez vous utiliser une arme à deux mains(o/n)?");
                scanf(" %c",&unOuDeux);

            }
            while(unOuDeux!='o' && unOuDeux!='n' );
            if (unOuDeux=='o')
            {
                p->armes.deuxMains=choisirArmeDeuxMains();

            }
            else
            {
                p->armes.mainDroite=choisirArmeUneMain();

                if (p->competence==PALADIN) // epee et bouclier
                {

                    p->armes.mainGauche=BOUCLIER;

                }
                if (p->competence==SAMOURAI) // epee et main libre
                {

                    p->armes.mainGauche=RIEN;

                }

            }
        }
        if (p->competence==ASSASSIN)
        {
            p->armes.mainDroite=choisirArmeUneMain();
            p->armes.mainGauche=RIEN;

        }
        if (p->competence==BRETTEUR)
        {
            do
            {
                printf("Voulez vous utiliser deux armes (o/n)?");
                scanf(" %c",&unOuDeux);

            }
            while(unOuDeux!='o' && unOuDeux!='n' );
            if (unOuDeux=='o')
            {
                printf("Main droite : ");
                p->armes.mainDroite=choisirArmeUneMain();
                printf("Main gauche : ");
                p->armes.mainGauche=choisirArmeUneMain();
            }
            else
            {
                p->armes.mainDroite=choisirArmeUneMain();

                p->armes.mainGauche=RIEN;

            }

        }
        if (p->competence==GUERRIER)
        {
            do
            {
                printf("Voulez vous utiliser un bouclier(o/n)?");
                scanf(" %c",&unOuDeux);

            }
            while(unOuDeux!='o' && unOuDeux!='n' );
            if (unOuDeux=='o')
            {
                printf("Main droite : ");
                p->armes.mainDroite=choisirArmeUneMain();

                p->armes.mainGauche=BOUCLIER;
            }
            else
            {
                p->armes.mainDroite=choisirArmeUneMain();

                p->armes.mainGauche=RIEN;

            }

        }

    }

    return p;
}


void faireUnDuel(typePersonnage *j1,typePersonnage *j2)
{
    booleen j1gagne=FALSE;
    booleen j2gagne=FALSE;
    int tour=0;
    int expj1,expj2;
    int degatJ1vsJ2;
    int degatJ2vsJ1;

    do
    {
        degatJ1vsJ2=calculDegats(j1,j2);
// mettre a jour les pv de j2 (pv actuel - degat)

        j2->pv = j2->pv - degatJ1vsJ2;

// afficher j1 attaque j2 et degats occasionnes

        printf("Le joueur 1 attaque le joueur 2 et lui inflige %d de degats.\n", degatJ1vsJ2);

        degatJ2vsJ1=calculDegats(j2,j1);
// mettre a jour les pv de j1 (pv actuel - degat)

        j1->pv = j1->pv - degatJ2vsJ1;

// afficher j1 attaque j2 et degats occasionnes

        printf("Le joueur 2 attaque le joueur 1 et lui inflige %d de degats.\n", degatJ2vsJ1);

// afficher les pv des deux joueurs

        printf("%s [%d/%d]pv\n", j1->nom, j1->pv, j1->pvMax);
        printf("%s [%d/%d]pv\n", j2->nom, j2->pv, j1->pvMax);

// augmenter le nombre de tours

        tour++;
    }
    while (j1->pv>0 && j2->pv>0);

    if (j1->pv>0)
    {
        j1gagne=TRUE;
// remettre les pv de j2 au maximum

        j2->pv = j2->pvMax;

    }
    else
    {
        j2gagne=TRUE;
// remettre les pv de j1 au maximum

        j1->pv = j1->pvMax;

    }

    expj1 = calculerGainExperience(j1,j2,j1gagne,tour);
// mettre a jour j1

    mettreAJourNiveau(j1, expj1);

    expj2 = calculerGainExperience(j2,j1,j2gagne,tour);
// mettre a jour j2

    mettreAJourNiveau(j2, expj2);

// afficher j1

    printf("++++++++++++++++++++++++++++++++");

    afficherPersonnage(j1);

    printf("=================================");
// afficher j2

    afficherPersonnage(j2);

    printf("++++++++++++++++++++++++++++++++");

}


int calculDegats(typePersonnage *attaquant, typePersonnage *defenseur)
{
    float degats;

    degats = calculAttaque(attaquant) - calculDefense(defenseur);

    if(degats <= 0){
        degats = 1;
    }

    return degats;
}


void sauvegarderPersonnages(typePersonnage *joueur)
{
    char nomFichier[NBMAXCARNOM];

    printf("Nom du fichier txt de sauvegarde :");
    scanf("%s", nomFichier);

    FILE *pFich = fopen(nomFichier, "w+");

    //Test si le fichier est correcte
    if(pFich == -1)
    {
        printf("%s\n", strerror(errno));
        exit(errno);
    }

    fwrite(joueur, sizeof(typePersonnage), 1, pFich);

    fclose(pFich);
}


typePersonnage* chargerPersonnage()
{
    char nomFichier[NBMAXCARNOM];
    typePersonnage* joueur=malloc(sizeof(typePersonnage));

    printf("Nom du fichier txt à ouvrir \n(le fichier en question doit etre a la racine du programme):");
    scanf("%s", nomFichier);

    FILE *pFich = fopen(nomFichier, "r");

    //Test si le fichier est correcte
    if(pFich == -1)
    {
        printf("%s\n", strerror(errno));
        exit(errno);
    }

    fread(joueur, sizeof(typePersonnage), 1, pFich);

    fclose(pFich);

    return joueur;
}