Observation

Contexte d’utilisation #

API publique du SDK 0.9.0-alpha.2. Chaque entrée donne la signature Kotlin et son contrat : sens de la valeur, conditions d’utilisation et effets à connaître. Choisissez les imports du module indiqué ci-dessus.

import fr.nimby.sdk.Train
import fr.nimby.sdk.Position
import fr.nimby.sdk.Track
import fr.nimby.sdk.Station
import fr.nimby.sdk.TrackNode
import fr.nimby.sdk.TrackJunction
import fr.nimby.sdk.TrackUsage
import fr.nimby.sdk.Signal
import fr.nimby.sdk.Service
import fr.nimby.sdk.TrainDetails
import fr.nimby.sdk.Platform
import fr.nimby.sdk.LineStop
import fr.nimby.sdk.SimulationClock
import fr.nimby.sdk.SimulationTimeChange
import fr.nimby.sdk.Observation
import fr.nimby.sdk.ObservationClient
import fr.nimby.sdk.GameProcess
import fr.nimby.sdk.GameProcesses
import fr.nimby.sdk.SdkException

Choisir la lecture et interpréter les résultats #

Dans un mod, utiliser ToolContext.trains(query). Dans une application JVM, utiliser game.trains.snapshot(query = query) ; sélectionner un train demande aussi son plan de ligne. Une requête groupe tous les trains : ne pas créer une capture par train. La lecture de l’horloge et la lecture ciblée d’un train sont séparées.

Les identifiants typés sont opaques. TimetableShiftId est unique seulement avec son TimetableId. LineType distingue uniquement Depot et Other ; aucune catégorie voyageurs/fret n’est inférée. Un nom d’horaire indisponible reste null. Les tags sont des libellés, sans priorité automatique ; un héritage incomplet ou cyclique reste inconnu. VehicleModel.nameEnglish conserve le nom anglais du catalogue.

TrainVehicle décrit un véhicule dans une composition. Le type nimby.Vehicle utilisé par le calcul de conduite est un autre contrat. Ne pas mélanger les classes homonymes des packages nimby et fr.nimby.sdk.

Train #

data class Train(val id: Long, val name: String, val position: Position?, val speedKmh: Double?, val speedDefaulted: Boolean)

Observation de base d’un train dans une capture JVM. Enrichir par snapshot.train(trainId) pour joindre le service, les lieux et les métadonnées de cette même capture.

Train.id #

val id: Long

Valeur opaque à comparer et transmettre telle quelle ; ne pas la découper ni la réutiliser dans une autre partie.

Train.name #

val name: String

Nom observé du train ; les renommages ne changent pas son identité.

Train.position #

val position: Position?

Position observable ; null si non disponible.

Train.speedKmh #

val speedKmh: Double?

Vitesse mesurée en km/h ; null pour une mesure indisponible ou de secours.

Train.speedDefaulted #

val speedDefaulted: Boolean

Indique une vitesse de secours du jeu. Ce cas laisse la vitesse mesurée inconnue ; il ne prouve pas un arrêt.

Train.trainId #

val trainId: TrainId

Même identité sous le type TrainId.

Position #

data class Position(val trackId: Long, val fraction: Double, val direction: Int)

Position sur une voie : fraction longitudinale et sens. Pour construire, utiliser des identifiants observés et une fraction strictement intérieure à la voie.

Position.trackId #

val trackId: Long

Valeur opaque à comparer et transmettre telle quelle ; ne pas la découper ni la réutiliser dans une autre partie.

Position.fraction #

val fraction: Double

Fraction longitudinale : 0 à l’origine de la voie, 1 à son extrémité. Le sens ne change pas cette origine.

Position.direction #

val direction: Int

Sens observé ; -1 ou 1 requis pour construire. Ne pas déduire une orientation géographique de cette valeur.

Position.track #

val track: TrackId

Même identité sous le type TrackId.

Track #

data class Track(val id: Long, val stationId: Long?, val speedLimitKmh: Double)

Voie observée avec son éventuelle gare et sa limite de vitesse. Sa longueur appartient à TrackMetric.

