TP 4 : Fédération de Boxe - Round 2 - Combat

Commentaires

Transcription

TP 4 : Fédération de Boxe - Round 2 - Combat
TP 4 : Fédération de Boxe - Round 2 - Combat
Extract of La page de Julien Seinturier
http://www.seinturier.fr/spip/spip.php?article99
TP 4 : Fédération de Boxe Round 2 - Combat
- Enseignements - Archives - 2013 / 2014 - DUT R&T IUT d'Aix-Marseille - Programmation Objet -
Publication date: lundi 16 mars 2015
Description:
Ce TP est dédié à la mise en place de combats entre les boxeurs modélisés lors du TP 3.
Copyright © La page de Julien Seinturier - Tous droits réservés
Copyright © La page de Julien Seinturier
Page 1/8
TP 4 : Fédération de Boxe - Round 2 - Combat
Prérequis
Liens utiles :
API java 1.8 :http://docs.oracle.com/javase/8/docs/api/
Outils Java :http://docs.oracle.com/javase/8/docs/technotes/tools/index.html
Les TPs en rapport :
TP 3 : Fédération de Boxe - Round 1 : Héritage
TP 4 : Fédération de Boxe - Round 2 : Combat
TP 5 : Fédération de Boxe - Round 3 : Collections
TP 6 : Fédération de Boxe - Round 4 - Entrée/Sorties
Introduction
Après avoir modéliser différents types de boxeurs lors du TP 3, nous allons maintenant mettre en place un système
de combat permettant de les faire s'affronter.
1. Description d'un combat
Un combat est l'opposition entre deux combattants dans un environnement clos (le ring) durant une période de
temps définie et fractionnée(en reprises, ou rounds).
Dans les sport de combats de type boxe, deux adversaires s'affrontent. Ceux-ci sont généralement identifiés par les
2 coins du ring dans lesquels ils se trouvent au début (coin bleu ou coin rouge). Le combat est caractérisé par une
suite de rounds (généralement 12 de 3 minutes chacun) durant lesquels les boxeurs échangent des coupes.
Le combat se termine si l'un des 2 boxeurs est mi hors combat (Knock Out - KO) ou si tous les rounds ont été
effectués. Le résultat d'un combat voit un vainqueur avant le terme si un boxeur met sont adversaire KO, un
vainqueur au point si le combat est allé au bout de ses rounds et qu'un des deux boxeurs possède un meilleur score
ou encore un match nul (ou no contest) si les 2 boxeurs sont KO ou si à la fin des rounds les deux possèdent le
même score.
2. Modélisation d'un combat
Nous allons maintenant enrichir notre package boxing avec une classe permettant de représenter des combats entre
boxeurs. Un combat sera représenté par la classe Combat du package fr.univamu.iut.rt.java.boxing. Les données
les plus élémentaires pour organiser un combat sont :
•
•
Les deux adversaires ;
Le nombre de rounds.
Copyright © La page de Julien Seinturier
Page 2/8
TP 4 : Fédération de Boxe - Round 2 - Combat
1. Créer la classe Combat du package fr.univamu.iut.rt.java.boxing. Cette classe devra comporter les champs
suivant :
bleu : qui est une référence vers le boxeur du coin bleu ;
•
rouge : qui est une référence vers le boxeur du coin rouge ;
•
roundsTotal : qui est le nombre de rounds total du combat.
•
La classe combat devra contenir le constructeur public Combat(Boxeur rouge,
d'instancier un combat d'un nombre de rounds donné entre deux boxeurs.
Nous allons maintenant faire de la classe
ajoutant des accesseurs.
Combat
Boxeur bleu, int rounds)
qui permet
un Java Bean en y appliquant des règles de sécurité et en y
2. Transformer la classe Combat en un Java Bean. Pour cela :
• passer tous les champs de la classe en private ;
• ajouter les accesseurs (getter / setters) nécessaires aux champs.
3. Phase de combat
Un combat peut être assimilé à une succession de phases composées de l'attaque d'un premier boxeur sur le
second suivie d'une attaque de ce second boxeur sur le premier. Chaque boxeur est donc capable d'attaquer et de
se défendre. Pour cela vous ajouterez à la classe Boxeur deux méthodes permettant de représenter les gestes
offensifs et défensifs.
•
Une attaque sera représentée par la méthode de la classe Boxeur :
public void frappe(Boxeur){} Cette méthode indique au boxeur attaquant qu'il doit porter un coup au
•
boxeur passé en paramètre.
•
Un geste défensif sera représenté par la méthode de la classe Boxeur :
public void defend(ICoup){} Celle-ci permettra au boxeur attaqué de se défendre par rapport au coup
•
reçu(passé en paramètre).
3. Ajouter à la classe Boxeur les méthodes suivantes :
public void frappe(Boxeur){} qui indique au boxeur attaquant qu'il doit porter un coup au boxeur passé en
•
paramètre.
public void defend(ICoup){} qui permettra au boxeur attaqué de se défendre par rapport au coup reçu(passé
•
en paramètre).
A partir des deux méthodes
manière suivante :
•
frappe(Boxeur)
et
defend(ICoup)
il est possible de modéliser une action de combat de la
l'attaquant choisi le coup à porter ;
Copyright © La page de Julien Seinturier
Page 3/8
TP 4 : Fédération de Boxe - Round 2 - Combat
•
•
il assène le coup au défenseur ;
le défenseur réagi au coup reçu.
Cette modélisation peut être facilement représentée grâce aux deux méthodes.
4. Modifier les méthodes suivantes public void frappe(Boxeur){} et public void defend(ICoup){} afin de
représenter la modélisation d'une action de combat telle que :
• la méthode frappe(Boxeur) :
• instancie un objet implantant l'interface ICoup (CoupPied, CoupPoing ou CoupCoude) ;
• appelle la méthode defend(ICoup) du boxeur défenseur en lui passant en paramètre le ICoup instancié.
•
la méthode defend(ICoup) doit permette au boxeur de réagir au coup reçu. Pour l'instant cette méthode peut se
contenter de ne rien faire.
Penser à ajouter des affichages (System.out.println() à l'intérieur des méthodes pour en suivre le déroulement. par
exemple, un appel à b1.frappe(b2) peut afficher b1.getNom()+" frappe "+b2.getNom())
4. Déroulement d'un combat
Nous allons maintenant nous intéresser au déroulement d'un combat en le représentant de façon simplifiée. Un
combat peut se résumer à un échange de coups entre boxeurs durant un nombre de rounds donnés. Un algorithme
de combat peut alors être le suivant :
Boxeur
rouge: Boxeur
roundsTotal : entier
roundActuel: entier
tantque roundActuel < roundsTotal faire
roundActuel ↕ roundActuel+ 1
bleu.frappe(rouge)
rouge.frappe(bleu)
fintq
bleu:
5. Ajouter à la classe
Une fois la classe
Combat
Combat
6. Ajouter au package
une méthode
public void combat()
qui implante l'algorithme ci-dessus.
mise à jour, il faut tester celle-ci.
fr.univamu.iut.rt.java.boxing
une classe
CombatTest
dont le code est le suivant :
package fr.univamu.iut.rt.java.boxing;
import java.util.Date;
Copyright © La page de Julien Seinturier
Page 4/8
TP 4 : Fédération de Boxe - Round 2 - Combat
public class CombatTest {
public static void main(String[] args){
Boxeur b1 = new Boxeur(new Date(59, 3, 24, 8, 35), "Panza", "Andre", 85.6f, 1);
Boxeur b2 = new Boxeur(new Date(66, 5, 30, 16, 5), "Tyson", "Mike", 88.4f, 1);
Combat combat = new Combat(b1, b2, 10);
combat.combat();
}
}
Exécuter ensuite cette classe pour tester l'algorithme simple de combat.
5. Déroulement d'un combat : Santé et fatigue des
combattants.
Nous allons maintenant nous concentrer sur le déroulement d'un combat. Lors d'un combat, les boxeurs sont soumis
à la fatigue et à la dégradation de leur santé en fonction des coups reçus.
La santé est représentée par un double compris entre 0 et 100 tel qu'à 100 le boxeur est en pleine santé et à 0 il est
KO. La fatigue est également représentée par un double tel qu'à 0 le boxeur est en pleine forme et à 100 il n'est plus
en état de porter des coups. La méthode isKO() retourne true si le boxeur est ko.
7. Afin de modéliser ce comportement, vous allez ajouter à la classe Boxeur les méthodes :
• public void setSante(double sante) {} qui change l'état de santé actuel du boxeur ;
• public double getSante() {} qui retourne l'état de santé actuel du boxeur ;
• public void setFatigue(double fatigue) {} qui change l'état de fatigue actuel du boxeur ;
• public double getFatigue() {} qui retourne l'état de fatigueactuel du boxeur ;
• public boolean isKO() {} qui retourne true si le boxeur est KO (c'est à dire si sa santé est inférieure à 0) et
false sinon.
La fatigue est la santé d'un
•
•
•
Boxeur
évoluent au cours d'un combat :
La santé diminue à chaque coup reçu et non esquivé / paré / contré. La valeur de santé perdue est fonction de
la puissance du coup porté.
La fatigue augmente à chaque coup porté. La valeur de la diminution est fonction de la puissance du coup porté
et de sa vitesse.
La fatigue se réduit lors de chaque esquive / contre.
8. Modifier les méthodes public void frappe(Boxeur){} et public void defend(ICoup){} de la classe
d'intégrer les règles relatives à la santé et à la fatigue énoncées ci-dessus.
Aide : La méthode
defend(ICoup)
Copyright © La page de Julien Seinturier
Boxeur
afin
doit permettre au boxeur de réagir au coup reçu. Une implantation très simple de
Page 5/8
TP 4 : Fédération de Boxe - Round 2 - Combat
cette méthode est de faire baisser la santé du boxeur défenseur en fonction de la puissance du coup reçu.
En plus d'attaquer et de défendre, les combats contiennent également des phases de repos (lorsque les boxeurs
sont fatigués.)
9. Les combats alternant des phases actives et des phases calmes, vous définirez pour la classe Boxeur la méthode
public void garde(){}.
Cette méthode place je boxeur en garde est lui permet de récupérer un peu en diminuant sa fatigue et en
augmentant sa santé. Ces changements de valeurs se font par exemple en fonction de l'endurance du boxeur.
A partir des nouvelles propriétés de la classe
combat.
10. Ajouter à classe
Combat
Boxeur,
il est possible d'enrichir la modélisation du déroulement d'un
les champs suivants :
public static final int BLEU_VAINQUEUR_KO
= 1;
public static final int BLEU_VAINQUEUR_PTS
= 2;
public static final int ROUGE_VAINQUEUR_KO
= 3;
public static final int ROUGE_VAINQUEUR_PTS = 4;
public static final int DOUBLE_KO
= 5;
public static final int NO_CONTEST
= 6;
Ces champs permettront de déterminer le résultat d'un combat.
Il est possible maintenant d'enrichir la méthode
possibles à un combat.
combat
11. Modifier dans la classe Combat la méthode public
• si les deux boxeurs sont ko ;
• si l'un des deux boxeurs est ko ;
• si le nombre maximal de rounds est atteint.
elle même afin de prendre en compte tous les résultats
void combat()
en faisant en sorte qu'un combat se termine :
Modifier ensuite la signature de public void combat() en public int combat() afin que celle-ci retourne un entier
représentant le résultat du combat (voir exercice 10). Les valeurs possibles sont :
•
•
si le boxeur bleu a gagné par KO ;
BLEU_VAINQUEUR_PTS si le boxeur bleu a gagné aux points (c'est à dire si à la fin du combat il a plus de santé que
le boxeur rouge) ;
BLEU_VAINQUEUR_KO
Copyright © La page de Julien Seinturier
Page 6/8
TP 4 : Fédération de Boxe - Round 2 - Combat
•
•
•
•
ROUGE_VAINQUEUR_KO
si le boxeur rouge a gagné par KO ;
si le boxeur rouge a gagné aux points (c'est à dire si à la fin du combat il a plus de santé
ROUGE_VAINQUEUR_PTS
que le boxeur bleu) ;
DOUBLE_KO si à la fin du combat les deux boxeurs sont KO ;
NO_CONTEST si à la fin du combat aucun boxeur n'est KO et que les deux ont la même valeur de santé.
Tester votre nouvelle implantation de
Combat
en exécutant la classe
CombatTest
6. Différents styles, différentes techniques.
Il existe de nombreuses techniques de boxe dans le monde. Nous allons maintenant modéliser quelques types de
boxe en représentant les boxeurs issus de ces techniques.
La boxe anglaise (aussi appelée le noble art) est une discipline dans laquelle les combattants utilisent uniquement
leur poings pour frapper leur adversaire.
13. Afin de représenter un boxeur pratiquant la boxe anglaise, vous définirez la classe
classe Boxeur. Vous devrez redéfinir les méthodes appropriées et vous assurer que :
• Un boxeur anglais ne peut porter que des coups de poings ;
• Un boxeur anglais ne peut contrer / parer des coups bas ;
• Un boxeur anglais ne peut porter de coups bas.
BoxeurAnglais
qui étendra la
La boxe française (ou savate) est une discipline dans laquelle les combattants peuvent utiliser leurs poings (comme
en boxe anglaise) et leur pieds pour frapper l'adversaire.
14. Afin de représenter un boxeur pratiquant la boxe française, vous définirez la classe
la classe Boxeur. Vous devrez vous assurer que :
• un boxeur français ne peut porter que des coups de Poings / Pieds ;
• un boxeur français peut porter des coups hauts, médians et bas ;
• un boxeur français peut esquiver / contrer les coupes de Poings et de Pieds ;
BoxeurFrancais
qui étendra
Maintenant qu'au moins deux techniques de boxe ont été modélisées, il faut s'assurer que l'on ne peut plus définir de
boxeur non issu d'une technique spécifique.
15. Modifier la classe Boxeur afin de la rendre abstraite. Pour cela :
• modifier la méthode public void frappe(Boxeur){} en public abstract void frappe(Boxeur){} ;
• modifier la méthode public void defend(ICoup){} en public abstract void defend(ICoup){}.
Vous ne pouvez plus maintenant directement instancier de Boxeur, il faut impérativement passer par un
BoxeurAnglais / BoxeurFrancais. Cette modélisation traduit le fait qu'un boxeur est forcement issu d'une discipline.
Copyright © La page de Julien Seinturier
Page 7/8
TP 4 : Fédération de Boxe - Round 2 - Combat
16. Maintenant que la classe Boxeur est devenue abstraite, la classe de test de combat (CombatTest) ne fonctionne
plus et doit être modifiée avec le code suivant :
package fr.univamu.iut.rt.java.boxing;
import java.util.Date;
public class CombatTest {
public static void main(String[] args){
Boxeur b1 = new BoxeurFrancais(new Date(59, 3, 24, 8, 35), "Panza", "Andre", 85.6f, 1);
Boxeur b2 = new BoxeurAnglais(new Date(66, 5, 30, 16, 5), "Tyson", "Mike", 88.4f, 1);
Combat combat = new Combat(b1, b2, 10);
combat.combat();
}
}
Exécuter ensuite cette classe pour tester lla nouvelle version de l'implantation de
Combat.
Vous pouvez maintenant exécuter à nouveau le jalon.
JALON 2 : Mettre à jour la librairie validation.jar en copiant le fichier dans le répertoire
lib
de votre projet.
Vous pouvez maintenant exécuter la cible Ant nommée test.boxing. Celle-ci testera votre projet et vous affichera un
rapport. Ce test enverra aussi un email au responsable des Tps contenant une copie de ce rapport.
Vous pouvez exécuter le test autant que nécessaire, seul le dernier envoi sera comptabilisé.
Rappel : pour exécuter une cible Ant, il suffit de vous placer dans le répertoire contenant le fichier
taper la commande ant cible (par exemple dans notre cas ant test.boxing).
build.xml
et de
Si vous avez oublié le fonctionnement de Ant ou que votre architecture de projet n'est pas valide, reportez-vous au
TP 2.
7. Si vous avez fini...
Si vous avez défini les coups relatifs à la boxe Thailandaise (voir TP2), il est alors possible de définir un boxeur
pratiquant la boxe thaïlandaise. Afin de représenter ce boxeur, vous définirez la classe BoxeurThai qui étendra la
classe Boxeur. Vous devrez vous assurer que :
•
•
•
•
Un boxeur thai ne peut porter que des coups de Poings / Pieds / Coude / Genoux
Un boxeur thai peut porter des coups hauts, médians et bas ;
Un boxeur thai peut esquiver / contrer que les coups de poings ;
Un boxeur thai ne peut pas contrer un coup de coude.
Copyright © La page de Julien Seinturier
Page 8/8