103 interfaces, chacune indique
« vérifiée ou non, à quelle vitesse, comment ça marche dessous »

État complet de toute la carte (WorldState) : .units .players .items .clock .me ; des appels répétés dans un délai de max_age secondes renvoient la même copie. ⚠ Les ouvriers entrés dans une mine d'or ne figurent pas dans la liste ; par défaut toute la carte est visible (en modèle lockstep, tout est présent en local), seul Game(fair=True) filtre selon le champ de vision.

Mécanisme Bloc du monde W3P Local\War3World_<pid> (poussé par le runtime toutes les 50 ms, seqlock)

Unités ennemies (ou creeps avec 'creep', ou unités d'un numéro de joueur) vues pour la dernière fois : [(état de l'unité à ce moment-là, horloge de jeu à ce moment-là, secondes écoulées depuis)], les plus récentes en premier. Une unité vue en train de mourir est retirée de la liste. En mode équitable comme en mode normal, l'enregistrement se fait selon « ce que votre camp voit en ce moment » — c'est la carte que le joueur a en tête : les forces repérées, la dernière position connue du héros adverse, le moment où l'adversaire a pris son expansion. max_age ne garde que les unités vues dans ce nombre de secondes de jeu.

Mécanisme visibleTo de l'instantané poussé (à chaque rafraîchissement de l'instantané, les unités ennemies/creeps visibles sont enregistrées)

Table du terrain de la partie, MapInfo : .walkable(x,y) .buildable(x,y) .at(x,y) .bounds (zone jouable) .starts (points de départ) .cells (bit0 non praticable, bit1 non constructible). Le calcul prend quelques secondes après le début de la partie ; tant qu'il n'est pas terminé, renvoie None. Les arbres n'y figurent pas (utilisez trees()).

Mécanisme Bloc de carte W3P Local\War3Map_<pid> (calculé par lots par le runtime après le début de la partie, IsTerrainPathable déplacement/construction)

Votre numéro de joueur (0~11).

Mécanisme En-tête du bloc du monde

{'gold','lumber','food_used','food_cap','gold_gathered','lumber_gathered'} ; player vaut par défaut votre joueur, et n'importe quel joueur peut être lu. Renvoie None si la lecture échoue : ne le confondez pas avec 0.

Mécanisme players[16] du bloc du monde

Les 16 emplacements de joueur : Player(id, gold, lumber, food_used, food_cap, gold_gathered, lumber_gathered, race, known).

Mécanisme players[16] du bloc du monde

Filtre les unités par propriétaire / type. owner : 'me' / 'enemy' / 'creep' / 'all' / numéro de joueur. types : ensemble de codes à quatre caractères.

Mécanisme units[] du bloc du monde