Track.id #

val id: Long

Valeur opaque à comparer et transmettre telle quelle ; ne pas la découper ni la réutiliser dans une autre partie.

Track.stationId #

val stationId: Long?

Gare associée observée, si disponible.

Track.speedLimitKmh #

val speedLimitKmh: Double

Limite de vitesse de la voie en km/h, distincte de la limite du matériel.

Track.trackId #

val trackId: TrackId

Même identité sous le type TrackId.

Track.station #

val station: StationId?

stationId sous forme typée ; null si aucun identifiant disponible.

Station #

data class Station(val id: Long, val name: String)

Gare du catalogue copié. L’identité sert aux jointures, le nom à l’affichage.

Station.id #

val id: Long

Valeur opaque à comparer et transmettre telle quelle ; ne pas la découper ni la réutiliser dans une autre partie.

Station.name #

val name: String

Nom de gare copié lors de la capture.

Station.stationId #

val stationId: StationId

Même identité sous le type StationId.

TrackNode #

data class TrackNode(val id: Long, val linkA: Long?, val linkB: Long?, val x: Double, val y: Double)

Élément du graphe de voies observé. Les liens peuvent être incomplets ou non réciproques ; ils ne prouvent ni l’état d’une aiguille ni un itinéraire réservé.

TrackNode.id #

val id: Long

Valeur opaque à comparer et transmettre telle quelle ; ne pas la découper ni la réutiliser dans une autre partie.

TrackNode.linkA #

val linkA: Long?

Lien observé côté A ; null signifie inconnu/absent, pas un heurtoir prouvé.

TrackNode.linkB #

val linkB: Long?

Lien observé côté B ; null signifie inconnu/absent, pas un heurtoir prouvé.

TrackNode.x #

val x: Double

Coordonnée projetée du jeu ; pas une longitude ni une longueur de voie.

TrackNode.y #

val y: Double

Coordonnée projetée du jeu ; pas une latitude ni une longueur de voie.

TrackJunction #

data class TrackJunction(val branchTrackId: Long, val mainTrackId: Long, val fraction: Double, val mainDirection: Int, val branchDirection: Int)

Raccord observé d’une branche sur une voie principale. Décrit la géométrie de connexion, sans garantir une permission de passage.

TrackJunction.branchTrackId #

val branchTrackId: Long

Identité de la voie de branche.

TrackJunction.mainTrackId #

val mainTrackId: Long

Identité de la voie principale.

TrackJunction.fraction #

val fraction: Double

Fraction du raccord sur la voie principale.

TrackJunction.mainDirection #

val mainDirection: Int

Sens d’approche du raccord sur la voie principale.

TrackJunction.branchDirection #

val branchDirection: Int

Sens de sortie du raccord sur la branche, sans retournement.

TrackUsage #

data class TrackUsage(val trainId: Long, val trackId: Long, val from: Double, val to: Double)

Intervalle observé de réservation ou d’occupation selon la table d’origine. Plusieurs intervalles peuvent se chevaucher ; ce n’est pas une permission ni un itinéraire ordonné.

TrackUsage.trainId #

val trainId: Long

Train associé à cet intervalle.

TrackUsage.trackId #

val trackId: Long

Voie portant cet intervalle.

TrackUsage.from #

val from: Double

Borne inférieure de fraction de voie ; inférieure ou égale à to.

TrackUsage.to #

val to: Double

Borne supérieure de fraction de voie ; ne donne pas le sens de circulation.

Signal #

data class Signal(val id: Long, val position: Position, val kind: Int, val textureState: Int?, val specificState: String?, val texturePath: String?)

Signal copié avec sa position et les informations d’affichage disponibles. Une image n’est pas une preuve d’autorisation de mouvement.

Signal.id #

val id: Long

Valeur opaque à comparer et transmettre telle quelle ; ne pas la découper ni la réutiliser dans une autre partie.

Signal.position #

val position: Position

Position observée du signal.

Signal.kind #

val kind: Int

Code de type rapporté par le jeu ; ne le confondre ni avec l’aspect ni avec une priorité.

