[POO] : gestion d'une partie de tennis en PHP et en objet

Un billet blog de rawsrc

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
<?php 
  
/** 
 * Classe représentant le concept de Joueur 
 * 
 * @see https://www.developpez.net/forums/blogs/32058-rawsrc/b8721/poo-gestion-partie-tennis-php-objet/ 
 * @date 2020-01-08 
 * @author rawsrc http://www.developpez.net/forums/u32058/rawsrc 
 */ 
class Joueur 
{ 
    private $id; 
    private $nom; 
    private $prenom; 
  
    public function __construct($id, string $nom, string $prenom) 
    { 
        $this->id     = $id; 
        $this->nom    = $nom; 
        $this->prenom = $prenom; 
    } 
  
    public function id() 
    { 
        return $this->id; 
    } 
  
    public function nom(): string 
    { 
        return $this->nom; 
    } 
  
    public function prenom(): string 
    { 
        return $this->prenom; 
    } 
  
    public function nomComplet(): string 
    { 
        return $this->prenom.' '.$this->nom; 
    } 
}

1
2
3
$roger_federer = new Joueur('rf', 'FEDERER', 'Roger'); 
$rafael_nadal = new Joueur('rn', 'NADAL', 'Rafael'); 
$andy_murray = new Joueur('am', 'MURRAY', 'Andy');

1
2
$atp_rf = classementATP($roger_federer); // ici $roger_federer est un Joueur car il est une instance de la classe Joueur 
$atp_rn = classementATP($rafael_nadal); // ici $rafael_nadal est un Joueur car il est une instance de la classe Joueur

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
<?php 
  
/** 
 * Classe représentant le concept de Partie au tennis 
 * 
 * @see https://www.developpez.net/forums/blogs/32058-rawsrc/b8721/poo-gestion-partie-tennis-php-objet/ 
 * @date 2020-01-08 
 * @author rawsrc http://www.developpez.net/forums/u32058/rawsrc 
 */ 
class Partie 
{ 
    /** 
     * Nombre total de sets pour la partie : 3 ou 5 
     * @var int 
     */ 
    private $nb_sets; 
    /** 
     * @var array   [num_set => [Set]] 
     */ 
    private $sets = []; // suivi des sets 
    /** 
     * @var Joueur 
     */ 
    private $joueur1; 
    /** 
     * @var Joueur 
     */ 
    private $joueur2; 
    /** 
     * @var Set 
     */ 
    private $set_courant; 
    /** 
     * @var Joueur 
     */ 
    private $gagnant; 
    /** 
     * @var bool 
     */ 
    private $est_finie = false; 
  
    /** 
     * @param Joueur $j1      Joueur numéro 1 
     * @param Joueur $j2      Joueur numéro 2 
     * @param int    $nb_sets nombre de sets à jouer : 3 ou 5 
     */ 
    public function __construct(Joueur $j1, Joueur $j2, int $nb_sets) 
    { 
        $this->joueur1 = $j1; 
        $this->joueur2 = $j2; 
        if (($nb_sets === 3) || ($nb_sets === 5)) { 
            $this->nb_sets = $nb_sets; 
        } else { 
            $this->nb_sets = 3; 
        } 
        $this->startNouveauSet(); 
    } 
  
    /** 
     * @return Joueur 
     */ 
    public function joueur1(): Joueur 
    { 
        return $this->joueur1; 
    } 
  
    /** 
     * @return Joueur 
     */ 
    public function joueur2(): Joueur 
    { 
        return $this->joueur2; 
    } 
  
    /** 
     * @return bool 
     */ 
    public function estFinie(): bool 
    { 
        return $this->est_finie; 
    } 
  
    /** 
     * @return bool 
     */ 
    public function estLeDernierSetDeLaPartie(): bool 
    { 
        return $this->set_courant->numero() === $this->nb_sets; 
    } 
  
    /** 
     * Pointeur vers le set en cours de jeu 
     * @return Set 
     */ 
    public function setCourant(): Set 
    { 
        return $this->set_courant; 
    } 
  
    /** 
     * @return int 
     */ 
    public function nbSetsPrevu(): int 
    { 
        return $this->nb_sets; 
    } 
  
    /** 
     * Fonction à appeler quand le Joueur 1 marque le point 
     */ 
    public function pointGagnantJoueur1() 
    { 
        $this->point($this->joueur1, $this->joueur2); 
    } 
  
