implémentation algo théorique (cela marche )

algo

@@ -0,0 +1,52 @@
+algo un certains nombre N de joueurs
+
+a chaque session, une table joue à un jeu avec T joueurs
+le but :
+_ faire le moins de sessions possibles
+_ chaque joueurs à joué une fois à chaque jeu
+_ maximiser la diversité des oppositions
+_ minimiser le nombre de table avec le meme jeu
+
+pour chaque session
+ un joueur à  :
+    _ une liste de jeu possible
+    _ une liste des opposants déjà rencontrés (pondéré au nombre de rencontres)
+
+le but : former Math.floor(N/T) tables
+    Js = la liste des joueurs non affectés
+    TANT QUE  Nb_Tables < Math.floor(N/T)  et jeux pas vide faire
+        jeux = map jeu/liste joueurpossible (le joueur n'a pas joué et est présent dans Js)
+                si moins de T joueurs dispo , jeu pas dans map
+        pour le jeu dans jeux avec le moins de joueurs (en cas d'égalité celui le moins joué a cette session)
+            faire table avec T de choisir_joueur( liste_joueur )
+            retirer les T joueurs de Js
+            pour chaque joueur de la table retirer le jeu et ajouter la table en oposant
+    fin tant que
+
+
+function choisir_joueur (listejoueur) {  o(n2)
+   //probleme des colocataire à T-tuple
+
+   //construction de la préférence
+   pour chaque joueur de listejoueur :
+    preference[joueur]  = { forte:[], faible:[], nulle : [], score:0} //pas rencontré , rencontré 1x rencontré plusieurs fois
+    pour chaque joueur' de liste joueur:
+        si joueur= joueur' continuer
+        si Nb rencontr joueur'<--> joueur ==0
+            preference[joueur].forte.push(joueur')
+        si Nb rencontr joueur'<--> joueur ==1
+            preference[joueur].faible.push(joueur')
+        sinon
+            preference[joueur].nulle.push(joueur')
+    fin pour
+    Si preference[joueur].forte a T-1 element
+      trouvé
+    preference[joueur].score = forte *liste_joueur **2 + faible *liste_joueur + null;
+   fin pour
+
+   //réduction
+   prendre preference forte et preference faible du joueur au meilleur score
+        dans faible, prendre par score décroissant.
+  pour former un T_tuple;
+   retourner "pas possible";
+}

table.html

@@ -23,15 +23,6 @@
           this.opponents = [];
           this.gamesPlayed = [];
         }
-        Player.prototype.availablePlayers = function (players, game) {
-           result = [];
-           for (var player of players ) {
-              if (!this.opponents.includes(player.name) &&
-                !player.gamesPlayed.includes(game) ) //TODO en fonction du mode
-                    result.push(player);
-           }
-           return result;
-        };
         Player.prototype.addOpponents = function (players) {
            for (var player of players ) {
               if (player.name === this.name) {
@@ -44,7 +35,7 @@
 
 
 
-       function compute() {
+  function compute() {
         document.getElementById("results").innerHTML="";
         players = [];
         for (name of playerSet.slice(0,document.getElementById("players").value) ) {
@@ -57,56 +48,46 @@
         session=1;
         maxgameplayed = Math.floor(players.length / playerAtTable);
         show ("Maximum "+ maxgameplayed + " parties joués en même temps<br/>");
-
-        var differentOponentMode = players.length >= playerAtTable * games.length ;
-        if (differentOponentMode ) {
-           showPass("Tous les joueurs pourront affronter des adversaires différents à chaque table");
-        }else {
-           showWarning("Certains joueurs s'affronteront plusieurs fois ");
-        }
         played ={};
         for( const player of players ) {
            played[player.name]={};
         }
 
-        while(!finished) {
+        while(!finished) { //a chaque session
               show("<p><b>Session "+session +"<b><br/>");
               var tables=0;
               playersAvailableInSession=players.slice();
-              newTable=1;
-              while(playersAvailableInSession.length >= playerAtTable
-                  && tables < maxgameplayed  && newTable > 0) {
-                 newTable=0;
-                 for( const game of games ) {
-                       showDebug( "try for  "+game+" players disponibles "+playersAvailableInSession.length +"  ");
-                       possibleplayers= playersAvailableInSession[0].availablePlayers( playersAvailableInSession, game);
-                       showDebug ("players dispo " +possibleplayers.length + "  <br/>" );
+              gameThisSession=[];
 
-                      //youpi , une table faite
-                      if(possibleplayers.length >= playerAtTable ) {
-                         tablePlayer = possibleplayers.slice(0,playerAtTable) ;
-                         show( "table "+game+" : ");
-                         //showDebug ("tablePlayer : " +JSON.stringify(tablePlayer) ) ;
-                         for(  const player of tablePlayer ) {
-                           played[player.name][game] = session;
-                           player.gamesPlayed.push(game);
-                           player.addOpponents(tablePlayer);
-                           show( player.name +", ");
-                           const index = playersAvailableInSession.indexOf(player);
-                           if (index > -1) {
-                              //showDebug("remove "+ player.name + " du pool de session <br/>");
-                              playersAvailableInSession.splice(index, 1); // 2nd parameter means remove one item only
-                           }
-                         }
-                         show( "<br/>");
-                         tables++;
-                         newTable++;
-                      }
+              essai=0;
+              while(tables < maxgameplayed  && essai < 10) {
+                 essai++;
+                 selectedGame = findgame(playersAvailableInSession, gameThisSession);
+                 showDebug( "try for  "  +selectedGame +", players disponibles "+playersAvailableInSession.length );
+                 possibleplayers = chooseplayers(playersAvailableInSession, selectedGame);
 
-                      if(tables == maxgameplayed) {
-                         break;
-                      }
-                  }
+                 showDebug ("players dispo " +possibleplayers.length + "  <br/>" );
+
+                 //youpi , une table faite
+                 if(possibleplayers.length >= playerAtTable ) {
+                     tablePlayer = possibleplayers.slice(0,playerAtTable) ;
+                     show( "table "+selectedGame+" : ");
+                     //showDebug ("tablePlayer : " +JSON.stringify(tablePlayer) ) ;
+                     for(  const player of tablePlayer ) {
+                       played[player.name][selectedGame] = session;
+                       player.gamesPlayed.push(selectedGame);
+                       player.addOpponents(tablePlayer);
+                       show( player.name +", ");
+                       const index = playersAvailableInSession.indexOf(player);
+                       if (index > -1) {
+                          //showDebug("remove "+ player.name + " du pool de session <br/>");
+                          playersAvailableInSession.splice(index, 1); // 2nd parameter means remove one item only
+                       }
+                     }
+                     show( "<br/>");
+                     tables++;
+                     gameThisSession.push(selectedGame);
+                 }
               }
               show("</p>");
               session++;
@@ -128,7 +109,99 @@
          }
        }
 
-        function showPass(text){
+    //pour le jeu dans jeux avec le moins de joueurs (en cas d'égalité celui le moins joué a cette session)
+    function findgame(playersAvailableInSession, gameThisSession) {
+        var gameplayer= {};
+        for( const g of games ) { //init
+           gameplayer[g]=0;
+        }
+
+        for ( p of playersAvailableInSession ) {
+            for ( g of p.gamesPlayed) {
+              gameplayer[g]++;
+            }
+        }
+
+        minjoueur = playersAvailableInSession.length +1;
+        mingame = games[0];
+
+        for( const gp in gameplayer ) { //init
+           if (gameplayer[gp] < minjoueur) {
+              mingame= gp;
+              minjoueur = gameplayer[gp];
+           } else if (gameplayer[gp] === minjoueur) {
+            //alors le moins joué à cette session
+             maxplayed = gameThisSession.reduce( (result, game) =>  game === mingame ? result +1 : result , 0);
+             gpplayed = gameThisSession.reduce( (result, game) =>  game === gp ? result +1 : result , 0);
+             if (gpplayed< maxplayed
+             || (gpplayed == maxplayed && Math.random()>0.5 ) ) { //un peu d'aleatoire en cas d'égalité
+                mingame = gp;
+             }
+           }
+        }
+        return mingame;
+    }
+
+    function chooseplayers(playersAvailableInSession, selectedGame) {
+         preference = [];
+         selectedpreference={ forte:[], faible:[], nulle : [], score:0} ;
+         selectedjoueur = "";
+         bestscore=0;
+         iterateur = playersAvailableInSession.length;
+         for (player of playersAvailableInSession ) {
+             if(  player.gamesPlayed.includes(selectedGame) )  continue;
+
+             preference[player]  = { forte:[], faible:[], nulle : [], score:0} ;
+
+             for (opositeplayer of playersAvailableInSession ) {
+                if( player === opositeplayer || opositeplayer.gamesPlayed.includes(selectedGame) )
+                        continue; //lui-mmeme ou déjà joué a ce jeu, niet!
+                nbrencontre= player.opponents.filter(o => o ===opositeplayer).length;
+                if (nbrencontre==0) {
+                     preference[player].forte.push(opositeplayer);
+                } else if (nbrencontre==1) {
+                     preference[player].faible.push(opositeplayer);
+                } else {
+                     preference[player].nulle.push(opositeplayer);
+                }
+             }
+
+             if(preference[player].forte.length >= playerAtTable-1 ) {
+               preference[player].forte.push(player);
+               return preference[player].forte;
+             } else {
+                   score = preference[player].forte.length *iterateur*iterateur+
+                    preference[player].faible.length *iterateur+
+                    preference[player].nulle.length ;
+                    if (score > bestscore) {
+                         bestscore =  score;
+                         selectedpreference = preference[player];
+                         selectedjoueur= player;
+                    }
+             }
+         }
+
+         //le meilleur score
+         selectedTable=[];
+         selectedTable.push(selectedjoueur);
+         selectedTable.push(selectedpreference.forte);
+         //todo completer
+         var j=0;
+         for (i=selectedTable.length ;i<= playerAtTable ; i++)  {
+              if (selectedpreference.faible.length == j) break; //plus de préférence moyenne
+              selectedTable.push(selectedpreference.faible[j]);
+              j++;
+         }
+         var j=0;
+         for (i=selectedTable.length ;i<= playerAtTable ; i++)  {
+              if (selectedpreference.nulle.length == j) break; //plus de préférence nulle
+              selectedTable.push(selectedpreference.nulle[j]);
+              j++;
+         }
+         return selectedTable;
+    }
+
+    function showPass(text){
          show ("<span style='color:green' >"+ text +"</span><br/>");
         }