From 9af280448c60ed512255047aa7c851f562f00189 Mon Sep 17 00:00:00 2001
From: pisouvigne <pisouvigne>
Date: Wed, 29 Jul 2020 10:05:57 +0200
Subject: [PATCH] gen

---
 site/vue/index.html         |   4 +
 site/vue/js/const.js        |   4 +-
 site/vue/js/func.js         |   8 +
 site/vue/js/generateGame.js | 510 +++++++++++++++++++++++++++++++++++-
 4 files changed, 519 insertions(+), 7 deletions(-)

diff --git a/site/vue/index.html b/site/vue/index.html
index 49ea96c..3204225 100644
--- a/site/vue/index.html
+++ b/site/vue/index.html
@@ -620,6 +620,10 @@
 <script src="js/db.js"></script>
 <script src="js/generateGame.js"></script>
 <script>
+    var matchs = [[1, 3], [1, 2], [2, 2]];
+    var listePorteLogique = [[true, "et"], [true, "inv"], [true, "ou"]];
+    var col = [5, 3, 2];
+    generator(matchs, listePorteLogique, col);
     getTest();
     initAll();
 
diff --git a/site/vue/js/const.js b/site/vue/js/const.js
index e242c6f..1777eec 100644
--- a/site/vue/js/const.js
+++ b/site/vue/js/const.js
@@ -59,7 +59,7 @@ var allowedInfoPorte = true;
 
 var double = false;
 
-var click = 0;
+var click = 0, perfectClick = 0;
 
 var successPanel = true;
 
@@ -67,4 +67,4 @@ var arrayPorte = [];
 
 const NOMBRETEST = 500;
 
-var tempCol = [], tempMatchs = [], tempFork = [], tempPortes = [];
\ No newline at end of file
+var tempCol = [], tempMatchs = [], tempFork = [], tempPortes = [], changePorte = [];
diff --git a/site/vue/js/func.js b/site/vue/js/func.js
index 2ce204c..741931d 100644
--- a/site/vue/js/func.js
+++ b/site/vue/js/func.js
@@ -339,6 +339,14 @@ function getLogiqueFromLine(lineId) {
     return logique;
 }
 