    /** 
     * Fonction à appeler quand le Joueur 2 marque le point 
     */ 
    public function pointGagnantJoueur2() 
    { 
        $this->point($this->joueur2, $this->joueur1); 
    } 
  
    /** 
     * @return Joueur|null 
     */ 
    public function gagnant(): ?Joueur 
    { 
        return $this->gagnant; 
    } 
  
    private function startNouveauSet(): void 
    { 
        if (empty($this->sets)) { 
            $num = 1; 
        } else { 
            // on incrémente de 1 le numéro du set courant 
            $num = $this->set_courant->numero() + 1; 
        } 
        // la classe Set attend dans son constructeur une référence à la partie en cours : 
        //         public function __construct(Partie $partie, int $numero) 
        // l'instance en cours est désignée par $this 
        // comme nous somme dans le code source de la classe Partie, $this référence bien une Partie 
        $set = new Set($this, $num); 
        // on enregistre le nouveau set dans le tableau de suivi des sets 
        $this->sets[$num] = $set; 
        // pour une question de commodité, on garde un accès direct au set en cours de jeu 
        // comme $set est une instance de classe donc une référence à un objet, ici on a un accès direct 
        // à l'objet original 
        $this->set_courant = $set; 
    } 
  
    /** 
     * Fonction qui gère toute la logique d'une partie de tennis 
     * @param Joueur $gagnant 
     * @param Joueur $perdant 
     */ 
    private function point(Joueur $gagnant, Joueur $perdant) 
    { 
        // calcul des points pour le set courant 
        $this->set_courant->point($gagnant, $perdant); 
  
        // si le set n'est pas fini on continue la suite de la partie 
        if ($this->set_courant->estFini() === false) { 
            return; 
        } 
  
        // set fini : on vérifie si la partie n'est pas finie 
        $nb_actuel_sets_du_gagnant = $this->nbSetsGagnes($gagnant); 
  
        if ($nb_actuel_sets_du_gagnant / $this->nb_sets >= 0.5) { 
            $this->est_finie = true; 
            $this->gagnant   = $gagnant; 
        } else { 
            // le set est fini mais la partie n'est pas finie => on démarre un nouveau set 
            $this->startNouveauSet(); 
        } 
    } 
  
    /** 
     * Pour la partie en cours renvoie le nombre total 
     * de sets gagnés par le joueur en paramètre 
     * @param Joueur $joueur 
     * @return int 
     */ 
    public function nbSetsGagnes(Joueur $joueur): int 
    { 
        $nb = 0; 
        // ici $this->sets est un tableau d'instances de la classe Set 
        // et comme chaque $set est un objet, on a accès à ses propriétés publiques 
        // en particulier on peut savoir si le set est fini et s'il a un gagnant 
        /** @var Set $set */ 
        foreach ($this->sets as $num => $set) { 
            if ($set->estFini() && ($set->gagnant() === $joueur)) { 
                ++$nb; 
            } 
        } 
        return $nb; 
    } 
  
    /** 
     * Pour la partie en cours, renvoie le nombre total 
     * de jeux gagnés dans un set pour le joueur en paramètre 
     * @param  Joueur $joueur 
     * @param  int    $numero_set 
     * @return int 
     */ 
    public function nbJeuxGagnesDansUnSet(Joueur $joueur, int $numero_set) : int 
    { 
        $nb = 0; 
        if (isset($this->sets[$numero_set])) { 
            /** @var Set $set */ 
            $set = $this->sets[$numero_set]; 
            $nb = $set->nbJeuxGagnes($joueur); 
        } 
        return $nb; 
    } 
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
<?php 
  
// dépendances 
include 'Joueur.php'; 
include 'Partie.php'; 
include 'Set.php'; 
include 'Jeu.php'; 
  
// création de 2 joueurs distincts 
$joueur1 = new Joueur('rf', 'FEDERER', 'Roger'); 
$joueur2 = new Joueur('rn', 'NADAL', 'Rafael'); 
  
// démarrage d'une nouvelle partie de tennis en 5 sets 
$partie  = new Partie($joueur1, $joueur2, 5);

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
<?php 
  
/** 
 * Classe représentant le concept de Set au tennis 
 * 
 * @see https://www.developpez.net/forums/blogs/32058-rawsrc/b8721/poo-gestion-partie-tennis-php-objet/ 
 * @date 2020-01-08 
 * @author rawsrc http://www.developpez.net/forums/u32058/rawsrc 
 */ 
class Set 
{ 
    /** 
     * @var Partie 
     */ 
    private $partie; 
    /** 
     * @var int 
     */ 
    private $numero; 
    /** 
     * @var array   suivi des jeux 
     */ 
    private $jeux = []; 
    /** 
     * @var Jeu 
     */ 
    private $jeu_courant; 
    /** 
     * Joueur ayant remporté le set 
     * @var Joueur 
     */ 
    private $gagnant; 
    /** 
     * @var bool 
     */ 
    private $est_fini = false; 
  