Signal.textureState #

val textureState: Int?

Indice observé d’image, si disponible ; appartient au catalogue du signal.

Signal.specificState #

val specificState: String?

État spécifique observé, sous la forme système:état ; null si indisponible.

Signal.texturePath #

val texturePath: String?

Chemin d’image observé ; null si indisponible. Ne décrit pas une règle de conduite.

Service #

data class Service(
    val trainId: Long, val lineName: String?, val status: Int?, val stationId: Long?, val flags: Int,
    val lineId: Long? = null, val stopStationId: Long? = null, val stopIndex: Int? = null,
    val gameEpochSeconds: Long? = null, val gameTimeUs: Long? = null,
    val arrivalTimeUs: Long? = null, val departureTimeUs: Long? = null, val dispatchTimeUs: Long? = null,
    val motionFlags: Int? = null, val alert: Int? = null, val locationTrackId: Long? = null,
    val stopTrackId: Long? = null, val lineKind: Int? = null,
    val arrivalRemainingSeconds: Double? = null, val departureRemainingSeconds: Double? = null,
    val dispatchRemainingSeconds: Double? = null,
)

Données de service copiées. Utiliser state, alertState, hidden, onNetwork et les dates converties pour interpréter les résultats ; les valeurs brutes restent disponibles pour diagnostic.

Service.trainId #

val trainId: Long

Valeur opaque à comparer et transmettre telle quelle ; ne pas la découper ni la réutiliser dans une autre partie.

Service.lineName #

val lineName: String?

Nom de ligne observé, optionnel.

Service.status #

val status: Int?

Code d’état observé ; préférer la propriété typée state.

Service.stationId #

val stationId: Long?

Identité de la gare du lieu de service, si disponible ; distincte de stopStationId.

Service.flags #

val flags: Int

Indicateurs de disponibilité de cet enregistrement. Préférer les propriétés optionnelles et typées pour le code métier.

Service.lineId #

val lineId: Long? = null

Identité de la ligne du service, optionnelle.

Service.stopStationId #

val stopStationId: Long? = null

Identité de la gare de l’arrêt ciblé, optionnelle.

Service.stopIndex #

val stopIndex: Int? = null

Indice d’arrêt courant à partir de zéro ; null si inconnu.

Service.gameEpochSeconds #

val gameEpochSeconds: Long? = null

Origine UTC du calendrier de simulation, en secondes depuis 1970 ; null si inconnue.

Service.gameTimeUs #

val gameTimeUs: Long? = null

Compteur observé en microsecondes depuis l’origine de simulation ; pas une date Unix.

Service.arrivalTimeUs #

val arrivalTimeUs: Long? = null

Échéance active d’arrivée en microsecondes depuis l’origine de simulation ; optionnelle.

Service.departureTimeUs #

val departureTimeUs: Long? = null

Échéance active de départ en microsecondes depuis l’origine de simulation ; optionnelle.

Service.dispatchTimeUs #

val dispatchTimeUs: Long? = null

Échéance de nouvelle tentative de dispatch, en microsecondes depuis l’origine de simulation.

Service.motionFlags #

val motionFlags: Int? = null

Indicateurs observés de présence ; préférer hidden et onNetwork.

Service.alert #

val alert: Int? = null

Code d’alerte observé ; préférer alertState.

Service.locationTrackId #

val locationTrackId: Long? = null

Voie du lieu de service, optionnelle ; distincte de la position géométrique du train.

Service.stopTrackId #

val stopTrackId: Long? = null

Voie de l’arrêt ciblé, optionnelle.

Service.lineKind #

val lineKind: Int? = null

Classification brute de ligne ; préférer isDepotLine ou Line.type.

Service.arrivalRemainingSeconds #

val arrivalRemainingSeconds: Double? = null

Secondes restantes jusqu’à l’échéance d’arrivée ; peuvent être négatives. Ne représentent pas le retard commercial prévu.

Service.departureRemainingSeconds #

val departureRemainingSeconds: Double? = null

Secondes restantes jusqu’à l’échéance de départ, bornées à zéro ; null si inconnues.