Trouve une unité par sa paire de handles (lo, hi) (la cible d'ordre, la cible de tâche et les événements fournissent tous des paires de handles).

Mécanisme by_handle du bloc du monde

Indique s'il s'agit d'un bâtiment (tours comprises). Déterminé par une vitesse de déplacement nulle dans la table des unités ; l'emprise au sol du hall mort-vivant vaut 0, ne vous fiez donc pas à l'emprise.

Mécanisme Instantané + units.json (spd==0 = bâtiment)

Vos ouvriers (paysans / péons / acolytes / feux follets).

Mécanisme Instantané poussé

Ouvriers sans travail : ni ordre ni tâche (ceux à qui vous venez de donner du travail pendant ce tick ne comptent pas). ⚠ Redonner un ordre de récolte à un ouvrier qui a une tâche interrompt son cycle de récolte (revenu nul).

Mécanisme Instantané poussé (emplacement d'ordre + emplacement de tâche)

Vos héros vivants (les héros morts sont dans la liste de résurrection de l'autel, voir revive).

Mécanisme Instantané poussé

Vos unités de combat : ni ouvriers ni bâtiments.

Mécanisme Instantané poussé + units.json

Vos bâtiments (tours et fondations en construction comprises) ; types permet de n'en garder que certains, par exemple {'hbar'}.

Mécanisme Instantané poussé

Indique si cet ouvrier est en train de construire (ou se rend sur un chantier / aide à réparer ; y compris s'il vient d'y être envoyé pendant ce tick). Ignorez-le quand vous choisissez un constructeur, sinon le chantier précédent s'arrête.

Mécanisme Instantané poussé (ordre = code à quatre caractères d'un bâtiment, ou ordre de construction / de réparation)

Ce bâtiment n'est pas terminé (PV incomplets). ⚠ Un bâtiment endommagé n'a pas non plus tous ses PV — suffisant en début de partie, mais une fois les combats engagés, tenez aussi compte du temps.

Mécanisme Instantané poussé (les PV des fondations montent d'une valeur très basse jusqu'au maximum)

Les mines d'or de la carte. ⚠ La mine d'or enchevêtrée des Elfes de la nuit et la mine neutre ont chacune une unité aux mêmes coordonnées ; envoyez la récolte vers la vôtre.

Mécanisme Instantané poussé (ngol/egol/ugol)

Unités des joueurs ennemis (creeps exclus). fighters_only : exclut les ouvriers et les bâtiments.

Mécanisme Instantané poussé

Creeps (neutres hostiles). ⚠ La nuit, la vision diminue ; une fois les camps éloignés passés dans le brouillard, les commandes sur cible qui les visent sont rejetées (code de motif 1001).

Mécanisme Instantané poussé (owner 12 = neutre hostile)

{'hp','hp_max','mana','mana_max'} (flottants, valeurs brutes du moteur). Pour u, une unité issue de l'instantané suffit (elle est remplacée par la copie la plus récente).

Mécanisme hp/hpMax/mana/manaMax des unités du bloc du monde

{'level','xp','skill_points'}.

Mécanisme level/xp/skillPoints des unités du bloc du monde

[{code, level, cooldown, flags}] ; les buffs sont dans buffs(u). Disponible uniquement pour les unités « avec détails » (héros > unités des joueurs > creeps, 256 au maximum).

Mécanisme Détails du bloc du monde : capacités (code/niveau/drapeaux/recharge restante)

Codes des buffs portés par l'unité (par exemple 'BHds' Bouclier divin, 'Bslo' Ralentissement). L'effet de chaque code est décrit dans data/game/buffs.json.

Mécanisme Détails du bloc du monde : objets de capacité dont le code commence par B

Secondes de recharge restantes pour cette capacité (secondes de jeu) ; 0 = utilisable ; renvoie None si l'unité n'a pas cette capacité (ou n'a pas de détails).

Mécanisme Détails du bloc du monde : recharge restante des capacités (minuteur de capacité)

Codes à quatre caractères des 6 emplacements d'objets (None pour un emplacement vide) ; renvoie None si l'unité n'a pas d'inventaire.

Mécanisme Détails du bloc du monde : 6 emplacements d'inventaire

{'order','target','x','y'} : l'ordre que l'unité est en train d'exécuter (order vaut 0x000D00xx ou le code à quatre caractères d'un bâtiment, 0 = inactive). target est une paire de handles ; convertissez-la en unité avec g.unit(target).

Mécanisme order / cible d'ordre / point cible d'ordre des unités du bloc du monde

L'unité que cette unité **attaque ou poursuit réellement** (None s'il n'y en a pas). ⚠ Après un ordre d'attaque, l'emplacement d'ordre se vide rapidement et l'attaque est portée par la tâche — pour savoir « qui elle attaque », utilisez cette méthode, pas current_order.

Mécanisme Cible de tâche des unités du bloc du monde

Horloge de jeu du moteur (en secondes de jeu, 0 pendant le chargement). À vitesse accélérée, elle avance plus vite que le temps réel.

Mécanisme clockMs de l'en-tête du bloc du monde (horloge de jeu du moteur)

Ce que produit ce bâtiment : Production(kind, queue, duration, elapsed, blocked, progress, remaining…), ou None s'il ne produit rien. kind 'queue' (entraînement/recherche/héros ; queue compte 7 emplacements au maximum, [0] est en cours) / 'construction' (en construction) / 'upgrade' (amélioration du hall/d'une tour) ; blocked = en file mais pas démarré (le plus souvent nourriture insuffisante — il est temps de construire une ferme) ; progress 0..1. Les bâtiments adverses sont aussi consultables (en mode équitable, uniquement ceux qui sont visibles).

Mécanisme Table de production du bloc du monde (objets de capacité Aque/ABnP/AUnP + temps écoulé suivi par le runtime ; écart mesuré < 0.2 seconde de jeu)

Codes à quatre caractères de la file d'entraînement/recherche ([0] en cours) ; [] si le bâtiment est inactif ou n'est pas un bâtiment de production.

Mécanisme Table de production du bloc du monde

Toutes les productions en cours [(bâtiment, Production)]. owner comme pour units() : 'me' / 'enemy' / numéro de joueur / 'all'. Usage pro : voir quelles unités l'adversaire entraîne, quelles technologies il recherche, quand il passe de tier (quand vous repérez ses bâtiments).

Mécanisme Table de production du bloc du monde

Distance à parcourir par une unité terrestre de a à b (a et b : unités ou (x,y)) ; None si inaccessible. Sur les cartes à îles, utilisez-la pour savoir « si ce camp de creeps / cette expansion est accessible par voie terrestre » ; elle est plus fiable que la distance à vol d'oiseau (elle contourne forêts, falaises et bâtiments). Précision d'une case de 128 ; un passage plus étroit qu'une case est considéré comme bloqué.

Mécanisme Bloc de carte (IsTerrainPathable du moteur) + bloc des arbres + emprise des bâtiments, A* côté SDK (cases de 128)

Accessible ou non par voie terrestre (None si le bloc de carte n'est pas encore calculé).

Mécanisme Idem

Points d'inflexion du chemin [(x,y)...] (le dernier point est b) ; avec path(units, liste de points), faites suivre ce chemin à vos troupes (contourner les tours, emprunter des chemins détournés).

Mécanisme Idem

Palier d'entretien : {'level': 'none'/'low'/'high', 'income': 1.0/0.7/0.4, 'next_at': nourriture du palier suivant (aucun = None)}. Règle bien connue des pros : restez à 50 de nourriture pendant le passage au tier 3 et les améliorations d'attaque/armure, et ne montez à 80 qu'avant la bataille décisive.

Mécanisme Règle fixe de la 1.27 : de 0 à 50 de nourriture, pas d'entretien ; de 51 à 80, revenu ×0.7 ; de 81 à 100, ×0.4

Expérience qu'il manque au héros pour atteindre le niveau suivant (niveau 10 = 0).

Mécanisme level/xp du bloc du monde + formule NeedHeroXP de MiscGame

Regroupe les creeps (visibles) en camps : [{'x','y','units','level','hp','max_level'}], du plus proche au plus éloigné de votre base principale. level = niveau total du camp (la mesure courante de la difficulté du creeping), hp = PV totaux. À combiner avec time_to_kill / path_distance pour choisir un camp.

Mécanisme Instantané poussé (creeps regroupés dans un rayon de 600) + niveaux de units.json

Ce qu'est un code de buff : {'ability','effect','dur','hero_dur','targets'} (ex. 'Bslo' -> Ralentissement). Si un code a plusieurs lignes, la première est renvoyée.

Mécanisme data/game/buffs.json (BuffID de AbilityData.slk -> capacité/effet/durée)

Caractéristiques de combat de l'unité, combat.UnitStats : PV/mana max, armure (améliorations d'attaque/armure et agilité du héros comprises), type d'armure, vitesse de déplacement, vision de jour/de nuit, armes (ce qu'elles peuvent toucher, portée, intervalle d'attaque, plage de dégâts, type d'attaque, dégâts de zone). u : une unité (la technologie de son propriétaire et le niveau du héros sont appliqués automatiquement) ou un code à quatre caractères (player vaut par défaut votre joueur). À combiner avec .dps_vs(adversaire) / .hits_to_kill(adversaire) / combat.time_to_kill(groupe, adversaire). ⚠ Objets, auras et buffs non pris en compte.

Mécanisme Tables de données (UnitBalance/UnitWeapons/UpgradeData/MiscGame) + niveaux de technologie en temps réel + niveau du héros

Secondes de jeu nécessaires à ce groupe d'unités pour tuer target ensemble (selon les PV actuels de target ; contres, armure et améliorations d'attaque/armure pris en compte ; déplacements, dégâts de zone et soins ignorés). Usage pro : en tir concentré, frappez d'abord l'unité « qui meurt le plus vite » (time_to_kill minimal), pas la plus proche. Impossible à atteindre = None.

Mécanisme stats() + PV en temps réel

Heure du jour dans le jeu (en heures, 0~24). La partie commence à 8 h du matin ; une journée complète = 480 secondes de jeu (240 s de jour et 240 s de nuit, mises à l'échelle par la vitesse du cycle jour/nuit). Renvoie None si la lecture échoue (ancien runtime / hors partie).

Mécanisme Zone d'extension du bloc du monde : GetFloatGameState(GAME_STATE_TIME_OF_DAY)

Indique s'il fait nuit (18:00~6:00). Usage pro : la nuit, les creeps dorment (en frappant le premier, vous n'êtes pas encerclé), la vision de toutes les unités diminue (bon moment pour une attaque surprise), et les sentinelles/unités des Elfes de la nuit deviennent invisibles près des arbres. Renvoie None si la lecture échoue.

Mécanisme Zone d'extension du bloc du monde (jour de 6 h à 18 h)

Secondes de jeu restantes avant qu'il soit hour heures dans le jeu (par exemple seconds_until(18) = temps restant avant la tombée de la nuit, pour planifier un creeping nocturne).

Mécanisme Zone d'extension du bloc du monde + journée de 480 secondes (mesuré : 20 secondes de jeu par heure)

Objets au sol [Item(addr, handle_lo, handle_hi, type, x, y, life)]. Ramasser ou utiliser un objet émet l'événement item.removed.

Mécanisme items[] du bloc du monde (uniquement les objets au sol : handle du porteur entièrement à FF)

Arbres vivants (ceux dont le targType dans DestructableData contient tree) ; si (x,y) est fourni, triés du plus proche au plus éloigné, limit arbres au maximum. Chaque arbre est un Tree(addr, handle_lo, handle_hi, type, x, y, life), que vous pouvez passer directement à gather pour couper du bois.

Mécanisme Bloc des arbres Local\War3Trees_<pid> (rafraîchi toutes les 2 secondes)

Ce qui s'est passé depuis le dernier appel : unit.appeared / unit.died / unit.removed / unit.damaged / order.changed / hero.levelup / owner.changed / item.appeared / item.removed / game.started (obtenus en comparant les publications, précision = période de publication de 50 ms), ainsi que les événements de niveau moteur damage / killed (le runtime les enregistre sur le thread du jeu au moment où ils se produisent : il y en a un pour **chaque coup**) : damage : handle = l'unité touchée, .source_addr = celle qui frappe (convertissez-la en unité avec snapshot().unit_by_addr), .value = PV réellement perdus, .raw_damage = dégâts avant armure, .attack_type (normal/pierce/siege/magic/chaos/hero/spell), .damage_type killed : ce coup a tué l'unité, .source_addr = le tueur ainsi que production.done, obtenu par le suivi de la table de production par le runtime (précision = période de publication) : unité = le bâtiment, .done_code = code à quatre caractères de ce qui est terminé, .done_kind = 'training' (unités/héros/résurrection) / 'research' / 'construction' (bâtiment terminé) / 'upgrade' (passage de tier / amélioration de tour), .value = secondes de jeu nécessaires Ajouts du 09-25 : spell.cast : unité = le lanceur, .spell code à quatre caractères du sort, b niveau, value recharge en secondes, x,y point d'incantation (détecté quand la recharge du sort commence, précision = période de publication) player.left : .player numéro du joueur parti / retiré après sa défaite ; game.ended : on quitte la partie selection.changed : la sélection du joueur local a changé (g.selection() pour obtenir les unités) message : une ligne d'un cadre de messages à l'écran (indication du jeu, chat, système) : .text texte intégral, .frame numéro du cadre de messages, .chat = {'channel', 'sender', 'text'} (quand c'est du chat ; c'est là qu'on lit ce que le joueur tape dans la boîte de chat) ui.click / ui.hover / hotkey / mouse.world : interface et entrées (g.ui), .key est la key du canevas / la syntaxe du raccourci Chaque entrée est un Event(seq, kind, clock, addr, handle, type, owner, a, b, x, y, value, extra). En mode équitable (fair=True), seuls sont fournis : les événements de vos propres unités, ceux des unités visibles en ce moment (ou encore visibles dans la dernière seconde), les dégâts subis ou infligés par votre camp, ainsi que les événements locaux d'interface / de messages / de partie.

Mécanisme Anneau d'événements Local\War3Events_<pid> (comparaison des publications + événements de dégâts capturés par le runtime)

Unités actuellement sélectionnées par le joueur local (l'unité principale en premier ; 12 au maximum). Tout changement de sélection émet l'événement selection.changed.

Mécanisme Zone d'extension du bloc du monde W3P, selAddrs (à chaque publication, le runtime y joint la sélection du joueur local)

Messages apparus dans les cadres de messages à l'écran depuis le dernier appel : [{'text', 'frame', 'repeat', 'seq', 'game_ms'}]. Les indications du jeu (« Il vous faut plus de fermes », « Impossible de construire ici »), le chat et les messages système s'y trouvent tous ; frame indique de quel cadre de messages il s'agit. Ce sont les mêmes messages que les événements message du flux d'événements (chacun avec son propre curseur).

Mécanisme Mémoire partagée Local\War3Msgs_<pid> (messages à l'écran capturés par le runtime)

Niveau de recherche / nombre de bâtiments terminés (les chaînes d'amélioration comptent : un château compte aussi comme htow). player vaut par défaut votre joueur ; n'importe quel joueur peut être interrogé.

Mécanisme Requête W3P q_tech (décompte des technologies du joueur par le moteur)

Verdict de faisabilité du moteur : 0/220 possible ; 3 nourriture, 8 or manquant, 9 bois manquant, 32 file pleine, 183 prérequis manquant, 185 autel en cours de résurrection, 221 élément absent/en construction. ⚠ Vaut toujours 221 pour un ouvrier qui construit un bâtiment : inutilisable pour valider un emplacement (utilisez build_near).

Mécanisme Requête W3P q_feasible (vérification de faisabilité du moteur)

Pose de nombreuses questions can_do d'un coup : pairs = [(unité, code à quatre caractères), ...], renvoie la liste des codes de verdict dans le même ordre (None pour une question sans réponse). Pour planifier ce qu'un tick doit construire/entraîner, interrogez d'abord tout en bloc : c'est N fois plus rapide que des can_do un par un (cerveau de référence, 09-23 : planification des constructions 76 -> 25 ms).

Mécanisme Requête W3P q_feasible × N, soumise en un lot

Interroge d'un coup de nombreux décomptes de technologies/bâtiments : {code à quatre caractères: nombre ou None}.

Mécanisme Requête W3P q_tech × N, soumise en un lot

Indique si ce point est visible par votre camp en ce moment (ni dans le brouillard ni dans le masque noir). Un bot en mode équitable ne devrait utiliser que les ennemis visibles.

Mécanisme Requête W3P q_visible (visible / brouillard / masque noir)

Or restant dans la mine d'or.

Mécanisme Requête W3P q_mine_gold (or restant dans la mine selon le moteur)

Le capitaine de l'IA de l'ordinateur : où il emmène ses troupes (vous savez avant même son départ quelle partie de votre base il va attaquer). Fonctionne uniquement contre un adversaire ordinateur ; renvoie None si l'unité ne suit pas de capitaine.

Mécanisme Requête W3P q_captain (le capitaine de l'ordinateur que suivent les unités ennemies)

L'ordre actuel de l'unité, **y compris celui que vous venez de donner pendant ce tick** (tant que l'instantané n'a pas rattrapé, le nouvel ordre du reçu est utilisé). ⚠ Constaté en partie réelle le 09-23 : hello_bot venait d'envoyer un paysan construire une ferme ; au même tick, rush_bot le voyait « inactif » dans l'instantané et l'envoyait construire une caserne, si bien que la ferme était abandonnée à mi-chemin, encore et encore. Pour choisir des unités « inactives / qui ne construisent pas », utilisez cette méthode plutôt que u.order.

Mécanisme Ordre de l'instantané + commandes de ce processus qui viennent d'être acceptées (reçus)

Indique si l'or et le bois actuels suffisent pour acheter code (unité, bâtiment ; selon les prix de units.json). Tout ce qui est absent de la table des prix est considéré comme abordable. ⚠ Pour les codes de passage de tier, la table contient le prix cumulé : le résultat est donc prudent ; c'est le reçu du moteur qui fait foi.

Mécanisme Ressources de votre camp dans l'instantané poussé + prix de units.json

Données de la carte en cours (openwar3.mapdata.MapData) : name_of('HC07') pour le nom d'une unité / d'un objet / d'une capacité personnalisés, hero_names, tooltip. Dans les cartes RPG, la plupart des unités sont créées par la carte elle-même et absentes de la table de noms intégrée ; si la partie n'a pas été lancée par le lanceur (fichier de carte introuvable), renvoie None.

Mécanisme Fichier de carte (chemin --map du lanceur) : w3u/w3t/w3a + wts ; pour une carte protégée, lit les TXT contenus dans la carte

Regroupe les commandes d'un tick en un lot : with g.batch() as b: g.attack(archers, target) # renvoie Pending, qui ne devient un reçu qu'à la fin du bloc g.move(wounded, *home) g.cast(hero, "thunderclap") print(b.sent, b.wait_ms, [r.reason for r in b.receipts]) Envoyée seule, chaque commande attend un passage du thread du jeu (environ 10 ms) ; un lot n'attend qu'une fois — c'est ainsi que le cerveau de référence (09-23) est passé de 48 -> 26 ms par cycle. * L'arbitrage s'applique toujours commande par commande (une unité réservée reçoit immédiatement un reçu held et n'entre pas dans le lot) ; * Dans le bloc, les commandes renvoient Pending : lire son .ok avant la fin du bloc lève une erreur (le reçu n'existe pas encore) ; après la fin du bloc, il s'utilise comme un Receipt ; * Une exception levée dans le bloc = tout le lot est annulé (status 97 cancelled), et les unités réservées sont libérées ; * Les requêtes (can_do / tech / visible …), build_near et buy n'entrent pas dans le lot et restent posées sur-le-champ — leur résultat est nécessaire immédiatement ; pour poser de nombreuses questions d'un coup, utilisez can_do_many / tech_many ; * Un with g.batch() imbriqué est fusionné dans le lot le plus externe ; au-delà de 16 commandes, le runtime découpe automatiquement en plusieurs segments (une attente par segment).

Mécanisme Les commandes du bloc sont accumulées en un lot, soumis en une fois à la fin du bloc (exécuté dans la même frame, une seule attente du thread du jeu)

Se rend en (x,y) sans attaquer en chemin (à utiliser pour battre en retraite). Accepte une unité ou une liste (l'ordre est donné dans la même frame). queue='after' : termine d'abord la tâche en cours (inséré après l'ordre actuel). values[0] du reçu = nombre d'ordres en file pour cette unité après l'ordre (celui en cours compris).

Mécanisme W3P point : move (bit extra = mode de mise en file)

Attaque-déplacement (A + clic au sol) : attaque les ennemis rencontrés en chemin. queue comme pour move.

Mécanisme W3P point : attack sur un point

Attaque target. Utilise par défaut le clic droit (sur un ennemi = attaquer celui-ci ; mesuré le 09-23 : la cible d'ordre et la cible de tâche sont toutes deux cette unité). ⚠ La cible doit être dans le champ de vision ; une cible invisible est rejetée (code de motif 1001). force=True utilise l'ordre d'attaque 0x0F (nécessaire pour attaquer une unité alliée / un petit animal neutre) — mesuré : il ne fait que changer l'ordre en attaque sans mémoriser la cible, et l'unité part attaquer d'autres ennemis à proximité ; ne l'utilisez pas pour une cible précise.

Mécanisme W3P target : commande sur cible (clic droit smart)

Arrête tout (ordre 0x000D0004) et vide aussi les ordres en file.

Mécanisme W3P immediate : stop

Tenir la position (ne poursuit pas, n'attaque que ce qui est à portée).

Mécanisme W3P immediate : holdposition

Patrouille entre la position actuelle et (x,y).

Mécanisme W3P point : patrol

Attaque au sol : l'artillerie tire sur une zone (unités invisibles, ennemis derrière des arbres, blocage d'un passage). Seules les unités capables d'attaquer le sol acceptent l'ordre.

Mécanisme W3P point : attackground (unités de siège / mortiers / catapultes)

Annuler : le dernier emplacement de la file d'entraînement/recherche (remboursé), un bâtiment en construction (75 % remboursés), un hall en cours d'amélioration.

Mécanisme W3P immediate : cancel

Parcourt une suite de points dans l'ordre (points enchaînés avec Shift : points de passage, contournement de tours, itinéraire d'éclaireur). attack=True fait de chaque segment une attaque-déplacement. Soumis en une fois ; un reçu par point (dans l'ordre de points).

Mécanisme Un lot : le premier segment s'exécute immédiatement, les autres sont insérés en ordre inverse avec queue='after' (le moteur ne sait insérer qu'après l'ordre en cours)

Récolte de l'or / coupe du bois (target est une mine d'or ou un arbre de trees()). ⚠ N'affectez que des ouvriers inactifs (idle_workers) : redonner l'ordre à un ouvrier qui a une tâche interrompt son cycle de récolte. Usage pro : retourner à la mine après une construction = gather(worker, mine, queue='after') après build(...).

Mécanisme W3P target : harvest (mine d'or ou arbre)

Réparer / aider à construire (un chantier humain ou orc s'arrête si personne n'y travaille).

Mécanisme W3P target : repair

Ordonne à un ouvrier de construire code en (x,y) (coordonnées alignées sur une grille de 32). Reçu accepté = l'ordre de l'ouvrier est déjà ce bâtiment (ou l'ordre de démarrage du chantier) ; avec queue='after' = ajouté à la file d'ordres de l'ouvrier (values[0] du reçu = nombre en file). ⚠ Accepté ≠ construit : le moteur accepte aussi sur le moment un emplacement en pleine forêt, et l'ouvrier n'échoue qu'une fois sur place (mesuré le 09-23) ; si l'argent est dépensé ailleurs entre-temps, les fondations n'apparaissent pas non plus. Si vous ne savez pas où le bâtiment peut être placé, utilisez build_near (il suit le résultat et met sur liste noire les emplacements en échec). Pour en enchaîner plusieurs, utilisez build_queue.

Mécanisme W3P build : ordre de construction, confirmé en relisant l'ordre de l'ouvrier dans la même frame

Un ouvrier construit plusieurs bâtiments d'affilée (construction enchaînée avec Shift) : plan = [(code à quatre caractères, x, y), ...]. Soumis en une fois ; reçus dans l'ordre de plan. ⚠ L'argent n'est prélevé qu'au début de chaque construction (pas lors de la mise en file) — avec 3 bâtiments en file mais de l'argent pour un seul, les deux suivants échouent quand l'ouvrier arrive sur place.

Mécanisme Un lot : le premier immédiatement, les autres en ordre inverse avec queue='after'

Cherche autour de (x,y), du plus proche au plus éloigné, un emplacement libre pour construire code. **Non bloquant**, peut être appelé à chaque tick : * une construction de ce type est encore en cours (l'ouvrier est en chemin) -> renvoie cet emplacement, sans redonner l'ordre ; * la précédente a réussi (les fondations sont apparues) -> cherche au besoin un nouvel emplacement ; * la précédente a échoué (l'ouvrier a découvert sur place que le bâtiment ne pouvait pas être posé, le moteur a retiré l'ordre, aucune fondation) -> cet emplacement est mis sur liste noire pendant 45 secondes, on passe au suivant ; * argent insuffisant -> renvoie directement None (sans essayer ni mettre sur liste noire) ; si tous les emplacements ont été essayés, renvoie None. ⚠ Pourquoi ce suivi : constaté en partie réelle le 09-23, le moteur **accepte sur le moment** un emplacement en pleine forêt, et l'ouvrier n'échoue qu'une fois sur place (le reçu de la même frame ne permet pas de le détecter) ; de plus, la vérification d'emplacement du moteur renvoie toujours 221 pour un ouvrier qui construit, on ne peut donc pas « vérifier » avant de construire. Seul un emplacement manifestement occupé (le centre du hall) est rejeté sur-le-champ.

Mécanisme build point par point + suivi (fondations apparues = réussite ; ouvrier qui abandonne l'ordre sans fondations = emplacement mis sur liste noire)

Entraîne une unité / recherche une technologie / améliore le hall (passer de tier = donner au hall lui-même le code à quatre caractères du hall cible, par exemple 'hkee'). En cas de rejet, le reason du reçu en donne la raison (nourriture insuffisante, or manquant, bois manquant, file pleine, prérequis manquant…).

Mécanisme W3P immediate : code à quatre caractères, avec le code de motif de faisabilité en cas de rejet

Le héros apprend une compétence (code à quatre caractères, par exemple 'AHbz' Blizzard).

Mécanisme W3P learn : la compétence n'est considérée comme apprise que si les points de compétence diminuent

Lance un sort. spell est le nom d'ordre ('thunderbolt' Éclair de tempête, 'blizzard', 'holybolt' Lumière sacrée…, voir data/order-ids.txt) ou l'identifiant d'ordre. Avec target = sur une unité ; avec x,y = sur le sol ; sans l'un ni l'autre = sans cible (Coup de tonnerre, Bouclier divin, Invocation d'élémentaire d'eau). Un reçu accepté signifie seulement que le moteur a pris l'ordre ; pour savoir si le sort est vraiment parti, vérifiez que cooldown() indique une recharge ou que le buff apparaît dans buffs().

Mécanisme W3P target / point / immediate (choisi selon les paramètres)

Définit le point de ralliement (sur un point, ou sur une unité / une mine d'or).

Mécanisme W3P rally

Ressuscite à l'autel un héros mort (sans hero, le premier de la liste de résurrection). Causes de rejet fréquentes (indiquées dans le reason du reçu) : nourriture insuffisante (les héros consomment aussi de la nourriture), argent insuffisant, mort trop récente (résurrection possible environ 3 secondes de jeu après la mort), résurrection déjà en cours (le moteur libère cet emplacement sur-le-champ quand il accepte l'ordre).

Mécanisme W3P revive : liste des héros morts -> l'autel lance la résurrection sur le héros mort

Le héros va ramasser un objet au sol (item provient de items_on_ground). Une fois ramassé, l'objet apparaît dans l'inventaire et l'événement item.removed est émis pour le sol.

Mécanisme W3P target : clic droit sur l'objet

Utilise l'objet de l'emplacement slot (0~5) de l'inventaire ; peut prendre une unité cible ou un point cible. ⚠ Pour un objet utilisé sur un point (par exemple une tour d'ivoire), le moteur renvoie 0 même en cas de succès, et le reçu est toujours compté comme accepté — vérifiez si l'emplacement d'inventaire s'est vidé.

Mécanisme W3P use_item (par numéro d'emplacement)

Dépose en (x,y) l'objet de l'emplacement slot de l'inventaire (le héros s'y rend pour le poser).

Mécanisme W3P item_drop (calqué sur JASS UnitDropItemPoint : dropitem 0xD0021 sur un point + objet en cible immédiate)

Donne l'objet de l'emplacement slot à to (un autre héros / une unité ; le héros se déplace pour le remettre). Donner à une boutique = vendre (voir sell_item).

Mécanisme W3P item_drop (calqué sur JASS UnitDropItemTarget : dropitem sur une unité)

Vend à une boutique l'objet de l'emplacement slot de l'inventaire (le héros doit se rendre près de la boutique ; seuls les objets vendables sont acceptés, repris à moitié prix).

Mécanisme Comme give_item, avec la boutique pour cible (mesuré : un Staff of Sanctuary se vend 125 d'or)

Change un objet d'emplacement dans l'inventaire (de l'emplacement slot vers to_slot ; si les deux sont occupés, ils sont échangés). Utile pour organiser les raccourcis clavier.

Mécanisme W3P target : ordre 0xD0022+numéro d'emplacement, cible = l'objet (calqué sur JASS UnitDropItemSlot)

Achète un objet dans une boutique (pour le héros qui se tient à côté). S'il manque un prérequis technologique, le moteur renvoie 0 et ne prélève rien.

Mécanisme W3P buy : la boutique vend au héros voisin

Appel aux armes des Humains : les paysans deviennent des miliciens (l'hôtel de ville de tier 1 n'a pas cette capacité ; valable uniquement pour le donjon/château).

Mécanisme W3P immediate : townbellon/off

Interface et entrées (openwar3.ui.UI) : boutons et cartes de choix cliquables, raccourcis clavier, choix d'une position par un clic au sol, ce que pointe la souris. Le jeu ne reçoit pas le clic qui tombe sur un bouton ; uniquement de l'entrée locale + du dessin local, donc sûr même en multijoueur.

Mécanisme W3P 74 input_enable + mémoire partagée Local\War3Input_<pid> (le runtime reçoit les entrées de la fenêtre)

Vitesse de jeu (100 = vitesse normale).

Mécanisme Action 47 (25~800 %)

Met en pause / reprend la partie. Pendant la pause, l'horloge du moteur s'arrête, mais la voie rapide accepte toujours les ordres (la distribution d'événements continue de tourner).

Mécanisme W3P pause

Période de publication de l'état du monde (16~1000 millisecondes, 50 par défaut). Un relevé prend environ 0.5 ms, 33 ms ne pose donc aucun problème ; la valeur est partagée par toute la machine, la dernière écrite l'emporte.

Mécanisme requestedPeriodMs du bloc du monde

Affiche une bulle de dialogue au-dessus d'une unité (pour le streaming / le débogage, sans effet sur la partie). Renvoie False si la bulle n'est pas apparue ; la raison est dans g.last_say_error.

Mécanisme Action 56

Affiche une ligne dans la zone de messages en bas à gauche de l'écran de jeu (visible uniquement sur cette machine). Il faut attendre que le jeu ait lui-même affiché une notification (la DLL récupère la zone de messages à ce moment-là).

Mécanisme Action 45

Termine ce processus de jeu (farm.py --keep lance automatiquement la partie suivante d'après next_game.json).

Mécanisme Action 22

Canevas : dessine sur l'écran de jeu des zones de texte, panneaux, barres de progression, images, cercles au sol et itinéraires (openwar3.canvas.Canvas). Le runtime dessine lui-même, sans créer de handle de jeu ni modifier l'état du jeu — sûr même en multijoueur ; style libre (caractères chinois, coins arrondis, transparence).

Mécanisme W3P 73 canvas_enable + mémoire partagée Local\War3Canvas_<pid> (dessinée par le runtime à chaque frame, juste avant que le jeu ne dessine le curseur de la souris ; le curseur passe par-dessus)

Appuie une fois sur Espace sur l'écran de chargement « Appuyez sur une touche pour continuer ». Beaucoup de cartes RPG / scénarisées attendent une touche à la fin du chargement pour démarrer (mesuré le 09-24 sur WarChasers : sans appui, le jeu reste sur l'écran de chargement, horloge de jeu à 0, voie rapide jamais vidée). openwar3.run appuie de lui-même en attendant l'entrée en partie ; en général, inutile de l'appeler à la main.

Mécanisme PostMessage WM_KEYDOWN/UP de la touche Espace vers la fenêtre du jeu (sans lui donner le focus)

Appelle n'importe quelle native JASS par son nom : g.jass.CreateUnit(g.jass.Player(1), "Hpal", x, y, 270.0). Paramètres I/R/B/S/H convertis automatiquement (unités et objets se passent directement) ; en multijoueur, seules les natives en lecture seule peuvent être appelées. Détails dans openwar3/jass.py et docs/COMPANION_ZH.md.

Mécanisme W3P 70 jass (le runtime cherche la native par son nom dans sa table de 1291 natives)

Les 16 emplacements de joueur : controller (user = humain / computer / neutral…), state (empty / playing / left), human, me, ally (allié ou non de votre joueur). Sert dans les cartes RPG à trouver un emplacement libre pour le compagnon, et à savoir si la partie est en solo.

Mécanisme JASS GetPlayerController / GetPlayerSlotState / IsPlayerAlly

Crée une unité en (x,y) (player vaut par défaut le joueur local) et renvoie l'unité de l'instantané (après la publication suivante du monde, environ 50 ms) ; renvoie None si la création échoue. L'unité renvoyée a un attribut supplémentaire, jass_handle. ⚠ Uniquement en partie solo (en multijoueur, cela provoque une désynchronisation).

Mécanisme JASS CreateUnit + W3P 72 handle -> unité

Définit la relation d'alliance du joueur a envers b : allied = pas d'attaque mutuelle + demande d'aide mutuelle ; vision = vision partagée ; control = contrôle partagé des unités (b peut commander les unités de a) ; xp = expérience partagée. both=True règle les deux sens à la fois (control seulement de a -> b).

Mécanisme JASS SetPlayerAlliance

Change le nom d'un joueur (celui affiché dans le tableau des scores, le chat et le panneau des alliances). Sert à donner un nom au compagnon.

Mécanisme JASS SetPlayerName

Affiche une ligne de texte en bas à gauche de l'écran (le texte qu'utilisent les déclencheurs des cartes), par défaut pour le joueur local. Prend en charge les codes couleur |cffRRGGBB.

Mécanisme JASS DisplayTimedTextToPlayer

État de la connexion : pid, publication du monde (période, durée de collecte), compteurs de la voie rapide.

Mécanisme Bloc du monde + voie rapide + table des réservations

L'élément le plus proche de to (une unité ou (x,y)) ; renvoie None s'il n'y a aucun candidat.

Mécanisme Calcul pur