    /** 
     * @param Partie $partie 
     * @param int    $numero 
     */ 
    public function __construct(Partie $partie, int $numero) 
    { 
        $this->partie = $partie;    // chaque set appartient à une partie 
        $this->numero = $numero;    // chaque set est numéroté de 1 à 7 
        $this->startNouveauJeu();   // on prépare directement un nouveau jeu 
    } 
  
    /** 
     * @return Partie 
     */ 
    public function partie(): Partie 
    { 
        return $this->partie; 
    } 
  
    /** 
     * @return int 
     */ 
    public function numero(): int 
    { 
        return $this->numero; 
    } 
  
    /** 
     * @return bool 
     */ 
    public function estFini(): bool 
    { 
        return $this->est_fini; 
    } 
  
    /** 
     * Quand le set est fini, on enregistre le joueur gagnant 
     * @return Joueur|null 
     */ 
    public function gagnant(): ?Joueur 
    { 
        return $this->gagnant; 
    } 
  
    /** 
     * @param bool $tie_break 
     */ 
    private function startNouveauJeu(bool $tie_break = false): void 
    { 
        if (empty($this->jeux)) { 
            $num = 1; 
        } else { 
            // on incrémente de 1 le numéro du jeu courant 
            $num = $this->jeu_courant->numero() + 1; 
        } 
        $jeu = new Jeu($this, $num, $tie_break); 
        $this->jeu_courant = $jeu; 
        $this->jeux[$num]  = $jeu; 
    } 
  
    /** 
     * @return Jeu 
     */ 
    public function jeuCourant(): Jeu 
    { 
        return $this->jeu_courant; 
    } 
  
    /** 
     * @param Joueur $gagnant 
     * @param Joueur $perdant 
     */ 
    public function point(Joueur $gagnant, Joueur $perdant) 
    { 
        // on comptabilise le point dans le jeu courant 
        $this->jeu_courant->point($gagnant, $perdant); 
  
        // si le jeu courant est fini on regarde la suite du jeu 
        // sinon le set continue 
        if ($this->jeu_courant->estFini() === false) { 
            return; 
        } 
  
        if ($this->jeu_courant->estTieBreak()) { 
            // tie break terminé 
            $this->est_fini = true; 
            $this->gagnant  = $gagnant; 
            return; 
        } 
  
        // récupération du décompte des jeux gagnés pour chaque joueur pour le set en cours 
        $nb_actuel_jeux_du_gagnant = $this->nbJeuxGagnes($gagnant); 
        $nb_actuel_jeux_du_perdant = $this->nbJeuxGagnes($perdant); 
        $ecart = $nb_actuel_jeux_du_gagnant - $nb_actuel_jeux_du_perdant; 
  
        // si strictement inférieur à 6 => le jeu continue 
        if ($nb_actuel_jeux_du_gagnant < 6) { 
            $this->startNouveauJeu(); 
        } elseif ($ecart >= 2) { 
            // si >= 6 => si écart de sets >= 2 alors le set est fini 
            $this->est_fini = true; 
            $this->gagnant = $gagnant; 
        } elseif ($nb_actuel_jeux_du_perdant === 6) { 
            // jeu décisif => tie break 
            $this->startNouveauJeu(true); 
        } else { 
            $this->startNouveauJeu(); 
        } 
    } 
  
