Orion

Sur un univers d'Orion seulement. Ces fonctions existent partout, mais le module ne s'active que sur un univers qui a Orion. Ailleurs, StartOrion et les gestes rendent l'erreur cet univers n'a pas Orion : le module ne lit rien, et rien ne part au jeu. Le robot le lit sur les pages que sa session parcourt, et il le retient. S'il ne le sait pas encore, une session ouverte lit une page Installations, une seule, celle qui montre le scanner d'anomalies même au niveau zéro ; sans session, l'erreur le dit. Les réglages ne rendent cette erreur qu'une fois l'univers connu : tant que le robot ne sait pas, ils s'enregistrent, sans effet hors d'un univers d'Orion. Les constantes d'Orion et le préfixe A: des coordonnées sont décrits dans Constantes et valeurs.

Ces noms sont neufs : si votre !global.ank en définit déjà un, vos scripts reçoivent celui du moteur, voir l'introduction. Renommez le vôtre.

Tout ce que fait la page Orion du robot se fait ici : lire le relevé, poser chaque réglage, et les gestes que le module fait lui-même, à la main.

L'interrupteur et le relevé

Fonction	Rend
`StartOrion()` / `StopOrion()`	1 : une erreur	La case « Orion actif », enregistrée. `StartWorker("orion")` et `StopWorker("orion")` font la même chose. `StartOrion` rend une erreur sur un univers sans Orion, et n'enregistre rien.
`GetOrion()`	1 : une structure	Le dernier relevé du module, sans aucune requête.
`RefreshOrion()`	2 : la structure et une erreur	Relit le jeu tout de suite, comme le bouton « Rafraîchir » : quatre requêtes, worker éteint compris, aucun geste. Quand la session n'a pas vu Orion (scanner à zéro), une page Installations de plus, qui rouvre les gestes si l'univers l'a. Refusée, elle rend le relevé d'avant avec l'erreur. Si une passe du module tourne, elle ne relit rien et le dit par son erreur : le relevé rendu date alors d'avant cette passe.

IsWorkerEnabled("orion"), IsWorkerRunning("orion") et RunWorkerNow("orion") marchent aussi. ListWorkers ne nomme orion que sur un univers dont le robot sait qu'il a Orion.

GetOrion rend ces champs :