Service.dispatchRemainingSeconds #

val dispatchRemainingSeconds: Double? = null

Secondes restantes avant une nouvelle tentative de dispatch, bornées à zéro ; null si inconnues.

Service.train #

val train: TrainId

Identité typée du train de ce service.

Service.line #

val line: LineId?

lineId sous forme typée, sans nouvelle lecture.

Service.state #

val state: TrainState?

État typé dérivé du code observé ; null reste indisponible, un code non reconnu devient Other.

Service.alertState #

val alertState: TrainAlert?

Alerte typée dérivée du code observé ; null reste indisponible.

Service.hidden #

val hidden: Boolean?

Présence masquée rapportée, validée indépendamment du service complet ; null si inconnue.

Service.onNetwork #

val onNetwork: Boolean?

Présence sur le réseau rapportée, optionnelle ; ne prouve pas une permission.

Service.isDepotLine #

val isDepotLine: Boolean?

true pour une ligne dépôt, false pour une autre classification connue ; null si classification inconnue.

Service.observedAt #

val observedAt: java.time.Instant?

Compteur observé converti en calendrier UTC du jeu ; null si l’origine ou le compteur manque, ou si la conversion dépasse la plage.

Service.arrival #

val arrival: java.time.Instant?

Date UTC de l’échéance active d’arrivée. null si la conversion est impossible ; ce n’est pas nécessairement l’horaire commercial.

Service.departure #

val departure: java.time.Instant?

Date UTC de l’échéance active de départ. null si la conversion est impossible ; ce n’est pas nécessairement l’horaire commercial.

Service.dispatchRetry #

val dispatchRetry: java.time.Instant?

Date UTC de nouvelle tentative de dispatch ; pas une heure commerciale de départ. null si non convertible.

TrainDetails #

data class TrainDetails(val trainId: Long, val passengers: Int?, val scheduleId: Long?, val shiftId: Long?,
                        val orderIndex: Int? = null, val orderMode: Int? = null)

Affectation et occupants copiés selon les groupes demandés. Les propriétés typées ne calculent aucun prochain horaire.

TrainDetails.trainId #

val trainId: Long

Valeur opaque à comparer et transmettre telle quelle ; ne pas la découper ni la réutiliser dans une autre partie.

TrainDetails.passengers #

val passengers: Int?

Occupants observés ; null si inconnus ou non demandés. Ne vaut pas la capacité.

TrainDetails.scheduleId #

val scheduleId: Long?

Identité opaque de l’horaire affecté ; null si indisponible.

TrainDetails.shiftId #

val shiftId: Long?

Clé de service dans scheduleId ; ne pas la comparer seule entre horaires.

TrainDetails.orderIndex #

val orderIndex: Int? = null

Indice d’ordre observé à partir de zéro ; null si indisponible.

TrainDetails.orderMode #

val orderMode: Int? = null

Mode d’ordre observé ; préférer isMothballed pour le remisage.

TrainDetails.train #

val train: TrainId

Identité typée du train.

TrainDetails.timetable #

val timetable: Timetable?

Horaire construit depuis scheduleId, avec son identité seulement ; null si scheduleId manque.

TrainDetails.shift #

val shift: TimetableShiftId?

Identité composée disponible seulement si horaire et clé de service sont connus.

TrainDetails.isMothballed #

val isMothballed: Boolean?

Indique le remisage d’après un mode d’ordre connu ; null si non interprétable.

Platform #

data class Platform(val trackId: Long, val stationId: Long?, val name: String?)

Information de quai associée à une voie. Un nom absent n’implique pas l’absence du quai.

Platform.trackId #

val trackId: Long

Voie observée associée au quai.

Platform.stationId #

val stationId: Long?

Gare associée, si connue.

Platform.name #

val name: String?

Nom observé du quai, optionnel.

LineStop #

data class LineStop(val lineId: Long, val trackId: Long, val stationId: Long?, val index: Int, val arrivalOffsetSeconds: Int?, val departureOffsetSeconds: Int?)

Arrêt ou waypoint d’un plan de ligne ; les heures sont des offsets relatifs au plan, pas des dates absolues du train sélectionné.