    /** 
     * Pour le set en cours renvoie le nombre 
     * de jeux gagnés par le joueur en paramètre 
     * @param Joueur $joueur 
     * @return int 
     */ 
    public function nbJeuxGagnes(Joueur $joueur): int 
    { 
        $nb = 0; 
        /** @var Jeu $jeu */ 
        foreach ($this->jeux as $num => $jeu) { 
            if ($jeu->estFini() && ($jeu->gagnant() === $joueur)) { 
                ++$nb; 
            } 
        } 
        return $nb; 
    } 
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
<?php 
  
/** 
 * Classe représentant le concept de Jeu au tennis 
 * 
 * @see https://www.developpez.net/forums/blogs/32058-rawsrc/b8721/poo-gestion-partie-tennis-php-objet/ 
 * @date 2020-04-11 
 * @author rawsrc http://www.developpez.net/forums/u32058/rawsrc 
 */ 
class Jeu 
{ 
    /** 
     * @var Set 
     */ 
    private $set; 
    /** 
     * @var int 
     */ 
    private $numero; 
    /** 
     * A chaque coup joué, on suit les scores 
     * [num coup joué => [joueur1 => score, joueur2 => score]] 
     * @var array 
     */ 
    private $score = []; 
    /** 
     * Joueur ayant remporté le set 
     * @var Joueur 
     */ 
    private $gagnant; 
    /** 
     * Indique si le set est fini 
     * @var bool 
     */ 
    private $est_fini = false; 
    /** 
     * @var array   suivi du score du tie_break 
     */ 
    private $tie_break = []; 
  
    /** 
     * @param Set  $set 
     * @param int  $numero 
     * @param bool $tie_break 
     */ 
    public function __construct(Set $set, int $numero, bool $tie_break) 
    { 
        $this->set    = $set;    // chaque jeu appartient à un set 
        $this->numero = $numero; // chaque jeu est numéroté 
  
        // initialisation du tableau des scores 
        // ici on remonte les références parentes pour atteindre la liste des joueurs 
        // qui est disponible que dans le concept Partie 
        $scores = [ 
            $set->partie()->joueur1()->id() => 0, 
            $set->partie()->joueur2()->id() => 0 
        ]; 
        if ($tie_break) { 
            $this->tie_break[] = $scores;   // initialisation du jeu décisif 
        } else { 
            $this->score[] = $scores;       // initialisation d'un jeu standard 
        } 
    } 
  
    /** 
     * @return int 
     */ 
    public function numero(): int 
    { 
        return $this->numero; 
    } 
  
    /** 
     * @return bool 
     */ 
    public function estFini(): bool 
    { 
        return $this->est_fini; 
    } 
  
    /** 
     * Quand le jeu est fini, on enregistre le joueur gagnant 
     * @return Joueur|null 
     */ 
    public function gagnant(): ?Joueur 
    { 
        return $this->gagnant; 
    } 
  
    /** 
     * @return array    [num coup joué => [joueur1 => score, joueur2 => score]] 
     */ 
    public function tableauDesScore(): array 
    { 
        return $this->score; 
    } 
  
    /** 
     * Renvoie le dernier score connu pour le joueur 
     * @param  Joueur $joueur 
     * @return string 
     */ 
    public function score(Joueur $joueur): string 
    { 
        return (string)end($this->score)[$joueur->id()]; 
    } 
  
    /** 
     * @return bool 
     */ 
    public function estTieBreak(): bool 
    { 
        return ( ! empty($this->tie_break)); 
    } 
  
