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) <noreply@anthropic.com>
This commit is contained in:
@@ -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()
|
||||
|
||||
@@ -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. |
|
||||
|
||||
@@ -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")
|
||||
|
||||
Reference in New Issue
Block a user