LineStop.lineId #

val lineId: Long

Valeur opaque à comparer et transmettre telle quelle ; ne pas la découper ni la réutiliser dans une autre partie.

LineStop.trackId #

val trackId: Long

Identité de la voie de l’arrêt.

LineStop.stationId #

val stationId: Long?

Gare de l’arrêt ; null pour un waypoint hors gare ou une donnée inconnue.

LineStop.index #

val index: Int

Indice d’arrêt à partir de zéro dans le plan de ligne.

LineStop.arrivalOffsetSeconds #

val arrivalOffsetSeconds: Int?

Offset d’arrivée en secondes depuis l’origine du plan ; null si inconnu. Pas une date absolue du train.

LineStop.departureOffsetSeconds #

val departureOffsetSeconds: Int?

Offset de départ en secondes depuis l’origine du plan ; null si inconnu.

LineStop.line #

val line: LineId

Identité typée de la ligne.

LineStop.track #

val track: TrackId

Identité typée de la voie.

LineStop.station #

val station: StationId?

Identité typée de la gare si connue.

LineStop.plannedDwellSeconds #

val plannedDwellSeconds: Long?

departureOffsetSeconds moins arrivalOffsetSeconds, en secondes ; null si un offset manque.

SimulationClock #

data class SimulationClock(val epochSeconds: Long, val ticks: Long)

Horloge copiée du calendrier simulé. Combiner origine et compteur avec toInstant ; ne pas la confondre avec l’heure de l’ordinateur.

SimulationClock.epochSeconds #

val epochSeconds: Long

Origine du calendrier du jeu en secondes UTC depuis 1970 ; peut précéder 1970.

SimulationClock.ticks #

val ticks: Long

Compteur simulé en centièmes de seconde depuis l’origine ; doit être positif ou nul pour toInstant.

SimulationClock.toInstant #

fun toInstant(): java.time.Instant

Additionne l’origine et les ticks, en conservant les centièmes. Rejette les ticks négatifs et les dates hors plage ; aucune lecture du jeu.

SimulationTimeChange #

data class SimulationTimeChange(val clock: SimulationClock, val interventions: Long)

Résultat d’un changement explicite de date. Contient l’horloge retournée et le nombre d’interventions lors du recalcul demandé.

SimulationTimeChange.clock #

val clock: SimulationClock

Horloge retournée après la commande ; relire plus tard pour un nouvel état.

SimulationTimeChange.interventions #

val interventions: Long

Nombre d’interventions du recalcul ; zéro lorsqu’aucun recalcul n’a été demandé.

Observation #

data class Observation(
    val capturedAtMillis: Long,
    val processId: Int,
    val gameHash: String,
    val trains: List<Train>,
    val tracks: List<Track>,
    val stations: List<Station>,
    val nodes: List<TrackNode>,
    val junctions: List<TrackJunction>,
    val signals: List<Signal>,
    val services: List<Service>,
    val details: List<TrainDetails>,
    val platforms: List<Platform>,
    val reservations: List<TrackUsage>?,
    val occupations: List<TrackUsage>?,
    val selectedPath: List<Long>?,
    val lineStops: List<LineStop>?,
    val clock: SimulationClock?,
    
    val trackMetrics: List<TrackMetric>? = null,
    
    val lines: List<Line>? = null, val tags: List<Tag>? = null, val trainMetadata: List<TrainMetadata>? = null,
    val vehicleModels: List<VehicleModel>? = null,
)

Ensemble de valeurs copiées, conservable après fermeture. Son contenu dépend du mode de capture et des groupes demandés. Les jointures locales n’actualisent rien ; une capture ne garantit pas un tick atomique.

Observation.capturedAtMillis #

val capturedAtMillis: Long

Horodatage UTC de l’ordinateur, en millisecondes depuis 1970. Il ne mesure pas le temps simulé.

Observation.processId #

val processId: Int

PID du jeu source de cette capture ; choisir explicitement la partie lors de la connexion.

Observation.gameHash #

val gameHash: String

