Compte, galaxie, joueurs et messages
Savoir qui vous êtes, regarder ce qu'il y a dans un système, reconnaître les autres joueurs, lire le classement, et écrire à quelqu'un.
Le compte
| Fonction | Rend | |
|---|---|---|
GetCachedPlayer() | 1 : votre fiche | PlayerID, PlayerName, Points, Rank, Total, HonourPoints. |
GetSlots() | 1 : vos emplacements de flotte | InUse, Total, ExpInUse, ExpTotal. |
ServerURL() | 2 : une adresse et une erreur | L'adresse de votre serveur, sans barre finale. Un ajout de Kepler. |
moi = GetCachedPlayer() // UNE cible : c'est une structure
Print(moi.PlayerName, moi.Points, "points, rang", moi.Rank, "sur", moi.Total)
slots = GetSlots() // UNE cible également
if slots.InUse >= slots.Total { Print("plus un emplacement libre") }
if slots.IsAllSlotsInUse(EXPEDITION) { Print("expéditions au complet") }
adresse, err = ServerURL() // DEUX cibles
Print(adresse) // https://s123-fr.ogame.gameforge.com
Rank est votre place au classement, Total le nombre de joueurs classés.
Une fiche de mémoire, pas une lecture. GetCachedPlayer ne demande rien au jeu, et c'est là son intérêt comme sa limite : elle rend ce que le robot a retenu de la dernière page d'accueil qu'il a ouverte, et d'aucune autre. Le pseudo et l'identifiant ne bougent pas, les points et le rang peuvent dater de plusieurs minutes.
Zéro veut dire « la lecture a échoué ». GetSlots interroge le jeu, mais ne rend qu'une valeur : elle n'a aucun moyen de vous signaler un échec. Sans session, ou si le jeu répond de travers, elle rend une structure entièrement à zéro et écrit la raison au journal du robot. C'est vrai aussi de GetCachedPlayer. Zéro emplacement libre sur zéro se lit « complet » par n'importe quel test, IsAllSlotsInUse comprise, si bien qu'aucun script n'ira lancer de flotte là-dessus. C'est voulu.
Échanger un code Gameforge
| Fonction | Rend | |
|---|---|---|
RedeemCode(code) | 1 : une erreur | Échange un code dans le lobby Gameforge pour le compte du robot, un don ou un sitting par exemple : le champ « Échanger un code Gameforge » des Paramètres. Un ajout de Kepler. |
err = RedeemCode("XXXX-XXXX-XXXX")
if err != nil {
LogWarn("échange du code :", err)
}
Tout passe par le proxy du robot, la connexion au lobby comprise quand il faut en ouvrir une, même avec « Connexion seulement » cochée. Les autres requêtes d'un script sortent alors en direct ; celle-ci, non. Un refus de Gameforge revient dans l'erreur, dit en clair comme le dit le lobby officiel, puis tel que Gameforge l'a rendu, entre parenthèses : échange refusé : Gameforge ne reconnaît pas ce code (400 Bad Request : …) : vérifiez … par exemple. Si Gameforge veut d'abord la vérification d'âge du compte, l'erreur le dit aussi. Rien n'est retenté par une autre connexion. Le type que Gameforge reconnaît au code part au journal du robot.
La session du robot d'abord. L'échange présente celle que le robot tient, sans en ouvrir une de plus. Il n'en ouvre une que si Gameforge refuse celle-là et qu'aucun robot de ce compte Gameforge n'est démarré, même en veille ou en attente de reconnexion : une session neuve pourrait le couper. Sinon l'erreur le dit, et il suffit d'arrêter ces robots avant de recommencer. Si un robot démarre pendant l'ouverture, la session est laissée de côté et le code n'est pas présenté : l'erreur le dit aussi.
Le frein du bouton vaut pour les scripts. Trois connexions refusées en dix minutes pour ce compte Gameforge, par le bouton des Paramètres, par un script ou par le formulaire « Nouveau robot », et RedeemCode rend pendant un quart d'heure une erreur qui le dit, sans rien envoyer. Un seul échange à la fois par compte Gameforge : celui qu'on lance pendant un autre est refusé.
Une réponse perdue n'est pas un refus. Si la demande est partie mais que la réponse de Gameforge ne revient pas (délai dépassé, passerelle en panne), l'erreur dit que Gameforge a pu prendre le code : vérifiez dans le lobby avant de recommencer.
L'empreinte du navigateur
| Fonction | Rend | |
|---|---|---|
GetFingerprintNames() | 1 : une liste de noms | Les entrées de la bibliothèque d'empreintes que décrit l'empreinte réglée de ce robot. Vide quand aucune ne correspond. |
C'est la ligne du panneau Empreinte du navigateur, dans les paramètres du robot, onglet « Généralités », au-dessus du tableau : « Ce tableau correspond à l'empreinte … de la bibliothèque ». Elle nomme l'entrée que décrit l'empreinte réglée du robot, celle du tableau, et la liste la marque « (ce bot) ». Une entrée est copiée dans le robot quand on l'applique, et rien ne garde d'où elle vient. Le lien, c'est la machine : même système, même navigateur, même agent, même écran, même mémoire, mêmes cœurs, même fuseau, mêmes langues, même profondeur de couleur, même navigator.vendor et même carte graphique. C'est aussi ce que compte la colonne Robots de la page Empreintes.
Une liste, parce que deux entrées peuvent décrire la même machine. Le robot les porte alors toutes les deux, et l'écran les nomme ensemble. Elle est vide pour une empreinte tirée au hasard, relevée sur cet ordinateur ou faite à la main, et pour une entrée retouchée depuis, ne serait-ce que sur sa carte graphique : le robot garde sa copie, qui n'est plus la même machine.
Le réglage, pas le fichier. Le jeu reçoit le fichier d'empreinte du robot tant qu'il existe, et GetFingerprintNames ne le lit pas : elle compare le réglage, comme la ligne au-dessus du tableau. La ligne orange sous le tableau (« Le jeu reçoit encore l'empreinte gardée dans le fichier de ce bot… ») ne compare au réglage qu'une partie du fichier : la mémoire, les cœurs, le fuseau, la carte graphique et l'agent, chacun seulement quand le réglage le renseigne. Sans écart sur ces cinq-là, c'est la ligne grise qui s'affiche, même si le fichier diffère par le système, le navigateur, l'écran, les langues, la profondeur de couleur ou le navigator.vendor. Le fichier peut différer du réglage dans deux cas. Il peut être plus ancien que lui : « Appliquer » l'efface alors, et la connexion suivante le refait d'après l'empreinte choisie. Il peut aussi être partagé par deux robots de même e-mail et même univers dans deux langues. C'est alors celui que le premier des deux à se connecter a bâti, d'après le réglage qu'il avait à ce moment, et « Appliquer » ne l'efface ni sur l'un ni sur l'autre : le jeu continue de le recevoir pour les deux. Deux robots peuvent aussi porter un même nom importé : « Appliquer » laisse alors le fichier à l'autre et range ce robot sous le nom de son compte.
Elle ne demande rien au jeu et se relit à chaque appel : une empreinte appliquée depuis l'écran se voit à l'appel suivant. Le jeu, lui, ne la reçoit qu'à la connexion suivante, et seulement si aucun autre robot ne porte déjà le fichier sous le nom de ce compte.
noms = GetFingerprintNames()
if len(noms) == 0 {
LogWarn("ce robot ne porte aucune empreinte de la bibliothèque")
} else {
Print("empreinte de la bibliothèque :", noms[0])
}
Créer, appliquer et retirer une empreinte
| Fonction | Rend | |
|---|---|---|
NewFingerprint(nom, système, région) | 2 : l'empreinte et une erreur | « + Nouvelle empreinte » de la page Empreintes : une machine tirée au hasard, puis enregistrée dans la bibliothèque. |
GetFingerprint(nom) | 1 : l'empreinte, nil quand il n'y en a pas | La fiche d'une entrée de la bibliothèque, à relire ou à retoucher. |
SaveFingerprint(empreinte) | 1 : une erreur | « Enregistrer » sur la fiche d'une entrée qu'on a retouchée. |
ApplyFingerprint(nom) | 1 : une erreur | « Appliquer » du panneau Empreinte du navigateur : ce robot présentera cette entrée au jeu. |
DeleteFingerprint(nom) | 1 : une erreur | ✕ de la bibliothèque : l'entrée de ce nom en est retirée, sauf si un robot la porte. |
NewFingerprint fait ce que fait la fiche de la page Empreintes, bouton « + Nouvelle empreinte » : « Tirer au hasard », puis « Enregistrer l'empreinte ». Les trois choix de la fiche sont ses trois arguments.
nomest le nom de l'entrée. Vide, c'est le premier « Machine N » libre, comme dans la fiche.systèmevaut"Windows","Mac OS X","Linux","Android"ou"iOS", sans souci de casse. Vide, il est tiré selon sa part réelle parmi les trois d'ordinateur : un téléphone ne sort que si on le demande. Un autre nom est refusé.régionest un code de la liste « Région » de la fiche ("FR","DE","RS"…). Elle commande le fuseau et les langues. Vide, c'est celle de l'adresse de sortie du robot sur le Cloud, et ailleurs celle de la langue de son univers : la fiche prend la langue du panneau, un script a un robot. Un code inconnu est refusé.
La machine tirée est cohérente de bout en bout, comme dans la fiche : l'agent, l'écran, la mémoire, les cœurs et, pour un téléphone, la carte graphique vont ensemble, et elle diffère de toutes les entrées de la bibliothèque et de tous les robots. Le navigateur est Chrome, à une version stable récente, et Safari sur un iPhone. La version vient du calendrier des sorties de Chrome, avec un retard de un à quatorze jours tiré pour la machine : le 10/11/2026, la 157 ou la 156.
Le Chrome d'un robot se met à jour tout seul, comme un vrai navigateur, chacun à sa date. Chaque robot a son propre retard sur la dernière version stable, de un à quatorze jours, tiré une fois. Il change de version à sa première connexion après sa date, jamais pendant une session, et jamais dans la même heure qu'un autre robot de l'installation. Son journal dit la date prévue (« changement de version du navigateur prévu »), puis le changement (« le navigateur de l'empreinte change de version », avant et après). Les entrées de la bibliothèque qu'il porte suivent avec lui. Une empreinte relevée sur cet ordinateur ne monte pas d'elle-même : elle suit le Chrome du joueur quand le panneau le relève de nouveau, à la connexion suivante du robot. Rien de tout cela ne passe par un script.
Un nom déjà pris n'est jamais écrasé. NewFingerprint rend alors l'entrée en place, telle quelle, avec une erreur qui le dit : un script lancé à chaque démarrage ne retire pas une machine neuve à chaque fois. L'empreinte rendue n'est jamais nil, même en échec.
Retoucher, c'est GetFingerprint puis SaveFingerprint, comme « Modifier » sur la page Empreintes. L'empreinte porte les champs de la fiche.
| Champ | |
|---|---|
Name | Le nom de l'entrée. Il ne se change pas : SaveFingerprint réécrit l'entrée de ce nom, et refuse un nom que la bibliothèque n'a pas. |
System, Browser, UserAgent | Le système, le navigateur et l'agent. |
Memory, Cores | La mémoire en Go, celle de navigator.deviceMemory, et les cœurs. |
Width, Height, ColorDepth | La taille utile de l'écran et sa profondeur de couleur. |
Timezone, Languages | Le fuseau et les langues ("fr-FR,fr,en-US,en"). |
Vendor, Webgl | navigator.vendor et la carte graphique. Vides, la bibliothèque les déduit du système. |
SaveFingerprint enregistre ce que le navigateur exposerait. La mémoire d'un Safari, d'un Firefox ou d'un iPhone est nulle, puisqu'ils n'ont pas navigator.deviceMemory ; les cœurs d'un Safari sont 4 ou 8 ; une mémoire que la version de Chrome ne rend pas devient la plus proche qu'elle rende. L'empreinte passée est relue telle qu'enregistrée. Un réglage que la connexion ne saurait pas bâtir, un fuseau inconnu ou une langue mal formée, est refusé avec l'erreur que la connexion aurait rendue. Les robots qui portent déjà cette entrée gardent leur copie : la retoucher ne vaut que pour les robots à qui on l'appliquera ensuite.
ApplyFingerprint est le bouton « Appliquer », sur le robot du script et lui seul. Le réglage change tout de suite, et GetFingerprintNames le voit à l'appel suivant. Le jeu reçoit la nouvelle empreinte à la connexion suivante : la session en cours n'est pas coupée. Le fichier d'empreinte du robot est effacé pour être refait d'après l'entrée, sauf s'il est aussi celui d'un autre robot. Sur le Cloud, une entrée dont le fuseau n'est pas celui de l'adresse de sortie du robot est refaite au démarrage suivant, comme si on l'avait appliquée depuis l'écran.
Ce que l'écran demande par une confirmation, ApplyFingerprint le tient par deux gardes.
- Une entrée que le robot porte déjà ne refait rien, quand son fichier la présente aussi ou n'existe pas encore. Le bouton refait le fichier à chaque clic ; un script rejoué à chaque démarrage donnerait au jeu une machine neuve à chaque connexion. Le journal ne dit « empreinte appliquée par un script » que quand l'empreinte a changé.
- Le fichier de ce compte est celui d'un autre robot, le même compte dans deux langues : refusé, avec une erreur qui le dit. Le jeu recevrait ce fichier, et non l'entrée demandée ; l'écran le dit dans sa confirmation.
DeleteFingerprint est le ✕ de la bibliothèque, celui de la page Empreintes et du panneau Empreinte du navigateur. L'entrée de ce nom quitte la bibliothèque ; aucun fichier d'empreinte n'est effacé. Un nom que la bibliothèque n'a pas est refusé.
Une entrée qu'un robot porte est refusée, quel que soit le robot, avec une erreur qui les nomme : ce sont ceux que compte la colonne Robots de la page Empreintes. L'écran la retire après une confirmation, les robots gardant leur copie ; un script n'a personne pour confirmer, et un script de ménage rejoué à chaque démarrage viderait la bibliothèque des machines qu'on partage entre robots. Pour la retirer quand même, passez par l'écran.
« Tirer une nouvelle empreinte » et « Reprendre l'empreinte de cet ordinateur », dans le panneau Empreinte du navigateur, n'ont pas de fonction : rejoués par un script, ils donneraient au jeu une machine neuve à chaque démarrage.
Aucune de ces fonctions ne touche à l'empreinte d'un autre robot : ApplyFingerprint ne prend pas de compte, et n'efface jamais le fichier d'un autre robot. Changer d'empreinte sur un compte déjà installé se remarque, depuis un script comme depuis l'écran : à faire à la création, ou en cas de collision avec un autre robot.
// Un téléphone pour ce robot, une fois pour toutes : rejoué, rien ne change
f, err = NewFingerprint("Téléphone du salon", "Android", "FR")
if err != nil { LogWarn("empreinte :", err) }
Print(f.Name, f.UserAgent, f.Memory, f.Width, f.Height)
err = ApplyFingerprint(f.Name)
if err != nil { LogError("application :", err) }
// Le ménage : retirer les entrées qu'aucun robot ne porte
for nom in ["Machine 1", "Machine 2", "Machine 3"] {
err = DeleteFingerprint(nom)
if err != nil { Print(nom, ":", err) }
}
// Retoucher l'écran d'une entrée de la bibliothèque
f = GetFingerprint("Salon")
if f == nil {
LogWarn("pas d'empreinte « Salon » dans la bibliothèque")
} else {
f.Width = 1920
f.Height = 1032
err = SaveFingerprint(f)
if err != nil { LogError("Salon :", err) }
}
Relever un système
| Fonction | Rend | |
|---|---|---|
GalaxyInfos(galaxie, système) | 2 : le relevé et une erreur | Les quinze positions d'un système. |
GalaxyInfosUsing(galaxie, système, céleste) | 2 : le relevé et une erreur | Le même, en se plaçant sur un céleste. |
GetPlanetInfo(coordonnée) | 2 : la position et une erreur | Une seule position. |
GetPlanetInfoUsing(coordonnée, céleste) | 2 : la position et une erreur | La même, en se plaçant sur un céleste. |
CoordinatesAvailableForDiscoveryFleet(origine, galaxie, système) | 2 : la liste et une erreur | Les positions où une expédition de forme de vie peut partir, places vides comprises. Liste vide quand il n'y en a aucune. |
sys, err = GalaxyInfos(1, 224) // DEUX cibles
if err != nil { LogError(err); return }
for i = 1; i <= 15; i++ {
p = sys.Position(i)
if p == nil { continue } // position entièrement vide
if p.Player.ID == 0 {
// personne : champ de débris seul, ou planète détruite
Print(i, "sans propriétaire", p.Debris.Metal)
continue
}
Print(p.Coordinate, p.Name, p.Player.Name, p.Activity)
}
// [P:1:224:8] Colonie III Xylo 15
Le relevé passe désormais par la porte de la version 13, sous la même forme qu'avant. Le jeu a fermé la page que la bibliothèque interrogeait : elle répondait « error in retrieve galaxy infos », et GalaxyInfos était la dernière lecture du robot restée en arrière. Elle emprunte maintenant le même relevé que les workers, puis le retraduit dans la forme d'origine, champ pour champ. Vos scripts existants n'ont pas une ligne à changer, à ceci près que les champs que la version 13 ne sert plus reviennent vides plutôt qu'en erreur : voyez les pièges ci-dessous.
Ce que porte une position
| Champ | Ce qu'il vaut |
|---|---|
.ID, .Name | La planète. Vides sur une position qui ne porte qu'un champ de débris. |
.Coordinate | S'écrit [P:1:224:8]. Le type est toujours P, même quand la position porte une lune. |
.Activity | 0 : rien à signaler. 15 : actif à l'instant. 16 à 59 : les minutes écoulées, recopiées telles que le jeu les compte. |
.Player.ID, .Player.Name, .Player.Rank | Le propriétaire et sa place au classement. |
.Inactive, .Vacation, .Banned, .Newbie, .StrongPlayer, .HonorableTarget, .Administrator | Les états du joueur. |
.Player.IsBandit, .Player.IsStarlord | Les deux extrémités du rang d'honneur. |
.Debris.Metal, .Debris.Crystal, .Debris.Deuterium, .Debris.RecyclersNeeded | Le champ de débris, avec le nombre de recycleurs que le jeu annonce. |
.Moon | nil, ou .ID, .Diameter, .Activity. .Moon.Name existe et reste vide. |
.Alliance | nil, ou .Tag. |
.Destroyed | Existe, et vaut toujours faux. Voir plus bas. |
Les pièges du relevé
nil veut dire « rien du tout », pas « pas de planète ». Une position qui ne porte qu'un champ de débris rend une fiche bien réelle, aux champs de joueur vides. Testez p.Player.ID == 0 pour « personne », p == nil pour « position déserte ». Un cas limite : un champ qui ne contiendrait que du deutérium, sans métal ni cristal, est laissé de côté et sa position revient nil.
Une planète détruite garde un nom, et .Destroyed ne le dit pas. Le jeu la rattache à un compte système au lieu de la retirer. Kepler efface le joueur, le rang, l'alliance et tous les états, mais .Player.Name peut encore porter le nom de remplacement du jeu. Quant à .Destroyed, il existe dans la forme rendue et n'est jamais rempli : il vaut faux sur une planète détruite comme sur les autres. L'identifiant de joueur à zéro est le seul test qui ne trompe pas.
Une activité à zéro n'est pas une absence d'activité. C'est l'absence d'affichage, et le jeu n'affiche rien au-delà d'une heure. Un joueur parti depuis trois jours et un joueur parti depuis soixante et une minutes rendent le même zéro.
L'alliance n'a plus que son tag. La version 13 ne donne plus le nom, le rang ni le nombre de membres sur cette page. .Alliance.Name, .Alliance.ID, .Alliance.Rank et .Alliance.Member existent donc toujours, et rendent la chaîne vide ou zéro au lieu d'une erreur, ce qui est le moins mauvais des deux.
L'inactivité longue n'est pas reportée. Le relevé du jeu distingue l'inactif de l'inactif de longue date, mais la forme rendue à votre script ne porte qu'un .Inactive, recopié du seul drapeau court. Pour faire la différence, lisez le Status que rend PlayersData et cherchez-y le I majuscule.
Le relevé n'expose que trois choses : Position(i), Galaxy() et System(). Les autres membres de la forme d'origine sont hors d'atteinte : sys.ExpeditionDebris s'arrête sur no member named 'ExpeditionDebris' for struct, et sys.Events comme sys.Relocations font de même. C'est une erreur franche, à l'exécution, qui nomme le champ. Les débris d'expédition, qui se posent en position 16, ne sont de toute façon pas dans le relevé.
Un relevé fait la queue derrière les workers. Il passe par la file d'attente du compte, à priorité ordinaire, mais pas par le régulateur de cadence du robot : c'est à votre script d'espacer ses appels s'il balaie cent systèmes.
Se placer sur un céleste, et pourquoi cela compte
c = GetCachedCelestial("1:2:3")
sys, err = GalaxyInfosUsing(4, 116, c.GetID())
Le céleste ne change pas ce que le relevé dit : un système contient les mêmes planètes vu d'où que ce soit. Il compte dès que vous voulez agir depuis ce relevé.
Le jeu rattache l'action à la planète courante, et le jeton qu'il délivre avec le relevé vaut pour elle. Relever depuis l'une et envoyer depuis l'autre se solde par un refus — que rien dans le relevé n'annonce.
Une seule position
p, err = GetPlanetInfo("4:116:6")
if err != nil {
Print("personne là :", err) // aucune planète en [P:4:116:6]
} else {
Print(p.Name, p.Player.Name, p.Activity)
}
GetPlanetInfo relève le système entier et vous en rend une position : elle coûte donc exactement une requête, la même que GalaxyInfos. Si vous en voulez plusieurs dans le même système, appelez GalaxyInfos une fois et parcourez son résultat.
Une position vide rend une erreur, et non une fiche à zéro. C'est délibéré : une fiche vide se lirait comme une planète sans nom appartenant au joueur numéro zéro, et un script qui compare des noms ou des rangs y verrait une vraie cible.
Parcourir plusieurs systèmes
| Fonction | Rend | |
|---|---|---|
GetSystemsInRange(origine, rayon) | 1 : une liste de systèmes | Dans l'ordre des numéros. |
GetSystemsInRangeAsc(origine, rayon) | 1 : une liste de systèmes | Du plus proche au plus loin. |
GetSystemsInRangeDesc(origine, rayon) | 1 : une liste de systèmes | Du plus loin au plus proche. |
Print(GetSystemsInRange(3, 2)) // [1 2 3 4 5]
Print(GetSystemsInRangeAsc(3, 2)) // [3 2 4 1 5]
Print(GetSystemsInRangeDesc(3, 2)) // [5 1 4 2 3]
for s in GetSystemsInRangeAsc(224, 15) {
sys, err = GalaxyInfos(1, s)
if err != nil { LogWarn(s, err); continue }
SleepRandMs(500, 1200) // espacez, rien ne le fera pour vous
}
Ces trois fonctions ne demandent rien au jeu : elles calculent. La galaxie boucle, donc un rayon qui déborde revient de l'autre côté, GetSystemsInRange(3, 3) commence par 499. Le nombre de systèmes est celui de votre univers ; faute de session, le calcul retombe sur 499 sans le dire.
Un écart avec Ninja. Notre Desc renverse la liste entière, la sienne ne renverse que les distances. Les deux rendent les mêmes systèmes, du plus loin au plus proche, mais à distance égale l'ordre des deux voisins est inversé : nous rendons [5 1 4 2 3] là où sa documentation annonce [1 5 2 4 3]. Sans conséquence pour un balayage, gênant si vous comparez deux journaux.
Les joueurs
| Fonction | Rend | |
|---|---|---|
PlayersData() | 2 : la liste et une erreur | Tous les joueurs de l'univers. |
PlayerDataByID(id) | 2 : un joueur et une erreur | Erreur franche si l'identifiant est inconnu. |
PlayerDataByName(pseudo) | 2 : un joueur et une erreur | Pseudo entier, la casse est ignorée. |
Ce que porte un joueur
| Champ | Ce qu'il vaut |
|---|---|
ID, Name | L'identifiant et le pseudo, tels que le jeu les publie. |
Status | La suite de lettres du jeu. C'est la seule source complète. |
Alliance | L'identifiant de son alliance, 0 quand il n'en a pas. |
IsInactive() | Vraie si le statut porte un i ou un I : l'inactivité courte comme la longue. |
IsVacation() | Vraie si le statut porte un v. |
IsBanned() | Vraie si le statut porte un b. |
DefensivePoints() | Ses points de défense, que le jeu ne publie pas. Fiche riche seulement. |
OffensivePoints() | Sa flotte, c'est-à-dire le militaire moins la défense. Fiche riche seulement. |
joueurs, err = PlayersData() // DEUX cibles
if err != nil { LogError(err); return }
n = 0
for j in joueurs {
if j.IsInactive() { n++ } // les parenthèses comptent, voir plus bas
}
Print(n, "inactifs sur", len(joueurs))
cible, err = PlayerDataByName("Xylo")
if err != nil { Print("inconnu au bataillon") } else { Print(cible.ID) }
Le piège des parenthèses, et il est silencieux. IsInactive, IsVacation et IsBanned sont des fonctions chez nous, des cases à cocher chez Ninja. Écrite sans parenthèses, if j.IsInactive { ... } ne provoque aucune erreur : la condition est simplement toujours fausse, et votre script trouve zéro inactif dans un univers qui en compte deux mille.
if j.IsInactive { ... } // ✗ jamais vrai, jamais signalé
if j.IsInactive() { ... } // ✓
Les autres noms de champs diffèrent aussi. Sa fiche courte porte IsAdmin, IsLongInactive, Vacation et AllianceID ; la nôtre porte Status et Alliance. Un script recopié s'arrête donc sur no member named 'Vacation' for struct, ce qui au moins se voit tout de suite. IsInactive est le seul nom commun aux deux, et c'est justement celui qui ne dit rien quand on l'écrit à sa façon.
La fiche complète, et ce qu'elle coûte. PlayerDataByID et PlayerDataByName rendent la fiche riche, aux noms de Ninja : PointsTotal, PointsEconomy, PointsResearch, PointsMilitary, PointsMilitaryBuilt, PointsMilitaryDestroyed, PointsMilitaryLost, PointsHonor, PointsLifeform, les neuf Position... qui leur répondent, MilitaryShips, Celestials et Alliance. PlayersData, elle, garde la fiche courte.
Alliance vaut nil quand le joueur n'en a pas, et porte sinon ID, Name et Tag. C'est le seul endroit du bot qui joint un identifiant d'alliance à son tag : le relevé de galaxie de la version 13 ne donne que le tag.
Celestials porte les planètes du joueur et leurs lunes, chaque lune juste après la sienne, avec ID, Name et Coordinate. C'est la seule façon de savoir où quelqu'un habite sans balayer des systèmes entiers.
Ces deux fonctions coûtent une requête par joueur, gardée une heure, là où PlayersData n'en coûte aucune. Un script qui parcourt deux mille joueurs doit donc partir de PlayersData et ne demander la fiche complète que de ceux qu'il retient.
DefensivePoints() et OffensivePoints() séparent la défense de la flotte, ce que le jeu ne publie nulle part : son classement militaire mélange les deux.
p, err = PlayerDataByID(id)
Print(p.DefensivePoints()) // ses points de défense
Print(p.OffensivePoints()) // sa flotte, donc ce qui peut voler
Le calcul repose sur une identité du jeu : la défense est la seule chose comptée en entier à la fois dans l'économie et dans le militaire. La somme des catégories dépasse donc le total d'exactement la défense.
défense = économie + recherche + militaire + forme de vie − total flotte = militaire − défense
Ces deux méthodes n'existent pas dans la 1.82.239 ni dans les versions antérieures : un bot qui ne les connaît pas arrête le script dessus.
La formule vient d'un client, le 22/09/2026 ; la référence de Ninja déclare les deux fonctions et n'a jamais donné leur calcul. Vérifiée sur deux comptes indépendamment : chez lui, et ici en chiffrant chaque pièce de défense des vingt célestes d'un compte par son prix. 168 476 points annoncés, 168 476 comptés, à l'unité près.
Les missiles d'interception comptent dans la défense, ce qui n'allait pas de soi : ils ne défendent contre aucune flotte, seulement contre d'autres missiles. La comptabilité du jeu les range pourtant là. Mesuré sur un second compte, qui en porte 490 :
sans les missiles : 2 695 268 → écart de 4 900 avec les missiles : 2 700 168 → écart nul
soit exactement leur prix. Les missiles interplanétaires, eux, n'ont pas pu être mesurés : aucun compte sous la main n'en a un seul. Ils sont sur la même page et dans le même silo, donc ils comptent probablement aussi - mais probablement n'est pas mesuré.
Une réserve qui reste : un joueur dont le fichier date de quelques heures rend les chiffres de ce moment-là, pas de maintenant. Le jeu ne le regénère qu'une fois par jour.
DefensivePoints() ne descend jamais sous zéro : les classements entiers arrondissent, et la soustraction peut tomber à −1. Le fichier de fiches, lui, est fractionnaire et ne déclenche pas ce cas.
Les points militaires ne sont pas dans l'ordre que Ninja déclare. Sa liste donne Built, Destroyed, Lost ; le jeu range les types 4, 5 et 6 dans l'ordre perdu, construit, détruit. Mesuré sur quarante joueurs le 21/09/2026, par une identité qui ne dépend d'aucune documentation : ce qu'un joueur a construit vaut ce qu'il a encore plus ce qu'il a perdu. Les noms sont ceux de Ninja, les valeurs viennent des bons types.
Le fichier est gros, il est donc gardé six heures. Le jeu ne le regénère qu'une fois par jour. Le premier appel télécharge plusieurs centaines de kilo-octets, les suivants ne coûtent rien, et tous les scripts du compte partagent la même copie. Un joueur qui change de pseudo peut donc rester connu sous l'ancien pendant six heures. PlayerDataByID et PlayerDataByName lisent cette même copie ; la seconde compare le pseudo entier, pas un morceau.
Ces lectures passent par la connexion du compte (donc par son proxy), mais pas par sa file d'attente : elles ne retardent aucun worker.
Le classement
| Fonction | Rend | |
|---|---|---|
HighscoreData(category, typ) | 2 : le classement entier et une erreur | Par l'API du jeu. Des identifiants, pas des noms. |
GetHighscore(category, typ, page) | 2 : une page et une erreur | La page du classement du jeu, cent joueurs, avec leur planète mère. |
Les deux se complètent. HighscoreData rend le classement entier en un appel, par l'API du jeu, mais seulement des identifiants. GetHighscore lit la page du classement telle que le jeu l'affiche : chaque entrée de Players porte Position, ID, Name, Score et Homeworld, la planète mère que le lien du pseudo ouvre dans la galaxie. C'est la seule source sûre de la planète mère.
NbPage vaut la page suivante tant que la page lue est pleine, et la page lue quand elle est la dernière : la boucle « tant que page < NbPage » des scripts venus de Ninja s'arrête donc au bon endroit. AllianceID, HonourPoints et Ships ne sont pas remplis.
HighscoreData interroge l'API que le jeu publie pour être lue. Elle rend le classement entier d'un seul appel, là où la page en donnait cent, et ne se cassera pas à la prochaine version. En échange, elle ne donne que des identifiants : le nom se prend dans PlayersData. Comme elle, elle emprunte la connexion du compte sans passer par sa file d'attente.
rangs, err = HighscoreData(1, 0) // joueurs, classement général
if err != nil { LogError(err); return }
joueurs, err = PlayersData()
if err != nil { LogError(err); return }
noms = {}
for j in joueurs { noms[j.ID] = j.Name }
for r in rangs {
if r.Position <= 10 { Print(r.Position, noms[r.ID], r.Score) }
}
Chaque entrée porte ID, Position, Score et Ships, ce dernier n'étant rempli que par les classements militaires.
category vaut 1 pour les joueurs et 2 pour les alliances. typ choisit le classement : 0 le total, 1 l'économie, 2 la recherche, 3 le militaire, puis 4, 5 et 6 pour les pertes, les constructions et les destructions. Au-delà, la documentation de Ninja se contredit elle-même : sa liste nomme 9 « économie » quand son propre exemple donne ce nom à 1. Kepler ne les interprète pas, il les recopie tels quels dans l'adresse de l'API : un appel d'essai tranche en une seconde, un pari se paie en heures.
Un classement d'alliances rendra des identifiants d'alliance, que PlayersData ne sait pas nommer : elle ne connaît que les joueurs.
Chaque couple catégorie/type est gardé une heure de son côté, parce que le jeu ne recalcule les rangs qu'une fois par heure. Comparer l'économie au militaire ne fait donc pas retélécharger l'un par l'autre.
Lire une page du jeu telle quelle
Deux ajouts qui n'existent pas chez Ninja. Ils servent à voir ce que le jeu envoie vraiment, quand une erreur d'analyse ne dit pas en quoi la page a changé.
| Fonction | Rend | |
|---|---|---|
PageContent(requête) | 2 : le texte et une erreur | Une page du jeu, par la session du compte. |
FetchURL(adresse) | 2 : le texte et une erreur | N'importe quelle adresse, par la même session. |
HttpRequest(méthode, adresse, en-têtes, corps) | 3 : le texte, le code et une erreur | Une requête complète, par la même session. |
html, err = PageContent("page=ingame&component=overview")
if err != nil { LogError(err); return }
Print(len(html), "octets")
regexp = import("regexp")
r = regexp.MustCompile(`var site = (\d+)`)
Print(r.FindStringSubmatch(html))
PageContent prend une suite de paramètres, pas une adresse : ce qui suit le ? de index.php. La requête part par la session du compte, donc par son proxy, ses cookies et son empreinte, et par sa file d'attente.
Un nom de page inexact retient le compte plusieurs minutes. Le jeu répond « An error has occured! », que la bibliothèque prend pour une déconnexion : elle se reconnecte et réessaie, dix fois, en doublant l'attente jusqu'à une minute, et pendant ce temps ni les workers ni l'écran n'obtiennent la main. Une graphie est corrigée d'office pour vous, resourceSettings devenu resourcesettings en version 13, et la correction se lit au journal. Les autres sont à vous.
FetchURL télécharge une adresse complète. ServerURL() vous donne la racine. FetchURL est bornée à 4 Mo, ce qui suffit largement pour un fichier d'interface. Deux choses à savoir : elle ne regarde pas le code de réponse, si bien qu'une page d'erreur du serveur vous revient comme un texte ordinaire, sans erreur ; et une longue lecture s'interrompt si vous arrêtez le script.
HttpRequest est la même chose avec les trois pièces qui manquent à FetchURL : la méthode, les en-têtes et le code de réponse.
entêtes = {}
entêtes["Authorization"] = "Bearer " + jeton
entêtes["Content-Type"] = "application/json"
charge, err = JsonEncode({"celeste": 33628068})
if err != nil { LogError(err); return }
corps, code, err = HttpRequest("POST", "https://exemple.net/api", entêtes, charge)
if err != nil { LogError(err); return } // ← TROIS cibles
if code == 429 {
Sleep(60) // trop vite : on réessaiera
return
}
if code == 401 {
LogError("jeton refusé") // inutile de réessayer
return
}
Print(code, len(corps))
C'est le code qui vous manquait pour une échelle de reprise. Un 429 se réessaie après une pause, un 401 ne se réessaiera jamais avec succès, et sans le code les deux se ressemblent : FetchURL vous rendrait la page d'erreur comme un texte ordinaire.
Les en-têtes s'écrivent en tableau ordinaire, nil si vous n'en avez pas. Un corps vide ne part pas. La méthode est libre - GET, POST, PUT, DELETE, PATCH - et une méthode vide vaut GET.
Le code de réponse n'est jamais une erreur : un 500 vous revient avec err à nil et code à 500. err ne se remplit que si la requête n'a pas pu partir ou pas pu revenir. Testez les deux.
Comme FetchURL, elle passe par la session du compte - même proxy, mêmes cookies, même empreinte - ce qui lui permet de poster sur les points d'entrée du jeu lui-même, qu'un GET nu n'atteint pas. Parler à un service tiers n'emporte rien de votre session : le bocal à cookies ne sert que le domaine visé. La réponse est bornée à 4 Mo, comme FetchURL.
Écrire à un joueur
| Fonction | Rend | |
|---|---|---|
SendMessage(playerID, message) | 1 : une erreur | Un message privé, par le chat du jeu. |
cible, err = PlayerDataByName("Xylo")
if err != nil { LogError(err); return }
err = SendMessage(cible.ID, "Bonjour, je viens en paix.")
if err != nil { LogError("message refusé :", err) }
Il faut un identifiant, pas un pseudo : passez par PlayerDataByName ou par .Player.ID d'un relevé de galaxie.
L'envoi emprunte le formulaire de la version 13, celui-là même que le robot utilise pour ses propres alertes. Le jeton de discussion est gardé d'un message au suivant, et retrouvé tout seul s'il est refusé : une campagne de trois cents messages ne recharge pas trois cents pages. Les erreurs, elles, sont franches : elles disent sous quelle forme le jeton a été lu, et le début de ce que le jeu a répondu.
SendMessageAlliance n'existe pas encore.
Les rapports et la boîte à messages
C'est la matière première d'un script de pillage écrit à la main : sans elle, un script voit les cibles par la galaxie mais jamais ce qu'elles portent.
| Fonction | Rend | |
|---|---|---|
GetEspionageReportMessages() | 2 : la liste et une erreur | Le résumé de chaque rapport de la première page. |
GetEspionageReportMessagesPages(pages) | 2 : la liste et une erreur | La même chose, sur plusieurs pages. |
GetEspionageReport(idMessage) | 2 : le rapport et une erreur | Le rapport détaillé d'un message. |
GetEspionageReportFor(coordonnée) | 2 : le rapport et une erreur | Le dernier rapport visant cette position. |
GetCombatReportSummaryFor(coordonnée) | 2 : le résumé et une erreur | Le dernier combat à cette position. |
DeleteMessage(idMessage) | 1 : une erreur | Efface un message pour de bon, corbeille comprise. |
DeleteAllMessagesFromTab(onglet) | 1 : une erreur | Met un onglet entier à la corbeille. |
resumes, err = GetEspionageReportMessages()
if err != nil { LogError("boite :", err) }
for m in resumes {
Print(m.ID, m.Target, "butin", m.LootPercentage)
}
rapport, err = GetEspionageReportFor("1:2:3")
if err == nil {
Print(rapport.Username, "inactif :", rapport.IsInactive)
Print("metal :", rapport.Metal, "cristal :", rapport.Crystal)
}
detail, err = GetEspionageReport(resumes[0].ID)
Print(detail.Username, err)
combat, err = GetCombatReportSummaryFor("1:2:3")
if err == nil { Print("butin :", combat.Loot, combat.AttackerName) }
anciens, err = GetEspionageReportMessagesPages(3)
Print("sur trois pages :", len(anciens))
DeleteMessage(resumes[0].ID)
DeleteAllMessagesFromTab(20)
Le résumé porte ID, Target, Type, From et LootPercentage — pas les ressources : celles-ci sont dans le rapport détaillé, que GetEspionageReport ou GetEspionageReportFor rendent. Ce dernier porte aussi Username, IsInactive, LastActivity, et les niveaux de bâtiments quand vous avez envoyé assez de sondes pour les voir.
Les numéros d'onglet sont ceux du jeu : 20 espionnage, 21 rapports de combat, 22 expéditions, 23 transports et unions, 24 le reste. Un autre numéro est refusé ici plutôt que passé au jeu, qui répondrait par sa page d'accueil, c'est-à-dire par rien.
DeleteMessage ne rend jamais un message à la boîte. Le bouton « effacer » du jeu est une bascule : sur un message déjà dans la corbeille, il le remet dans la boîte. DeleteMessage cherche donc d'abord où est le message, dans la boîte puis dans la corbeille de ces cinq onglets. Dans la boîte, il l'efface puis vide sa place dans la corbeille ; déjà dans la corbeille, il ne fait que l'en retirer. C'est le geste du bouton corbeille de la page Rapports.
Un message qui n'est dans aucun des cinq onglets n'est pas touché, et l'erreur le dit. La recherche coûte des lectures de la messagerie : une seule pour un rapport d'espionnage récent, davantage pour un message rangé loin.
DeleteAllMessagesFromTab, lui, met la boîte de l'onglet à la corbeille sans la vider : purger la corbeille entière emporterait aussi les avis « vous avez été espionné » et ce que vous y avez mis vous-même.
Une seule page par défaut. GetEspionageReportMessages lit ce que voit un joueur qui ouvre sa boîte. Parcourir tout l'historique coûterait une requête par page sans que le script l'ait demandé : c'est à quoi sert la variante qui prend un nombre de pages.
Compter ses colonies
| Fonction | Rend | |
|---|---|---|
CountColonies() | 2 : le nombre et le maximum | Ce que vous avez, ce que vous pouvez avoir. |
combien, possible = CountColonies()
Print(combien, "colonies sur", possible)
Aucune erreur en retour : le compte se lit dans la mémoire du robot, il ne coûte pas de requête. Sans session ouverte, deux zéros et une ligne au journal.