← Back to branch summary

~wattazoum/+junk/blackjack

« back to all changes in this revision

Viewing changes to bj_jeu.c

  • Committer: Aziz OUATTARA
  • Date: 2012-11-02 18:47:17 UTC
  • Revision ID: wattazoum@gmail.com-20121102184717-i58drhqv252vszq0
* BlackJack main working
* I used debug symbols flags in makefile
* I used GDB to correct segfaults

Show diffs side-by-side

added added

removed removed

Lines of Context:
bj_jeu.c
1
1
#include "bj_jeu.h"
2
2
#include <stdlib.h>
 
3
#include <string.h>
3
4
#include <time.h>
4
5
 
 
6
#include <stdio.h>
 
7
 
5
8
/*  Fonction: calcule_score
6
9
 *  Entrees: - un pointeur vers une main
7
10
 *           - le nombre de cartes en main
10
13
 *  Calcule le score d'une main donnee. Compte l'as comme 1 ou 11
11
14
 *   suivant le meilleur cas possible.
12
15
 */
13
 
int calcule_score(const int *main, int nb_cartes)
14
 
{
15
 
        int score=0;
16
 
        int i=0;
17
 
        for(i=0;i<nb_cartes;i++){
18
 
                if (main[i]%12 ==0){ 
19
 
                        if (score+11>21){
20
 
                                score=score+1;
21
 
                        } else {
22
 
                                score=score+11;
23
 
                        }
24
 
                        
25
 
                } else {
26
 
                        score=score+main[i];
27
 
                }
28
 
                
29
 
        }
 
16
int calcule_score(const int *main, int nb_cartes) {
 
17
    int score = 0;
 
18
    int i = 0;
 
19
    for (i = 0; i < nb_cartes; i++) {
 
20
        if (main[i] % 12 == 0) {
 
21
            if (score + 11 > 21) {
 
22
                score = score + 1;
 
23
            } else {
 
24
                score = score + 11;
 
25
            }
 
26
 
 
27
        } else {
 
28
            score = score + main[i];
 
29
        }
 
30
 
 
31
    }
30
32
    return score;
31
33
}
32
34
 
38
40
 *  Tire une carte au hasard dans le talon et la donne au joueur
39
41
 *  Le score du joueur est mis a jour.
40
42
 */
41
 
void donne_une_carte(struct s_table *tables, int id_joueur)
42
 
{
43
 
        struct s_joueur joueur;
44
 
        /* tirer une carte au hasard et la sortir du talon */
45
 
        int ind=tire_carte (tables);
46
 
        int carte=tables->cartes[ind];
47
 
        tables->cartes[ind]=tables->cartes[tables->nb_cartes_dispo-1];
48
 
        tables->nb_cartes_dispo--;
49
 
        /*donner la carte au joueur */
50
 
        joueur=tables->joueurs[id_joueur];
51
 
        joueur.jeu_en_main[joueur.nb_cartes+1]=carte;
52
 
        joueur.nb_cartes++;
53
 
        /* calcul du score du joeur */
54
 
        joueur.points=calcule_score (joueur.jeu_en_main, joueur.nb_cartes);
55
 
        
 
43
void donne_une_carte(struct s_table *tables, int id_joueur) {
 
44
    /* tirer une carte au hasard et la sortir du talon */
 
45
    int ind = tire_carte(tables);
 
46
    int carte = tables->cartes[ind];
 
47
    tables->cartes[ind] = tables->cartes[tables->nb_cartes_dispo - 1];
 
48
    tables->nb_cartes_dispo--;
 
49
    /*donner la carte au joueur */
 
50
    
 
51
    tables->joueurs[id_joueur].jeu_en_main[tables->joueurs[id_joueur].nb_cartes] = carte;
 
52
    /* 
 
53
     * printf("nb_cartes ==> %d\n", tables->joueurs[id_joueur].nb_cartes);
 
54
     * printf("==> %d\n", carte);
 
55
     */
 
56
    tables->joueurs[id_joueur].nb_cartes++;
 
57
    /* calcul du score du joeur */
 
58
    tables->joueurs[id_joueur].points = calcule_score(tables->joueurs[id_joueur].jeu_en_main, tables->joueurs[id_joueur].nb_cartes);
 
59
 
56
60
}
57
61
 
58
62
/*  Fonction: tire_carte                                      
62
66
 *                                                           
63
67
 *  Tire une carte au hasard dans le talon                    
64
68
 */
65
 
int tire_carte(struct s_table *table)
66
 
{
67
 
        /* Faire un random pour tirer une carte dans le talon*/
68
 
        int ind=rand()%table->nb_cartes_dispo; 
 
69
int tire_carte(struct s_table *table) {
 
70
    /* Faire un random pour tirer une carte dans le talon*/
 
71
    int ind = rand() % table->nb_cartes_dispo;
69
72
    return ind;
70
73
}
71
74
 
84
87
 *  Distribue 2 cartes a tout le monde                       
85
88
 *  Calcule le score correspondant                           
86
89
 */
87
 
int init_jeu(struct s_table *table, int nb_joueurs, int nb_cartes, char **noms_des_joueurs, const int *affiche_score)
88
 
{
89
 
        struct s_joueur joueur;
90
 
        int i=0;
91
 
        int j=0;
92
 
        /* Initialisation du nombre de joueurs */
93
 
        table->nb_joueurs=nb_joueurs;
94
 
        /* Initialiser les valeurs des tableaux à zero */
95
 
        for (i=0;i>nb_joueurs;i++){
96
 
                /* copie de noms_des_joueurs[i] dans joueur.nom, mais erreur à la compilation*/
97
 
                char *strcpy(joueur.nom ,noms_des_joueurs[i]);
98
 
                for (j=0;j<NB_CARTES_MAIN;j++){
99
 
                        joueur.jeu_en_main[j]=0;
100
 
                }
101
 
                joueur.nb_cartes=0;
102
 
                joueur.points=0;
103
 
                joueur.affiche_score=affiche_score[0];
104
 
                /*attribue à table.joueurs[i] les entrées de joueur,mais erreur (request for member ‘joueurs’ in something not a structure or union)*/
105
 
                table.joueurs[i]=joueur;
106
 
        }
107
 
        /* initialisation du random*/
108
 
        srand(time(NULL));
109
 
        
 
90
int init_jeu(struct s_table *table, int nb_joueurs, int nb_cartes, char **noms_des_joueurs, const int *affiche_score) {
 
91
    struct s_joueur *joueur;
 
92
    int i;
 
93
    int j;
 
94
    /* Initialisation du nombre de joueurs */
 
95
    table->joueurs = malloc(nb_joueurs * sizeof(struct s_joueur));
 
96
    table->nb_joueurs = nb_joueurs;
 
97
    table->nb_cartes_dispo = nb_cartes;
 
98
    table->nb_cartes_max=nb_cartes;
 
99
    table->nb_joueurs=nb_joueurs;
 
100
    /* Initialiser les valeurs des tableaux à zero */
 
101
    for (i = 0; i < nb_joueurs; i++) {
 
102
        joueur = malloc(sizeof(struct s_joueur));
 
103
        table->joueurs[i] = *joueur;
 
104
        /* copie de noms_des_joueurs[i] dans joueur.nom, mais erreur à la compilation*/
 
105
        strcpy(joueur->nom, noms_des_joueurs[i]);
 
106
        for (j = 0; j < NB_CARTES_MAIN; j++) {
 
107
            joueur->jeu_en_main[j] = 0;
 
108
        }
 
109
        joueur->nb_cartes = 0;
 
110
        joueur->points = 0;
 
111
        joueur->affiche_score = *affiche_score;
 
112
 
 
113
    }
 
114
    /* initialisation du random*/
 
115
    srand(time(NULL));
 
116
 
 
117
    /* donne 2 cartes et calcul le score*/
 
118
    for (i = 0; i < nb_joueurs; i++) {
 
119
        donne_une_carte(table, i);
 
120
        donne_une_carte(table, i);
 
121
        table->joueurs[i].points = calcule_score(table->joueurs[i].jeu_en_main, 2);
 
122
    }
 
123
    
110
124
    return 0;
111
125
}
112
126