Empreinte du binaire du jeu observé, utile dans un diagnostic de compatibilité ; pas une identité de sauvegarde.

Observation.trains #

val trains: List<Train>

Observations de base des trains du lot ; selectedTrain ne filtre pas cette liste.

Observation.tracks #

val tracks: List<Track>

Voies demandées par le mode de capture. Une requête spécialisée sans lieux peut laisser cette liste vide.

Observation.stations #

val stations: List<Station>

Gares demandées par le mode de capture ; liste vide ne prouve pas un monde sans gares.

Observation.nodes #

val nodes: List<TrackNode>

Graphe observé de la capture complète ; vide dans la capture spécialisée de trains et éventuellement si indisponible.

Observation.junctions #

val junctions: List<TrackJunction>

Raccords observés de la capture complète ; vide dans la capture spécialisée, sans preuve d’absence d’aiguilles.

Observation.signals #

val signals: List<Signal>

Signaux observés de la capture complète ; la capture spécialisée de trains ne les demande pas.

Observation.services #

val services: List<Service>

Services demandés et observables ; une liste vide peut aussi résulter d’un groupe non demandé ou indisponible.

Observation.details #

val details: List<TrainDetails>

Affectations/occupants selon les options de lecture ; interpréter chaque propriété facultative séparément.

Observation.platforms #

val platforms: List<Platform>

Quais de la capture complète, si observables ; non demandés dans la capture spécialisée.

Observation.reservations #

val reservations: List<TrackUsage>?

Intervalles de réservation, si observables ; null dans une capture spécialisée. Une réservation n’est pas une occupation.

Observation.occupations #

val occupations: List<TrackUsage>?

Intervalles d’occupation, si observables ; null dans une capture spécialisée. Une table inconnue ne prouve pas une voie libre.

Observation.selectedPath #

val selectedPath: List<Long>?

Chemin du train sélectionné dans une capture complète ; null si non demandé ou indisponible. Pas une permission de passage.

Observation.lineStops #

val lineStops: List<LineStop>?

Plan de ligne demandé pour selectedTrain ; null si non demandé ou indisponible. Peut dépasser sa course partielle.

Observation.clock #

val clock: SimulationClock?

Horloge simulée copiée avec la capture, si disponible.

Observation.trackMetrics #

val trackMetrics: List<TrackMetric>? = null

Longueurs observées des voies de la capture complète ; null si non disponibles ou non demandées. Une ligne manquante reste inconnue.

Observation.lines #

val lines: List<Line>? = null

Catalogue des lignes demandé explicitement ; null si non demandé ou indisponible.

Observation.tags #

val tags: List<Tag>? = null

Catalogue des tags demandé explicitement ; null si non demandé ou indisponible.

Observation.trainMetadata #

val trainMetadata: List<TrainMetadata>? = null

Métadonnées enrichies des trains selon TrainQuery ; null hors de cette capture ou si indisponibles.

Observation.vehicleModels #

val vehicleModels: List<VehicleModel>? = null

Modèles référencés par les compositions demandées ; null si non demandés ou indisponibles.

Observation.train #

fun train(id: Long): TrainRecord?

Recherche indexée de fiche jointe du train dans cette capture uniquement. null si aucune donnée correspondante ; aucune nouvelle lecture du jeu.

Observation.service #

fun service(trainId: Long): Service?

Recherche indexée de service du train dans cette capture uniquement. null si aucune donnée correspondante ; aucune nouvelle lecture du jeu.

Observation.train #

fun train(id: TrainId): TrainRecord?

Recherche indexée de fiche jointe du train dans cette capture uniquement. null si aucune donnée correspondante ; aucune nouvelle lecture du jeu.

Observation.service #

fun service(id: TrainId): Service?

Recherche indexée de service du train dans cette capture uniquement. null si aucune donnée correspondante ; aucune nouvelle lecture du jeu.

Observation.details #

fun details(trainId: Long): TrainDetails?

Recherche indexée de fiche d’affectation/occupants du train dans cette capture uniquement. null si aucune donnée correspondante ; aucune nouvelle lecture du jeu.

