Nous avons besoin d'un logiciel qui nous permette de gérer les compétitions mettant en jeu la machine qui est fournie.

Ainsi nous aimerions :

• qu'un manager puisse déclarer de nouvelles compétitions;
• qu'il puisse gérer les matchs pendant la compétition, c'est à dire établir automatiquement la liste des matchs à partir de la liste des participants, gérer la succession des matchs et les résultats des joueurs;
• Sur ce dernier point, il s'agit de permettre à un consultant de consulter pour un joueur au cours de la compétition les matchs joués ou à jouer et les scores obtenus.

Une compétition se déroule ainsi ¹⁾ :

1. Elle est créée
2. Les joueurs absents sont considérés comme forfait.
3. Les matchs sont calculés en fonction du nombre de joueurs et leur rang
4. les matchs sont distibués sur les pistes disponibles (il peut y avoir plusieurs matchs par piste, ils se déroulent en séquence)
5. les pistes sont “lancées”,
6. Dès que toutes les pistes ont terminé,
7. Tant qu'il y a encore des tours à faire (c'est à dire que le gagnant de la compétition n'a pas été déterminé)
   1. on calcule une nouvelle série de matchs en fonction des gagnants du tour précédent
8. On ré-initialise les pistes avec les nouveaux matchs
   1. on ferme les pistes devenues inutiles
   2. On lance les pistes
   3. etc.
9. Le gagnant du tournoi est enregistré.

Nous nous focalisons à présent sur la déclaration d'une compétition et l'établissement des matchs.

Une compétition est définie par la liste des joueurs inscrits. Une compétition se caractérise par une arme et une tranche d’âge.

Avant le début de la compétition, l'appel des joueurs est fait. Sur la base des joueurs présents la liste des matchs initiaux est établie (voir plus bas). Puis, des machines sont enregistrées, une par piste. Les matchs sont alors distribués sur les machines. Chaque machine est alors en prête à contrôler une piste.

la liste des matchs initiaux est établie comme suit :

• Le premier joueur présent (celui de rang le plus fort) est affecté au même match que celui de plus faible rang présent,
• le 2e joue avec l'avant dernier s'il n'a pas encore été affecté
• etc.

Extension : vous pouvez étendre l'algorithme en ne mettant pas deux joueurs d'n même club l'un contre l'autre si c'est possible.

Vous ne développerez pas d'interfaces graphiques mais vous les prévoirez.

Voici les codes d'une piste reliée à une machine. Fournir aussi l'interface de match…

Fournir la javadoc

Voici le modèle associé et le scénario de lancement général envisagé.

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.

???

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 {

1. Vous commencerez par créer une piste et tester
2. Par exemple

  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();

Vous avez modélisé la semaine dernière une compétition. Vous devez à présent connecter une compétition aux pistes. Pour cela vous reprenez votre classe compétition…

Amusez vous

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)));
	}

Cette fois-ci vous allez devoir utiliser vos propres capacités à modéliser.

Notre premier objectif est d'implémenter la méthode next.

IL s'agit de : - gérer une liste de rounds - prendre le prochain round affecté à cette table

EXtension : a chaque round, les joueurs changent de côté.