Enabled : l'interrupteur. ReadAt : l'heure du relevé, dans le fuseau du compte, nil tant qu'aucune relecture n'a abouti. Error : la dernière erreur de relecture.
Lithium, LithiumCap, LithiumPerHour, NextStopSeconds : le stock, son plafond, la production des conversions, et le temps avant qu'une conversion s'arrête faute de ressource.
Conversions, une ligne par planète : Planet, Name, Coordinate, Resource (vide à l'arrêt), Load, PerHour, Endless, RemainingSeconds.
Missions : Object, Name, Level, PvP, Delivery, Stars, Coordinate, Wave, Waves, NextWaveSeconds, DisappearsInSeconds, ClaimCost, PossibleRewards, EarnedRewards, NextWave (Ships, Types, -1 pour un compte caché), FleetsFlying, FleetsHolding, FleetsReturning, Finished, Lost, ClaimWithinSeconds, RewardsToClaim. Une récompense porte Kind, Name, Quantity, Value. Lost : un autre joueur tient l'anomalie, la flotte du module a fait demi-tour, et la mission ne se réclame pas. Le module ne le voit que sur ses propres prises : une mission prise par OrionInvestigate n'en dit rien.
MissionsInUse, MissionsMax.
Scanner : MaxLevel, MaxResults, DiscoveriesInUse, DiscoveriesMax, et Cards, les cartes du dernier scan : Mission, Name, Level, PvP, Delivery, Stars, Coordinate, Duration, Waves, Distance, ClaimCost, PossibleRewards.
Planets, celles de la page Empire : Planet, Name, Coordinate, Scanner (-1 tant que cette page n'a pas été lue).

Les décomptes en secondes partent de ReadAt. Un relevé jamais fait rend des listes vides, et un script y boucle sans se poser de question.

o = GetOrion()
Print("lithium", o.Lithium, "/", o.LithiumCap, "par heure", o.LithiumPerHour)
for m in o.Missions {
	if m.Finished && !m.Lost {
		Print(m.Name, "a reclamer avant", m.ClaimWithinSeconds, "s, cout", m.ClaimCost)
	}
}

Les réglages de la page

Fonction	Rend
`GetOrionSettings()`	1 : une structure	Tous les réglages tels que le module les applique : `Enabled`, `IntervalMinutes`, `AutoClaim`, `Conversions` (`Planet`, `Resource`, `Load`), `Deliveries`, `ScanLevel`, `ScanRange`, `Transporter`, `MissionPlanet`.
`SetOrionInterval(minutes)`	1 : une erreur	L'écart entre deux relectures, de 10 à 180 minutes.
`SetOrionAutoClaim(oui)`	1 : une erreur	La case « Réclamer les récompenses des missions terminées ».
`SetOrionConversion(planète, ressource, charge)`	1 : une erreur	La conversion à tenir sur une planète. Ressource : `"metal"`, `"crystal"`, `"deuterium"` ou `"food"`. Charge : de 10 à 100, par pas de 10.
`ClearOrionConversion(planète)`	1 : une erreur	« Laisser le jeu » : le module ne tient plus cette planète. Sa conversion en cours continue.
`SetOrionDeliveries(oui)`	1 : une erreur	La case « Mener les livraisons d'anomalie ».
`SetOrionScanLevel(niveau)`	1 : une erreur	Le niveau des scans du module, 1 ou plus. Au-delà de ce que permettent les scanners, le module scanne au plus haut permis.
`SetOrionScanRange(portée)`	1 : une erreur	La portée des scans du module : 10, 50 ou 150 systèmes.
`SetOrionTransporter(genre)`	1 : une erreur	Les vaisseaux des livraisons : `"auto"` (grands d'abord, petits pour compléter), `"small"` ou `"large"`.
`SetOrionMissionPlanet(planète)`	1 : une erreur	La planète que le module vise : son relevé, ses gestes et ceux de cette page. `0` pour le laisser prendre celle au plus haut scanner, ce qu'il fait aussi quand celle-ci n'en a pas.

Chaque réglage est enregistré comme le bouton de la page, appliqué tout de suite, et survit au redémarrage. Hors de ses bornes, il est refusé et rien ne change. Rien n'est coché par une lecture : un robot qui n'a rien réglé ne fait rien de plus qu'avant.

Les gestes

Fonction	Rend
`OrionScanCost(niveau, portée)`	2 : une structure et une erreur	Le coût d'un scan : `Cost`, `Lithium`, `LithiumPerHour`, `NextStopSeconds`. Rien n'est dépensé.
`OrionScan(niveau, portée, [forcer])`	2 : une structure et une erreur	Lance un scan et rend `Cards`, comme les cartes du relevé. Dépense du lithium, et remplace les cartes du scan d'avant. Refusé faute de place, `FreeInRange` dit combien il en reste, et `forcer` à `true` accepte un scan réduit à celles-là.
`OrionInvestigate(carte)`	2 : une structure et une erreur	Prend la mission d'une carte, ou de son `Mission`. Rend `MissionsWithoutFleet` et `Discoveries`. Son horloge part à cet instant, et c'est à vous d'y envoyer une flotte.
`OrionClaim(mission)`	1 : une erreur	Réclame les récompenses d'une mission terminée, ou de son `Object`, avec les gestes du bouton « Réclamer » : le coût et le stock relus au jeu, puis le relevé après la réclamation, soit environ huit requêtes. Sous le coût, sur un coût illisible, ou sur une mission `Lost`, déjà réclamée ou encore en cours, elle rend son refus et rien ne part. Jamais de matière noire. Si une passe du module tourne, elle le dit aussi : réessayez un instant plus tard.
`OrionStartConversion(planète, ressource, charge)`	1 : une erreur	Lance ou remplace la conversion d'une planète, une fois. Pour qu'elle tienne, c'est `SetOrionConversion`.
`OrionStopConversion(planète)`	1 : une erreur	Arrête la conversion d'une planète. Si le module la tient, elle repart à sa passe suivante : retirez-la d'abord par `ClearOrionConversion`.

Une planète se désigne comme partout : un céleste, une coordonnée ou un identifiant. Une lune est refusée, elle n'a pas de scanner. Le scan se centre sur la planète que vise le module, et la mission s'y accepte : voir SetOrionMissionPlanet. Tant que la page Empire n'a pas été lue, worker éteint et sans RefreshOrion, ils partent de la planète courante.

Chaque geste attend la fin du mode manuel, puis part dans sa propre transaction, à côté de celles du worker. Sur un univers sans Orion, aucun ne part. Aucun ne se rejoue tout seul : une réponse qui ne dit rien demande de relire avant de recommencer, par RefreshOrion, et de relire encore si celle-ci répond qu'une passe tourne. Le relevé de GetOrion ne voit un geste qu'à la relecture suivante.

Le module ne mène que ce qu'il a lui-même : il ne remplace pas les cartes d'un scan de script, et il ne sert pas une mission prise par OrionInvestigate. La flotte est alors à vous.

Envoyer une flotte vers une anomalie

C'est NewFleet, avec la mission ANOMALYENCOUNTER et une destination de type ANOMALY_TYPE : "[A:4:165:9]", NewCoordinate(4, 165, 9, ANOMALY_TYPE), ou directement une carte ou une mission du relevé. SetDuration donne le maintien en heures, ramené au premier palier du jeu au-dessus (1, 2, 4, 8, 16 ou 32) qu'il admet pour cette anomalie. Sans lui, le robot prend celui qui tient jusqu'à la disparition, comme la page du jeu. Une flotte rentre de toute façon quand l'anomalie disparaît. FlightTime chiffre ce vol, à la vitesse de guerre de l'univers, si vous lui donnez la mission.

o = GetOrion()
for c in o.Scanner.Cards {
	if !c.Delivery || c.PvP { continue }
	p, err = OrionInvestigate(c)
	if err != nil { LogError(err); return }
	Print("sans flotte :", p.MissionsWithoutFleet)
	f = NewFleet()
	f.SetOrigin(GetCachedPlanets()[0])
	f.SetDestination(c)
	f.SetMission(ANOMALYENCOUNTER)
	f.SetSpeed(HUNDRED_PERCENT)
	f.AddShips(SMALLCARGO, 3)
	vol, err = f.SendNow()
	if err != nil { LogError(err); return }
	Print("parti :", vol.ID)
	break
}

Une livraison n'accepte que des transporteurs, avec au moins la soute de la flotte qui arrive. Comme tout envoi de script, celui-ci ne regarde ni la réserve de slots ni la veille : GetFleetSlotsReserved et GetNextSleepTime sont là pour ça. SendSpy prend les mêmes cibles.

Slots et messages

Fonction	Rend
`GetOrionFleetSettings()`	1 : une structure	Les réglages ci-dessous : `MaxSlots`, `CleanMessages`, `DeliveryCelestials`. Aucune requête.
`SetOrionMaxSlots(n)`	1 : une erreur	La ligne « Orion » de Paramètres > Slots de flotte : le nombre de vols d'anomalie, retours compris, de 0 (pas de plafond, l'origine) à 100. Hors de ces bornes, refusé. La réserve et les slots gardés pour les expéditions et la main flotte passent avant.
`SetOrionDeliveryCelestials(liste)`	1 : une erreur	Les célestes d'où une livraison peut partir : `["[P:4:273:12]"]`. Liste vide : tous, l'origine. Les transporteurs des prochaines expéditions restent à quai dans tous les cas.
`SetOrionCleanMessages(oui)`	1 : une erreur	La case « Effacer les messages de Fleet Command des missions finies », décochée d'origine.

Une flotte qui vise une anomalie n'est pas une attaque sur le compte : GetAttacks, IsUnderAttack, WaitAttack et OnAttackCh ne la rendent pas. L'alerte « Flotte hostile vers une anomalie » et la page des Mouvements la montrent.

Les alertes

Fonction	Rend
`WaitOrionAlert(secondes)`	2 : l'alerte et un booléen	Attend une alerte du module, zéro pour attendre sans fin. Le booléen dit si elle est venue.

Valeur	Contient
`OnOrionAlertCh`	un canal	Les mêmes alertes, à lire par `a = <-OnOrionAlertCh`.

Une alerte porte Text, sa phrase, et Kind, l'un de ces noms :

Valeur de `Kind`
`"lithium_cap"`	Le lithium a atteint son plafond.
`"rewards"`	Une mission terminée attend sa réclamation.
`"rewards_lost"`	Des récompenses sont perdues : le délai pour les réclamer est passé.
`"combat"`	Un combat pris reste sans flotte.
`"delivery"`	Une livraison prise reste sans flotte.
`"threat"`	Une flotte hostile vise une anomalie.

Ce sont celles que le worker lève à sa passe, cochées ou non dans les Notifications : worker éteint, il n'en vient aucune, et elles ne coûtent aucune requête.

for {
	a, vu = WaitOrionAlert(600)
	if !vu { continue }
	if a.Kind == "rewards" {
		SendDiscord(a.Text)
	}
}

Le Centre de contrôle

Ces fonctions, comme celles des places plus bas, marchent le worker Orion éteint. Sur un univers sans Orion, elles rendent une erreur et rien ne part au jeu.

Fonction	Rend
`OrionControlCenter(céleste)`	2 : une liste et une erreur	Lit l'onglet du Centre de contrôle d'une planète qui porte un scanner : une requête, sans jeton consommé.

Chaque ligne porte ID (4001 à 4007), Name (le nom du jeu, dans la langue du compte), Level, Bonus, Locked et UnlockLevel (la mission à réussir pour l'ouvrir).

Pour construire, posez une ligne : AddItemToQueue(céleste, 4001, 5). Le Brain ne lance jamais un de ces bâtiments de lui-même, ni tant qu'il est verrouillé : la ligne attend, marquée à l'écran.

Les places

Fonction	Rend
`OrionSlotPrices(céleste)`	2 : une structure et une erreur	Le prix de la prochaine place de chaque genre, lu sur l'onglet du scanner de cette planète : `AnomalyDiscovery` et `ScanResult`, chacun avec `Metal`, `Crystal`, `Deuterium`, `Maxed` (le jeu n'en vend plus) et `Unreadable`.
`OrionBuySlot(genre, céleste)`	1 : une erreur	Achète une place, payée par cette planète : `"anomalyDiscovery"` (une anomalie examinée de plus à la fois) ou `"scanResult"` (un résultat de plus par scan).

Le prix est relu juste avant l'achat. Rien ne part sur un prix illisible ou qui parlerait d'autre chose que de métal, de cristal et de deutérium : jamais de matière noire. La planète qui paie doit porter un scanner. Un manque de ressources se dit par une erreur (code 100047 du jeu), le plafond aussi (code 100017). Un achat ne se rejoue pas de lui-même : après une erreur, relisez le prix avant de recommencer, il a pu avoir lieu.

Monter les scanners

Fonction	Rend
`OrionProfitableScannerLevel()`	1 : un entier	Le plus haut niveau de scanner dont le lithium crédité vaut plus que la conversion du même prix, sur cet univers : 16 en vitesse 8, 17 en vitesse 10. Aucune requête.
`OrionEqualizeScanners(niveaux, somme)`	2 : une liste et une erreur	Répartit une somme de niveaux entre des scanners au moindre coût, le plus bas d'abord : `[5, 1, 3]` vers une somme de 12 rend `[5, 4, 3]`. Un calcul, aucune requête, sans les cases des planètes.

Le niveau d'anomalie maximal vaut la somme des scanners, d'après les joueurs : le jeu ne l'écrit pas.

← Workers Orion : la valeur →