Observation.details #

fun details(id: TrainId): TrainDetails?

Recherche indexée de fiche d’affectation/occupants du train dans cette capture uniquement. null si aucune donnée correspondante ; aucune nouvelle lecture du jeu.

Observation.station #

fun station(id: Long): Station?

Recherche indexée de gare dans cette capture uniquement. null si aucune donnée correspondante ; aucune nouvelle lecture du jeu.

Observation.station #

fun station(id: StationId): Station?

Recherche indexée de gare dans cette capture uniquement. null si aucune donnée correspondante ; aucune nouvelle lecture du jeu.

Observation.track #

fun track(id: Long): Track?

Recherche indexée de voie dans cette capture uniquement. null si aucune donnée correspondante ; aucune nouvelle lecture du jeu.

Observation.track #

fun track(id: TrackId): Track?

Recherche indexée de voie dans cette capture uniquement. null si aucune donnée correspondante ; aucune nouvelle lecture du jeu.

Observation.platform #

fun platform(trackId: Long): Platform?

Recherche indexée de information de quai pour cette voie dans cette capture uniquement. null si aucune donnée correspondante ; aucune nouvelle lecture du jeu.

Observation.platform #

fun platform(trackId: TrackId): Platform?

Recherche indexée de information de quai pour cette voie dans cette capture uniquement. null si aucune donnée correspondante ; aucune nouvelle lecture du jeu.

Observation.line #

fun line(id: LineId): Line?

Recherche indexée de ligne du catalogue dans cette capture uniquement. null si aucune donnée correspondante ; aucune nouvelle lecture du jeu.

Observation.tag #

fun tag(id: TagId): Tag?

Recherche indexée de tag du catalogue dans cette capture uniquement. null si aucune donnée correspondante ; aucune nouvelle lecture du jeu.

Observation.metadata #

fun metadata(id: TrainId): TrainMetadata?

Recherche indexée de métadonnée enrichie du train dans cette capture uniquement. null si aucune donnée correspondante ; aucune nouvelle lecture du jeu.

Observation.tagsForLine #

fun tagsForLine(id: LineId): List<Tag>?

Réunit les tags déclarés de la ligne et de ses parents, sans doublons. null si une ligne, un parent ou ses tags sont inconnus, si un cycle apparaît ou si les limites sont dépassées. Ne produit aucune priorité.

ObservationClient #

interface ObservationClient : AutoCloseable

Contrat d’une source d’observations fermable. Utile pour injecter une source contrôlée dans les tests d’une application ; NimbyClient est l’implémentation reliée au jeu.

ObservationClient.capture #

fun capture(selectedTrainId: Long? = null): Observation

Capture les tables du réseau et les observations usuelles. Un train sélectionné ajoute son chemin et son plan de ligne ; il ne filtre pas la liste des trains. Les tables sont copiées sans garantir un tick atomique.

GameProcess #

data class GameProcess(val pid: Int, val executable: String)

Processus de jeu découvert. La découverte ne prouve ni qu’une partie est chargée ni que le SDK est compatible.

GameProcess.pid #

val pid: Int

Identifiant de processus à passer explicitement à connect.

GameProcess.executable #

val executable: String

Chemin de l’exécutable rapporté par le système.

GameProcesses #

object GameProcesses

Découverte de processus visibles de NIMBY Rails. Préférer Nimby.runningGames au point d’entrée de l’application.

GameProcesses.discover #

fun discover(): List<GameProcess>

Liste les exécutables de jeu reconnus parmi les processus visibles. Retourne une liste vide si aucun n’est visible ; ne sélectionne ni n’ouvre une connexion.

SdkException #

class SdkException(val status: Int, operation: String) : IllegalStateException

Échec d’une opération SDK. Conserver message et statut pour le diagnostic ; distinguer d’un résultat optionnel null. Ne pas relancer automatiquement une écriture après exception.

SdkException.status #

val status: Int

Code du refus : notamment 2 accès impossible, 7 jeu non pris en charge, 8 donnée indisponible, 11 jeu fermé. Conserver les autres codes sans inventer leur signification.