    /** 
     * @param Joueur $gagnant 
     * @param Joueur $perdant 
     */ 
    public function point(Joueur $gagnant, Joueur $perdant) 
    { 
        // traitement particulier si on est dans un tie-break 
        if ($this->estTieBreak()) { 
            $this->pointTieBreak($gagnant, $perdant); 
            return; 
        } 
  
        $id_gagnant = $gagnant->id(); 
        $id_perdant = $perdant->id(); 
  
        // score actuel du joueur ayant marqué le point 
        $score_actuel_gagnant = end($this->score)[$id_gagnant]; 
        // score actuel de l'adversaire 
        $score_actuel_perdant = end($this->score)[$id_perdant]; 
  
        // Par défaut le score du perdant ne bouge pas 
        // sauf dans le cas de l'égalité notée 40A et de l'avantage noté AD ou de sa perte 
        $nouveau_score_perdant = $score_actuel_perdant; 
  
        // détermination du prochain score des joueurs 
        // ajout d'un coup joué et sauvegarde des scores 
        if ($score_actuel_gagnant === 0) { 
            $nouveau_score_gagnant = 15; 
        } elseif ($score_actuel_gagnant === 15) { 
            $nouveau_score_gagnant = 30; 
        } elseif ($score_actuel_gagnant === 30) { 
            if ($score_actuel_perdant === 40) { 
                // score égalité pour les deux joueurs 
                $nouveau_score_gagnant = '40A'; 
                $nouveau_score_perdant = '40A'; 
            } else { 
                $nouveau_score_gagnant = 40; 
            } 
        } elseif ($score_actuel_gagnant === '40A') { 
            if ($score_actuel_perdant === 'AD') { 
                // perte de l'avantage : retour à l'égalité pour les deux joueurs 
                $nouveau_score_gagnant = '40A'; 
                $nouveau_score_perdant = '40A'; 
            } else { 
                $nouveau_score_gagnant = 'AD'; 
            } 
        } elseif (($score_actuel_gagnant === 40) || ($score_actuel_gagnant === 'AD')) { 
            // l'augmentation du score provoque la fin du jeu 
            // on conserve le gagnant du jeu 
            $this->gagnant = $gagnant; 
            $this->est_fini = true; 
            // on va sauvegarder le coup joué avec des valeur particulières 
            // pour bien repérer la fin du jeu 
            $nouveau_score_gagnant = true; 
            $nouveau_score_perdant = false; 
        } 
  
        $this->score[] = [ 
            $id_gagnant => $nouveau_score_gagnant, 
            $id_perdant => $nouveau_score_perdant 
        ]; 
    } 
  
    /** 
     * @param Joueur $gagnant 
     * @param Joueur $perdant 
     */ 
    private function pointTieBreak(Joueur $gagnant, Joueur $perdant) 
    { 
        $id_gagnant = $gagnant->id(); 
        $id_perdant = $perdant->id(); 
  
        // récupération du décompte des points pour chaque joueur 
        $score_actuel_tie_break_du_gagnant = end($this->tie_break)[$id_gagnant]; 
        $score_actuel_tie_break_du_perdant = end($this->tie_break)[$id_perdant]; 
  
        // le tie-break se joue en 7 points de base et il continue jusqu'à obtenir un écart de 2 points 
  
        $nouveau_score_tie_break_du_gagnant = $score_actuel_tie_break_du_gagnant + 1; 
        $ecart = $nouveau_score_tie_break_du_gagnant - $score_actuel_tie_break_du_perdant; 
  
        if ($nouveau_score_tie_break_du_gagnant >= 7) { 
            if ($ecart >= 2) { 
                $this->est_fini = true;    // clôture du jeu 
                $this->gagnant = $gagnant; // enregistrement du gagnant 
            } 
        } 
        // enregistrement du score du tie-break 
        $this->tie_break[] = [ 
            $id_gagnant => $nouveau_score_tie_break_du_gagnant, 
            $id_perdant => $score_actuel_tie_break_du_perdant 
        ]; 
    } 
  
