Les codes simulant une machine vous sont donnés. Les seules parties qui vous interessent sont la classe FencingPiste qui définit une “machine” et l'interface MatchInterface que vous devrez implémenter pour gérer les matchs.

Voici le modèle qui décrit les classes FencingPiste et MatchInterface.

Voici le .jar

Voici les javadoc (tronqués pour cause de problèmes de chargement de fichier html dans cet environnement).

• fencingpiste.html
• matchinterface.html

Archive des codes livrés

Voici un exemple très basique d'utilisation de ces classes et interfaces.

match1.java testpist.java

Comme vous avez dû le constater la “FencingPiste” est fournie avec une interface MatchInterface, qui vous permet d'utiliser votre propre classe Match, il suffit pour cela qu'elle “implemente” l'interface.

Voici l'interface MatchInterface qui vous est fournie.

package pistePK;
 
/**
 * Cette interface est utilisée par les machines pour visualiser le nom des joueurs
 * et enregistrer le nom des gagnants
 * Bien sur, chaque système peut implémenter cette interface comme il le veut
 * En particulier pour retrouver le gagnant, et pas forcement avec seulement son nom.
 * @author blay
 */
public interface MatchInterface {
 
	/**
	 * Retourne le nom du joueur de gauche
	 * @return String
	 */
	public String getLeftPlayer();
 
 
	/**
	 * Retourne le nom du joueur de droite
	 * @return String
	 */
	String getRightPlayer();
 
 
	/**
	 * Enregistre le nom du joueur gagnant
	 * 
	 */
	void setWinner(String matchWinner);
 
}

Votre code ne correspond probablement pas exactement à l'interface de MatchInterface.

Vous devez donc adapter VOTRE CODE (et pas l'inverse, en général, on n'a pas le droit de modifier les codes fournis) pour qu'il implémente l'interface MatchInterface.

Rappel : Pour dire qu'une classe implémente une interface

public class Match implements MatchInterface {

Votre objectif est de faire en sorte que que le code écrit à la dernière séance fasse maintenant référence aux machines qui vous ont été fournis.

  FencingPiste pist1 = new FencingPiste(1);
  FencingPiste pist2 = new FencingPiste(2);
  Match m1 = new Match();//attention à bien mettre vos propres parametres dans les constructeurs et votre propre type "Match"
  Match m2 = new Match();
  Match m3 = new Match();
 
  pist1.addMatch(m1);
  pist1.addMatch(m2);
  pist2.addMatch(m3);
 
  pist1.start();
  pist2.start();
 
  while (!(pist1.isOver() && pist2.isOver())  ) {
	Thread.sleep(6000);
	System.out.println("pas fini-------------------");
  }
 
  System.out.println("gagnant de m1" + m1.getWinner());
  System.out.println("gagnant de m2" + m2.getWinner());			
  System.out.println("gagnant de m3" + m3.getWinner());	
 
/*
 * Quand tous les matchs ont eu lieu sur toutes les pistes on re-initialise les match
 * puis on ré-affecte les pistes.
 * On ferme les pistes inutiles
 */
 pist1.clear();
 Match1 m4 = new Match1();
 pist1.addMatch(m4);
 pist1.start();
// On ferme l'autre piste
 pist2.close();

Diagramme de composants

Mettre en avant 1) diagramme de classes

2)

3) Diagramme de séquence qui dit ce que vous devez faire

- où se trouve les codes qui valide une fin de match ¹⁾ ?

- Quel code devez vous modifier pour implémenter la validation conformément aux règles ci-après ?

- De quelles informations disposez-vous pour faire ces calculs?

Règles de validation

- Implémenter les rgles ci-après

- Vérifier que les jeux de données correspondent bien

Faire un tableau

Joueur1 Joueur2 ScoreJoueur1 ScoreJoueur2 Temps Résultat

Voici un jeu de tests

public class MachineControllerTest {
	public static final int THREE_MINUTES = 1000 * 60 * 3;
	public static final int TWO_MINUTES = 1000 * 60 * 2;
	public static final int ONE_MINUTE = 1000 * 60 ;
	Score sleft = new Score(PlayerType.left);
	Score sright = new Score(PlayerType.right);	
	MachineController mc = new MachineController();
	StateMachine stateMachineOnChrono = new StateMachine(sleft,sright, THREE_MINUTES);
	StateMachine stateMachineOnPoints= new StateMachine(sleft,sright, 360);
 
/*	 Des que un des joueurs a fait 5 touches et s'il y a une différence de au moins 1 touches entre les deux joueurs 
	 alors il est déclaré gagnant
	 Par exemple un score de 5 pour l'un et de 3 pour l'autre
	 mais aussi 7 et 5
	par contre 5 et 4 ne suffisent pas.
*/	
	@Test
	public void testValidateOnScoreForLeft() {
		sleft.setScore(5);
		sright.setScore(3);
		assertEquals(PlayerType.left, mc.validate(stateMachineOnPoints));
	}
	@Test
	public void testValidateOnScoreForRight() {
		sright.setScore(5);
		sleft.setScore(3);
		assertEquals(PlayerType.right, mc.validate(stateMachineOnPoints));
	}
 
	@Test
	public void testValidateFailOnScoreGap() {
		sleft.setScore(5);
		sright.setScore(4);
		assertEquals(PlayerType.fail, mc.validate(stateMachineOnPoints));
	}
 
	@Test
	public void testValidateFailOnScoreLevel() {
		sleft.setScore(4);
		sright.setScore(2);
		assertEquals(PlayerType.fail, mc.validate(stateMachineOnPoints));
	}
 
 
 
	// VERSION SIMPLIFIEE 
	// Si aucun des joueurs n'a marqué 5 touches mais que les 3 minutes sont écoulées alors celui qui a fait le plus de touches est déclaré gagnant du round.
	// Si les deux ont le même score, le jeux doit se prolonger 2minutes. 
	// Des que l'un des joueurs touche, il gagne.
	// AU bout de 5minute, le gagnant est tiré au sort.
 
	@Test
	public void testValidateOnChronoLeft() {
		sleft.setScore(4);
		sright.setScore(2);
		assertEquals(PlayerType.left, mc.validate(stateMachineOnChrono));
	}
 
	@Test
	public void testValidateOnChronoRight() {
		sleft.setScore(1);
		sright.setScore(2);
		stateMachineOnChrono.setClockTime(THREE_MINUTES );
		assertEquals(PlayerType.right, mc.validate(stateMachineOnChrono));
	}
 
	@Test
	public void testValidateFailOnChrono() {
		sleft.setScore(2);
		sright.setScore(2);
		stateMachineOnChrono.setClockTime(THREE_MINUTES + ONE_MINUTE);
		assertEquals(PlayerType.fail, mc.validate(stateMachineOnChrono));
	}
 
	@Test
	public void testValidateRandomOnChrono() {	
		sleft.setScore(2);
		sright.setScore(2);
		stateMachineOnChrono.setClockTime(THREE_MINUTES + TWO_MINUTES);
		assertFalse(PlayerType.fail.equals( mc.validate(stateMachineOnChrono)));
	}