From 5ff3687c1e5acf55dec41b647d67f2fb024d4296 Mon Sep 17 00:00:00 2001 From: Adrestie Date: Tue, 22 Sep 2026 18:17:41 +0200 Subject: [PATCH] Gestionnaire : l'ordre retenu ne garde qu'une fois chaque nom Le temoin /fui sets a donne la cause : pour UN ensemble publie par le client, l'ordre retenu en tenait sept -- "aab" quatre fois, plus trois noms effaces. Un nom que le client ne publie pas a cet instant est saute par la premiere boucle, et la seconde le rajoute des qu'il reparait ; quelques renommages suffisaient a empiler les copies. Chaque copie prenant un rang, l'ensemble se posait quatre fois. Et la boucle d'affichage testait "index <= total" avec index = le RANG au lieu de l'indice du client : la carte finissait au rang 4 pour un total de 1, donc masquee -- liste vide apres un renommage. Trois corrections : un nom n'est place qu'une fois ; remplacerDansOrdre retire les copies du nom qu'il pose ; l'ordre se nettoie des noms effaces, mais seulement quand le client publie au moins un ensemble. Le vrai indice se lit dans ordre[position]. Le banc rejoue l'ordre corrompu rapporte par le temoin, et verifie qu'a zero ensemble publie l'ordre reste intact. Co-Authored-By: Claude Opus 5 (1M context) --- data/addon/ForeverUI/EquipmentManager.lua | 64 ++++++++++++++++++----- docs/AMELIORATIONS.md | 2 + tools/test_addon.py | 24 +++++++++ 3 files changed, 77 insertions(+), 13 deletions(-) diff --git a/data/addon/ForeverUI/EquipmentManager.lua b/data/addon/ForeverUI/EquipmentManager.lua index ac12f30..8b5e2ad 100644 --- a/data/addon/ForeverUI/EquipmentManager.lua +++ b/data/addon/ForeverUI/EquipmentManager.lua @@ -198,26 +198,45 @@ local function ensemblesOrdonnes() end end - -- L'ORDRE NE S'ELAGUE PAS ICI. Il l'a fait, et c'etait une faute : - -- quand le client ne rend momentanement AUCUN ensemble -- ce qui arrive - -- entre un enregistrement et son evenement -- l'elagage vidait la table - -- pour de bon. Les noms revenaient ensuite un par un, d'ou une liste en - -- retard d'une operation. Un nom inconnu est simplement saute ; il ne - -- coute qu'une ligne de table. + -- L'ORDRE RETENU NE GARDE QU'UNE FOIS CHAQUE NOM. + -- + -- Il finissait par en tenir plusieurs copies : un nom que le client ne + -- publie pas a cet instant est saute par la premiere boucle, et la + -- seconde le rajoute des qu'il reparait. Quelques operations suffisaient + -- a obtenir "aab, aab, aze, aab, azq, zzzaq, aab". Chaque copie prenait + -- un rang, l'ensemble se posait quatre fois, et la carte finissait a un + -- rang au-dela du nombre d'ensembles -- donc masquee, liste vide. + -- + -- ET IL SE NETTOIE, mais SEULEMENT quand le client publie quelque chose. + -- L'elaguer sans condition etait la faute d'avant : entre un + -- enregistrement et son evenement, le client ne rend AUCUN ensemble, et + -- la table se vidait pour de bon. A zero ensemble publie, on ne touche + -- a rien. local ordre = ordreRetenu() - local liste = {} + local liste, retenu = {}, {} for _, nom in ipairs(ordre) do - if parNom[nom] then + if parNom[nom] and not dans[nom] then liste[#liste + 1] = parNom[nom] dans[nom] = true + retenu[#retenu + 1] = nom end end for index = 1, total do local nom = GetEquipmentSetInfo(index) if nom and not dans[nom] then liste[#liste + 1] = index - ordre[#ordre + 1] = nom + dans[nom] = true + retenu[#retenu + 1] = nom + end + end + + if total > 0 then + for rang = #ordre, 1, -1 do + ordre[rang] = nil + end + for rang, nom in ipairs(retenu) do + ordre[rang] = nom end end return liste @@ -554,9 +573,12 @@ local function poserCartes() for position = 1, #dialogue.buttons do local bouton = parRang[position] - local index = position + -- Le rang n'est PAS l'indice du client : c'est ordre[position] qui + -- le donne. Confondre les deux masquait toute carte posee a un rang + -- superieur au nombre d'ensembles. + local index = ordre[position] local rang = position - decalage - if bouton and index <= total and rang >= 1 and rang <= place then + if bouton and index and index <= total and rang >= 1 and rang <= place then bouton:ClearAllPoints() if precedent then bouton:SetPoint("TOPLEFT", precedent, "BOTTOMLEFT", 0, 0) @@ -792,13 +814,29 @@ attenteEdition:Hide() local function remplacerDansOrdre(ancien, nouveau) local ordre = ordreRetenu() + local place for rang, connu in ipairs(ordre) do if connu == ancien then ordre[rang] = nouveau - return + place = rang + break + end + end + if not place then + place = #ordre + 1 + ordre[place] = nouveau + end + -- Le nouveau nom pouvait deja figurer ailleurs -- un ancien renommage, + -- un ensemble efface puis recree. Deux copies, et il prendrait deux + -- rangs. On n'en garde que celle qu'on vient de poser. + for rang = #ordre, 1, -1 do + if rang ~= place and ordre[rang] == nouveau then + table.remove(ordre, rang) + if rang < place then + place = place - 1 + end end end - ordre[#ordre + 1] = nouveau end local function terminerEdition() diff --git a/docs/AMELIORATIONS.md b/docs/AMELIORATIONS.md index 7697e69..b5aa37c 100644 --- a/docs/AMELIORATIONS.md +++ b/docs/AMELIORATIONS.md @@ -743,6 +743,8 @@ toujours le client qui tient la liste, la sélection et les infobulles. | **C'est asynchrone** | `UseEquipmentSet` rend la main avant la fin ; c'est `EQUIPMENT_SWAP_FINISHED(terminé, nom)` qui l'annonce. Si l'ensemble est déjà porté, rien n'est à équiper et on enchaîne. Au bout de 10 s sans réponse — combat, pièce verrouillée — l'opération est abandonnée plutôt que laissée en suspens. | | **La liste du client se met à jour après coup, et l'événement ne suffit pas** | `GetNumEquipmentSets` et `GetEquipmentSetInfo` ne rendent pas le nouvel état dans la foulée d'un enregistrement ni même à l'instant où `EQUIPMENT_SETS_CHANGED` arrive. La liste se reposait donc sur l'état d'**avant** et restait en retard d'une opération : renommer AAA en AAB ne montrait plus rien, créer AZE faisait apparaître AAB, supprimer AAB faisait apparaître AZE. Elle se repose désormais à l'**image suivante** (`ForeverUIEquipmentRecheck`), comme la hauteur des sacs. | | **L'ordre ne s'élague pas pendant l'affichage** | Il le faisait, et c'était la seconde moitié du défaut : quand le client ne rend momentanément **aucun** ensemble, l'élagage vidait la table d'ordre pour de bon, et les noms y revenaient ensuite un par un. Un nom inconnu est simplement sauté. | +| **L'ordre retenu tenait plusieurs fois le même nom** | C'était la vraie cause, et c'est le témoin `/fui sets` qui l'a montrée : pour **un** ensemble publié par le client, l'ordre retenu tenait sept entrées — `aab, aab, aze, aab, azq, zzzaq, aab`. Un nom que le client ne publie pas à cet instant est sauté par la première boucle, et la seconde le rajoute dès qu'il reparaît ; quelques renommages suffisaient. Chaque copie prenant un rang, l'ensemble se posait quatre fois. Un nom n'est désormais placé qu'**une** fois, `remplacerDansOrdre` retire les copies du nom qu'il vient de poser, et l'ordre se nettoie des noms effacés — mais **seulement quand le client publie au moins un ensemble**, sinon on retombe sur la table vidée d'avant. | +| **Le rang n'est pas l'indice du client** | La boucle d'affichage testait `index <= total` avec `index = position`, le rang dans *notre* ordre. Avec l'ordre dédoublonné le cas ne se voyait pas ; avec quatre copies, la carte finissait au rang 4 pour un total de 1 et se masquait — `carte 1 : visible=nil`. Le vrai indice se lit dans `ordre[position]`. | | **Une image ne suffisait pas non plus : la liste ne s'attend plus, elle se surveille** | Le rattrapage d'une image a encore manqué la publication du client : en jeu, renommer AAA en AAB laissait la liste **vide jusqu'à l'opération suivante**. Les ensembles vivent côté serveur, et aucun moment ne peut être tenu pour sûr — ni le retour de `SaveEquipmentSet`, ni l'instant de `EQUIPMENT_SETS_CHANGED`, ni l'image d'après. On a donc cessé de parier sur un délai : le panneau compare toutes les **0,2 s** ce que le client rend (nombre d'ensembles, noms, icônes) à ce qui est affiché, et repose les cartes dès que cela diffère. Quand rien ne change, rien n'est reposé — le banc le vérifie : 0 pose sur 10 contrôles. Le contrôle ne tourne que panneau ouvert, c'est-à-dire exactement quand la liste se regarde. | | **Le banc ne pouvait pas voir une publication tardive** | Sa séquence publiait toujours au moment de l'événement. Il rejoue maintenant le pire cas : l'événement arrive **avant** que le client ait refait sa liste, le rattrapage passe dans le vide, et plus rien n'est annoncé ensuite — seul le battement du panneau répare. | | **Un témoin pour ne plus deviner** | `/fui sets` rapporte, depuis le jeu, les trois choses qui décident de l'affichage et qui peuvent se contredire : ce que le client publie (`GetNumEquipmentSets` et chaque `GetEquipmentSetInfo`), l'ordre retenu dans `ForeverUIDB`, l'ordre posé, puis pour chaque carte son nom, sa visibilité, son ancrage et sa coche — avec le défilement et le nombre de cartes qui tiennent. | diff --git a/tools/test_addon.py b/tools/test_addon.py index 3c021a6..6923705 100644 --- a/tools/test_addon.py +++ b/tools/test_addon.py @@ -3082,6 +3082,30 @@ def main(): print(" liste inchangee : %d pose(s) sur 10 controles" % poses) assert poses == 0, "liste inchangee, rien a reposer" + # L ETAT CORROMPU RAPPORTE PAR /fui sets, rejoue tel quel : l ordre + # retenu tenait sept entrees pour UN ensemble publie -- "aab" quatre + # fois, plus trois noms effaces. L ensemble se posait donc quatre fois, + # la carte finissait au rang 4 pour un total de 1, et se masquait. + lua.execute('ENSEMBLES = { { nom = "aab", icone = "icone-aab", porte = false } }') + lua.execute("publierEnsembles()") + lua.execute('ForeverUIDB.ordreEnsembles = ' + '{ "aab", "aab", "aze", "aab", "azq", "zzzaq", "aab" }') + lua.execute('GearManagerDialog_Update()') + g.ForeverUI.EquipmentSetsLayout() + pose = list(g.ForeverUI.EquipmentSetsOrder().values()) + print(" ordre corrompu : pose %s | retenu %s | visibles %s" % ( + pose, list(g.ForeverUIDB.ordreEnsembles.values()), visiblesMaintenant())) + assert pose == [1], "un ensemble publie ne se pose qu une fois" + assert visiblesMaintenant() == ["aab"], "et sa carte doit etre visible" + assert list(g.ForeverUIDB.ordreEnsembles.values()) == ["aab"], "l ordre retenu se nettoie des doublons et des noms effaces" + + # A ZERO ENSEMBLE PUBLIE, en revanche, l ordre ne doit PAS etre vide : + # c est l etat momentane entre un enregistrement et son evenement. + lua.execute('ENSEMBLES = {} publierEnsembles()') + g.ForeverUI.EquipmentSetsOrder() + print(" client muet : retenu %s" % list(g.ForeverUIDB.ordreEnsembles.values())) + assert list(g.ForeverUIDB.ordreEnsembles.values()) == ["aab"], "le client ne publie rien : on ne touche pas a l ordre" + # LE TEMOIN ne doit rien casser, et dire ce qu il voit. g.ForeverUI.EquipmentSetsDebug() print(" temoin /fui sets : rapport rendu sans erreur")