    /** 
     * @param  Joueur $joueur 
     * @return int 
     */ 
    public function scoreTieBreak(Joueur $joueur): int 
    { 
        $score = 0; 
        if ($this->estTieBreak()) { 
            $nb = end($this->tie_break)[$joueur->id()]; 
        } 
        return $score; 
    } 
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
<?php 
  
define('DIR_ROOT', __DIR__.DIRECTORY_SEPARATOR); 
  
// dépendances 
include 'PhpEcho.php';  // moteur de rendu pour l'affichage 
// modélisation : concepts d'une partie de tennis 
include 'src/Joueur.php'; 
include 'src/Partie.php'; 
include 'src/Set.php'; 
include 'src/Jeu.php'; 
  
// routage très basique 
$routes = [ 
    'start' => 'actions/start.php', // soumission du formulaire de création d'une nouvelle partie de tennis 
    'point' => 'actions/point.php'  // soumission d'un point marqué par un joueur 
]; 
  
parse_str($_SERVER['QUERY_STRING'], $query); 
$action = $query['action'] ?? ''; 
  
session_start(); 
  
// page d'accueil 
if ($action === '') { 
    if (isset($_SESSION['partie'])) { 
        // demande de la page d'accueil : alors qu'une partie est en cours => réinitialisation de la partie 
        unset($_SESSION['partie']); 
    } 
    echo new PhpEcho([DIR_ROOT, 'vue Nouvelle_Partie.php']); 
} elseif (isset($routes[$query['action']])) { 
    include DIR_ROOT.$routes[$query['action']]; 
} else { 
    echo 'Action non gérée'; 
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
<?php 
  
/** @var Partie $partie */ 
$partie = $this['partie']; 
  
$en_5sets = ($partie->nbSetsPrevu() === 5); 
  
// pointeur vers les instances de classe des joueurs 
$j1 = $partie->joueur1(); 
$j2 = $partie->joueur2(); 
  
$j1_nom = $this('$hsc', $j1->nomComplet()); 
$j2_nom = $this('$hsc', $j2->nomComplet()); 
  
// score en cours 
if ($partie->setCourant()->jeuCourant()->estTieBreak()) { 
    $titre    = ' - TIE BREAK'; 
    $j1_score = $partie->setCourant()->jeuCourant()->scoreTieBreak($j1); 
    $j2_score = $partie->setCourant()->jeuCourant()->scoreTieBreak($j2); 
} else { 
    $titre    = ''; 
    $j1_score = $partie->setCourant()->jeuCourant()->score($j1); 
    $j2_score = $partie->setCourant()->jeuCourant()->score($j2); 
} 
?> 
<style> 
  * { 
    font-family: Arial; 
    font-size: 14px; 
  } 
  table { 
    border: solid 1px black; 
    border-collapse: collapse; 
  } 
  th, td { 
    text-align: center; 
    padding: 5px; 
    border: solid 1px black; 
    border-collapse: collapse; 
  } 
</style> 
<p>DÉROULEMENT DE LA PARTIE<br>SUIVI DES POINTS</p><br> 
<?php if ($partie->estFinie()) { ?> 
<br><p>LA PARTIE EST FINIE : VICTOIRE DE : <?= $this('$hsc', $partie->gagnant()->nomComplet()) ?></p><br> 
<?php } ?> 
<table> 
    <thead> 
        <tr> 
            <th>JOUEUR</th> 
            <th>Set 1</th> 
            <th>Set 2</th> 
            <th>Set 3</th> 
            <?php if ($en_5sets) { ?> 
            <th>Set 4</th> 
            <th>Set 5</th> 
            <?php } ?> 
        </tr> 
    </thead> 
    <tbody> 
        <tr> 
            <td><?= $j1_nom ?></td> 
            <td><?= $partie->nbJeuxGagnesDansUnSet($j1, 1) ?></td> 
            <td><?= $partie->nbJeuxGagnesDansUnSet($j1, 2) ?></td> 
            <td><?= $partie->nbJeuxGagnesDansUnSet($j1, 3) ?></td> 
            <?php if ($en_5sets) { ?> 
            <td><?= $partie->nbJeuxGagnesDansUnSet($j1, 4) ?></td> 
            <td><?= $partie->nbJeuxGagnesDansUnSet($j1, 5) ?></td> 
            <?php } ?> 
        </tr> 
        <tr> 
          <td><?= $j2_nom ?></td> 
          <td><?= $partie->nbJeuxGagnesDansUnSet($j2, 1) ?></td> 
          <td><?= $partie->nbJeuxGagnesDansUnSet($j2, 2) ?></td> 
          <td><?= $partie->nbJeuxGagnesDansUnSet($j2, 3) ?></td> 
            <?php if ($en_5sets) { ?> 
              <td><?= $partie->nbJeuxGagnesDansUnSet($j2, 4) ?></td> 
              <td><?= $partie->nbJeuxGagnesDansUnSet($j2, 5) ?></td> 
            <?php } ?> 
        </tr> 
    </tbody> 
</table> 
<br><br> 
<?php if ($partie->estFinie() === false) { ?> 
<form method="post" action="index.php?action=point"> 
    <p>POINT GAGNÉ PAR</p> 
    <input type="submit" name="pointJoueur1" value="<?= $j1_nom ?>">  
    <input type="submit" name="pointJoueur2" value="<?= $j2_nom ?>"> 
</form> 
<br><br> 
<p>JEU EN COURS<?= $titre ?></p> 
<table> 
    <tbody> 
        <tr> 
            <td><?= $j1_nom ?></td> 
            <td><?= $j1_score ?></td> 
        </tr> 
        <tr> 
          <td><?= $j2_nom ?></td> 
          <td><?= $j2_score ?></td> 
        </tr> 
    </tbody> 
</table> 
<?php } ?>