+function getLogiqueFromLineEnter(lineId) {
+    var logique = null;
+    logiques.forEach(function (element) {
+        if (element.id1 === lineId || element.id2 === lineId) logique = element;
+    });
+    return logique;
+}
+
 function getSwitchFromLine(lineId) {
     var switche = null;
     switchsInfoCopy.forEach(function (element) {
diff --git a/site/vue/js/generateGame.js b/site/vue/js/generateGame.js
index c97625b..204f04a 100644
--- a/site/vue/js/generateGame.js
+++ b/site/vue/js/generateGame.js
@@ -441,6 +441,444 @@ function createGameOne(niveau) {
 }
 
 
+function generator(matchs, listePorteLogique, col) {
+    var groupes = [];
+    var colCopy = [];
+    var links = [];
+    var orphelins = [];
+    var logiquesTemp = [];
+    for (let i = 0; i < col.length; i++) colCopy[i] = col[i];
+    //liste porte logique
+    if (listePorteLogique === null || listePorteLogique === undefined)
+        arrayPorte = [
+            [document.querySelector("#logique1").checked, "et"],
+            [document.querySelector("#logique2").checked, "ou"],
+            [document.querySelector("#logique3").checked, "inv"],
+            [document.querySelector("#logique4").checked, "etnon"],
+            [document.querySelector("#logique5").checked, "nonou"]
+        ];
+    else arrayPorte = listePorteLogique;
+    arrayPorte = arrayPorte.filter(function (e) {
+        if (e[0] === true) return e;
+    });
+    //Creation des logiques obj : 
+    var logiqueCount = 1;
+    for (let i = 0; i < col.length; i++) {
+        for (let j = 0; j < col[i]; j++) {
+            var newLogique = {
+                id: "logique" + logiqueCount,
+                col: i + 1,
+                id1: null,
+                id2: null,
+                id3: null,
+                type: null,
+            };
+
+            logiquesTemp.push(newLogique);
+            logiqueCount++;
+        }
+    }
+
+    for (let i = col.length; i > 0; i--) {
+        var logiqueCol = [];
+        logiquesTemp.forEach(function (logique) {
+            if (logique.col === i) logiqueCol.push(logique);
+        });
+        //Création des liens
+        matchs.forEach(function (element) {
+            if (element[0] === i) {
+                //Selection de la sortie au hasard dans la colonne i
+                var index = getRandomArbitrary(0, logiqueCol.length);
+                var logiqueUse = logiqueCol[index];
+                logiqueCol.splice(index, 1);
+                //Selection du groupes
+                groupes.forEach(function (group, index) {
+                    if (group.length === element[1]) {
+                        group.forEach(function (logique) {
+                            var signal = null;
+
+                            logiquesTemp.forEach(function (log) {
+                                if (log.id === logique[0]) {
+                                    if (logique[1] === "id1")
+                                        signal = log.id1;
+                                    else signal = log.id2;
+                                }
+                            });
+                            links.push([logiqueUse.id, logique[0], logique[1], signal]);
+                        });
+                        groupes.splice(index, 1);
+                    }
+                });
+            }
+        });
+        //Attribution des links aux orphelins :
+        var free = [], usedLogique = [];
+        logiquesTemp.forEach(function (logique) {
+            isLogiqueFree = [];
+            if (logique.col === i + 1) {
+                //Si c'est un non
+                if (logique.type === "inv") {
+                    var isOk = true;
+                    links.forEach(function (link) {
+                        if (link[1] === logique.id)
+                            isOk = false;
+                    });
+                    usedLogique.forEach(function (uLogique) {
+                        if (uLogique[0] === logique.id) isOk = false;
+                    });
+                    if (isOk)
+                        isLogiqueFree.push("id1");
+                } else {
+                    var isId1 = true;
+                    var isId2 = true;
+                    links.forEach(function (link) {
+                        if (link[1] === logique.id) {
+                            if (link[2] === "id1") isId1 = false;
+                            else isId2 = false;
+                        }
+                    });
+                    //Already use in this column
+                    usedLogique.forEach(function (uLogique) {
+                        if (uLogique[0] === logique.id) {
+                            if (uLogique[1] === "id1") isId1 = false;
+                            else isId2 = false;
+                        }
+                    });
+
+                    if (isId1) isLogiqueFree.push("id1");
+                    if (isId2) isLogiqueFree.push("id2");
+                }
+            }
+            isLogiqueFree.forEach(function (id) {
+                if (id === "id1")
+                    free.push([logique.id, id, logique.id1]);
+                else
+                    free.push([logique.id, id, logique.id2]);
+            });
+        });
+        logiqueCol.forEach(function (logique) {
+            //Check si il reste des portes à droite :
+            if (free.length > 0) {
+                isDone = false;
+                free.forEach(function (fr, index) {
+                    if (!isDone) {
+                        var signal = null;
+                        logiquesTemp.forEach(function (logique) {
+                            if (logique.id === fr[0]) {
+                                if (fr[1] === "id1") signal = logique.id1;
+                                else signal = logique.id2;
+                            }
+                        });
+                        links.push([logique.id, fr[0], fr[1], signal]);
+                        free.splice(index, 1);
+                        isDone = true;
+                    }
+                });
+            } else {
+                links.push([logique.id, "end", null, 1]);
+            }
+        });
+
+        //Calcul du signal souhaité à chaque porte de la colonne i
+        var logiqueTemp2 = [];
+        for (let k = 0; k < logiquesTemp.length; k++) logiqueTemp2[k] = logiquesTemp[k];
+        logiquesTemp.forEach(function (logique) {
+            if (logique.col === i) {
+                //Type au hasard :
+                logique.type = arrayPorte[getRandomArbitrary(0, arrayPorte.length)][1];
+                //Attribution du signal :
+                //Si dernière colonne
+                if (i === col.length) {
+                    logique.id3 = 1;
+                    //Opération pour les entrée :
+                    switch (logique.type) {
+                        case "et":
+                            logique.id1 = 1;
+                            logique.id2 = 1;
+                            break;
+                        case "ou":
+                            switch (getRandomArbitrary(0, 3)) {
+                                case 0:
+                                    logique.id1 = 1;
+                                    logique.id2 = 1;
+                                    break;
+                                case 1:
+                                    logique.id1 = 0;
+                                    logique.id2 = 1;
+                                    break;
+                                case 2:
+                                    logique.id1 = 1;
+                                    logique.id2 = 0;
+                                    break;
+                            }
+                            break;
+                        case "inv":
+                            logique.id1 = 0;
+                            break;
+                        case "nonou":
+                            logique.id1 = 0;
+                            logique.id2 = 0;
+                            break;
+                        case "etnon":
+                            switch (getRandomArbitrary(0, 3)) {
+                                case 0:
+                                    logique.id1 = 0;
+                                    logique.id2 = 0;
+                                    break;
+                                case 1:
+                                    logique.id1 = 0;
+                                    logique.id2 = 1;
+                                    break;
+                                case 2:
+                                    logique.id1 = 1;
+                                    logique.id2 = 0;
+                                    break;
+                            }
+                            break;
+                    }
+                } else {
+                    //Attribution du signal id3
+                    var isNull = null;
+                    //console.log("Colonne : " + i + " ---------------------")
+                    links.forEach(function (link) {
+                        if (isNull === null) {
+                            if (link[0] === logique.id) {
+                                logique.id3 = link[3];
+                                isNull = 1;
+                            }
+                        }
+                    });
+                    if (isNull === null) logique.id3 = 1;
+                    //Calcul valeur d'entrée
+                    if (logique.id3 === 1) {
+                        switch (logique.type) {
+                            case "et":
+                                logique.id1 = 1;
+                                logique.id2 = 1;
+                                break;
+                            case "ou":
+                                switch (getRandomArbitrary(0, 3)) {
+                                    case 0:
+                                        logique.id1 = 1;
+                                        logique.id2 = 1;
+                                        break;
+                                    case 1:
+                                        logique.id1 = 0;
+                                        logique.id2 = 1;
+                                        break;
+                                    case 2:
+                                        logique.id1 = 1;
+                                        logique.id2 = 0;
+                                        break;
+                                }
+                                break;
+                            case "inv":
+                                logique.id1 = 0;
+                                break;
+                            case "nonou":
+                                logique.id1 = 0;
+                                logique.id2 = 0;
+                                break;
+                            case "etnon":
+                                switch (getRandomArbitrary(0, 3)) {
+                                    case 0:
+                                        logique.id1 = 0;
+                                        logique.id2 = 0;
+                                        break;
+                                    case 1:
+                                        logique.id1 = 0;
+                                        logique.id2 = 1;
+                                        break;
+                                    case 2:
+                                        logique.id1 = 1;
+                                        logique.id2 = 0;
+                                        break;
+                                }
+                                break;
+                        }
+                    } else {
+                        switch (logique.type) {
+                            case "et":
+                                switch (getRandomArbitrary(0, 3)) {
+                                    case 0:
+                                        logique.id1 = 0;
+                                        logique.id2 = 0;
+                                        break;
+                                    case 1:
+                                        logique.id1 = 0;
+                                        logique.id2 = 1;
+                                        break;
+                                    case 2:
+                                        logique.id1 = 1;
+                                        logique.id2 = 0;
+                                        break;
+                                }
+                                break;
+                            case "ou":
+                                logique.id1 = 0;
+                                logique.id2 = 0;
+                                break;
+                            case "inv":
+                                logique.id1 = 1;
+                                break;
+                            case "nonou":
+                                switch (getRandomArbitrary(0, 3)) {
+                                    case 0:
+                                        logique.id1 = 1;
+                                        logique.id2 = 1;
+                                        break;
+                                    case 1:
+                                        logique.id1 = 0;
+                                        logique.id2 = 1;
+                                        break;
+                                    case 2:
+                                        logique.id1 = 1;
+                                        logique.id2 = 0;
+                                        break;
+                                }
+                                break;
+                            case "etnon":
+                                logique.id1 = 1;
+                                logique.id2 = 1;
+                                break;
+                        }
+                    }
+
+                }
+            }
+        });
+        var usedLogique = [];
+        matchs.forEach(function (element) {
+            if (element[0] === i - 1) {
+                //Création d'un nouveau groupe :
+                var newGroupe = [];
+                //Calcul des logiques libres 
+                var free = [];
+                logiquesTemp.forEach(function (logique) {
+                    isLogiqueFree = [];
+                    if (logique.col === i) {
+                        //Si c'est un non
+                        if (logique.type === "inv") {
+                            var isOk = true;
+                            links.forEach(function (link) {
+                                if (link[1] === logique.id)
+                                    isOk = false;
+                            });
+                            usedLogique.forEach(function (uLogique) {
+                                if (uLogique[0] === logique.id) isOk = false;
+                            });
+                            if (isOk)
+                                isLogiqueFree.push("id1");
+                        } else {
+                            var isId1 = true;
+                            var isId2 = true;
+                            links.forEach(function (link) {
+                                if (link[1] === logique.id) {
+                                    if (link[2] === "id1") isId1 = false;
+                                    else isId2 = false;
+                                }
+                            });
+                            //Already use in this column
+                            usedLogique.forEach(function (uLogique) {
+                                if (uLogique[0] === logique.id) {
+                                    if (uLogique[1] === "id1") isId1 = false;
+                                    else isId2 = false;
+                                }
+                            });
+
+                            if (isId1) isLogiqueFree.push("id1");
+                            if (isId2) isLogiqueFree.push("id2");
+                        }
+                    }
+                    isLogiqueFree.forEach(function (id) {
+                        if (id === "id1")
+                            free.push([logique.id, id, logique.id1]);
+                        else
+                            free.push([logique.id, id, logique.id2]);
+                    });
+                });
+                //On a tableau des portes free, maintenant on doit choisir :
+                //On compte les nombres de portes logiques :
+                var number1 = 0, number0 = 0;
+                var count = 0;
+                //Compte des 0 :
+                var alreadyUse = [];
+                free.forEach(function (fr) {
+                    if (fr[2] === 0) {
+                        var isAllowed = true;
+                        alreadyUse.forEach(function (logique) {
+                            if (logique === fr[0]) isAllowed = false;
+                        });
+                        if (isAllowed) {
+                            number0++;
+                            alreadyUse.push(fr[0]);
+                        }
+                    }
+                });
+                //Compte des 1 :
+                var alreadyUse = [];
+                free.forEach(function (fr) {
+                    if (fr[2] === 1) {
+                        var isAllowed = true;
+                        alreadyUse.forEach(function (logique) {
+                            if (logique === fr[0]) isAllowed = false;
+                        });
+                        if (isAllowed) {
+                            number1++;
+                            alreadyUse.push(fr[0]);
+                        }
+                    }
+                });
+                //Selection entre les 0 ou les 1:
+                //On selectionne les 1
+                if (number1 >= element[1]) {
+                    //Selection des portes :
+                    free.forEach(function (fr) {
+                        if (count < element[1]) {
+                            if (fr[2] === 1) {
+                                var isAllowed = true;
+                                newGroupe.forEach(function (logique) {
+                                    if (logique[0] === fr[0]) isAllowed = false;
+                                });
+                                if (isAllowed) {
+                                    newGroupe.push([fr[0], fr[1]]);
+                                    count++;
+                                }
+                            }
+                        }
+                    });
+                }
+                //On selectionne les 0
+                else if (number0 >= element[1]) {
+                    free.forEach(function (fr) {
+                        if (count < element[1]) {
+                            if (fr[2] === 0) {
+                                var isAllowed = true;
+                                newGroupe.forEach(function (logique) {
+                                    if (logique[0] === fr[0]) isAllowed = false;
+                                });
+                                if (isAllowed) {
+                                    newGroupe.push([fr[0], fr[1]]);
+                                    count++;
+                                }
+                            }
+                        }
+                    });
+                }
+                //Problème retour en arrière : 
+                else {
+                    console.log("gros problème")
+                }
+                groupes.push(newGroupe);
+            }
+        });
+    }
+    console.log(col);
+    console.log(logiquesTemp);
+    console.log(links);
+}
+
+
 function generate2(col, matchs, fork, portes) {
     isTutoriel = false;
     isTuto = false;
@@ -646,21 +1084,83 @@ function generate2(col, matchs, fork, portes) {
         }
     }
     initEndGame();
-    console.log(lines);
-    console.log(endLines);
+    perfectClick = 0;
     var endStateTab = [], v = 0;
+    logiques.forEach(function (logique) {
+        logique.id3.forEach(function (element) {
+            if (getLogiqueFromLineEnter(element) === null || getLogiqueFromLineEnter(element) == undefined) {
+                console.log(element);
+            }
+        });
+    });
     endLines.forEach(function (line) {
         endStateTab[v] = ["line" + line, getLineState("line" + line)];
         v++;
     });
     endStateTab.forEach(function (element) {
         if (element[1] === false) {
-            console.log("faux : " + element[0])
-            console.log(getLogiqueFromLine(element[0]));
+
+            switch (getLogiqueFromLine(element[0]).type) {
+                case "inv":
+                    //il faut les 2 allumé
+                    /* console.log(getLineState(getLogiqueFromLine(element[0]).id1));
+                     console.log(getLineState(getLogiqueFromLine(element[0]).id2));
+                     console.log(getLogiqueFromLine(element[0]).id1);*/
+                    setLineTrue(getLogiqueFromLine(element[0]).id1);
+                    break;
+                default:
+                    setLineTrue(getLogiqueFromLine(element[0]).id1);
+                    setLineTrue(getLogiqueFromLine(element[0]).id2);
+                    break;
+            }
         }
     });
-    invertLine();
+    changePorte.forEach(function (element) {
+        activeSwitch(element);
+        checkAllSortieLogique();
+        stage.draw();
+    });
     checkAllSortieLogique();
+    console.log(perfectClick);
+
+}
+
+function setLineTrue(line) {
+    var isSwitch = false;
+    switchsInfoCopy.forEach(function (element) {
+        element.id3.forEach(function (id3) {
+            if (id3 === line) {
+                if (getLineState(id3) === false) {
+                    perfectClick++;
+                    activeSwitch(element.id);
+                    stage.draw();
+                    changePorte.push(element.id);
+                    isSwitch = true;
+                }
+            }
+        })
+    });
+    if (!isSwitch && getLogiqueFromLine(line) != null) {
+        switch (getLogiqueFromLine(line).type) {
+            case "et":
+                if (getLineState(getLogiqueFromLine(line).id1) === false)
+                    setLineTrue(getLogiqueFromLine(line).id1);
+                if (getLineState(getLogiqueFromLine(line).id2) === false)
+                    setLineTrue(getLogiqueFromLine(line).id2);
+                break;
+            case "ou":
+                if (getLineState(getLogiqueFromLine(line).id1) === false && getLineState(getLogiqueFromLine(line).id2) === false)
+                    setLineTrue(getLogiqueFromLine(line).id1);
+                break;
+            case "inv":
+                setLineTrue(getLogiqueFromLine(line).id1);
+                break;
+        }
+
+    }
+    checkAllSortieLogique();
+    //setLineTrue(getLogiqueFromLine(line).id1);
+
 }
 
 function getNumberFork(arr, col) {