Mod — SDK 0.9 — Wiki NimbyRails France

Contexte d’utilisation

Module	Package	Source SDK
Kotlin/Native	nimby	kotlin/src/nimby/Mod.kt

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.

Imports de cette page

import nimby.Checkbox
import nimby.SignalType
import nimby.Occupancy
import nimby.SettingsStatus
import nimby.Observation
import nimby.Decision
import nimby.Signal
import nimby.Vehicle
import nimby.DrivingSettings
import nimby.Constraint
import nimby.DrivingInput
import nimby.DrivingPlan
import nimby.DrivingFlag
import nimby.DrivingRule
import nimby.SignallingMod
import nimby.maximumSignalNetworkSize
import nimby.prepareObservedNetwork
import nimby.evaluateNetwork

Unités et données inconnues

Propriété / famille	Unité ou sens
speedMps, reopenedSpeedMps	mètres par seconde ; km/h ÷ 3,6.
beginM, endM, headM, lengthM, marginM	mètres.
…Mps2	mètres par seconde carrée.
emptyMassKg, extraMassKg	kilogrammes.
tractiveEffortN / powerW	newtons / watts.
Observation.fresh	La fraîcheur des observations reçues.
Occupancy.Unknown	Absence de preuve de canton libre ou occupé.
DrivingPlan.available	Disponibilité du calcul du mod, pas permission native.

Signal, Observation et DrivingSettings de nimby concernent le mod natif. Les types de même nom dans fr.nimby.sdk appartiennent au client JVM : vérifiez vos imports.

Checkbox

nimby · class

data class Checkbox(val name: String, val label: String, val description: String, val defaultValue: Boolean = false,
    
    val onlyWhenEnabled: Boolean = false)

Déclaration d’un réglage booléen persistant propre à un modèle de signal. label et description acceptent tr ; name reste une clé stable. La case n’a d’effet métier que si les règles la consultent.

Checkbox.name

nimby · val

val name: String

Clé enregistrée pour chaque signal, locale au modèle ; ne pas la traduire ni la renommer pour changer un libellé.

Checkbox.label

nimby · val

val label: String

Texte affiché à côté de la case ; accepte tr pour suivre la langue du jeu.

Checkbox.description

nimby · val

val description: String

Aide affichée sous la case, avec retour à la ligne. Une chaîne vide supprime cette ligne ; accepte tr.

Checkbox.defaultValue

nimby · val

val defaultValue: Boolean = false

Valeur utilisée lorsqu’aucune valeur n’est enregistrée pour cette clé ; ne remplace pas un choix sauvegardé.

Checkbox.onlyWhenEnabled

nimby · val

val onlyWhenEnabled: Boolean = false

Affiche la case seulement tant qu’elle est vraie. Adapté à un avertissement à acquitter ; une fois décochée, elle disparaît.

SignalType

nimby · class

data class SignalType(
    val id: String,
    val title: String,
    val textureSet: String,
    val checkboxes: List<Checkbox> = emptyList(),
    
    val observeApproach: Boolean = false,
    val actions: List<SignalAction> = emptyList(),
    
    val approachBlocks: Int = 1,
    
    val construction: SignalConstruction? = null,
    val numbers: List<NumberSetting> = emptyList()
)

Description publique d’un modèle constructible : identité, catalogue, réglages et actions. Un mod accepte 1 à 16 types aux identifiants et catalogues distincts. Les règles et les images se déclarent avec signalModel.

SignalType.id

nimby · val

val id: String

Identifiant stable du modèle utilisé dans Signal.type et les sauvegardes. Distinct dans le mod ; ne pas traduire.

SignalType.title

nimby · val

val title: String

Titre affiché dans le panneau de réglages de ce modèle ; accepte tr. Le nom constructible est déclaré séparément.

SignalType.textureSet

nimby · val

val textureSet: String

Identifiant stable du catalogue de textures. Deux modèles du même mod ne peuvent pas partager ce catalogue.

SignalType.checkboxes

nimby · val

val checkboxes: List<Checkbox> = emptyList()

Déclarations des réglages booléens de ce type, avec clés uniques. Utilisez checkbox dans le builder pour enregistrer les options consultées par les règles.

SignalType.observeApproach

nimby · val

val observeApproach: Boolean = false

Demande l’observation d’un train orienté vers ce signal. false évite cette demande ; true ne réserve aucun itinéraire et ne donne aucune permission de mouvement.

SignalType.actions

nimby · val

val actions: List<SignalAction> = emptyList()

Boutons de services optionnels, jusqu’à 16 avec identifiants distincts. Une action manque si son fournisseur ou son service est indisponible.

SignalType.approachBlocks

nimby · val

val approachBlocks: Int = 1

Portée amont de l’observation d’approche, de 1 à 16 cantons. 1 signifie le canton immédiatement derrière le signal ; utilisé seulement si observeApproach=true.

SignalType.construction

nimby · val

val construction: SignalConstruction? = null

Ressources et paramètres servant à générer l’entrée constructible. null signifie qu’aucune déclaration de construction n’est fournie ici.

SignalType.numbers

nimby · val

val numbers: List<NumberSetting> = emptyList()

Jusqu’à quatre réglages entiers persistants aux noms distincts. Déclarez-les avec number pour que le modèle fournisse aussi leurs valeurs par défaut.

Occupancy

nimby · class

enum class Occupancy {
    Unknown,
    Clear,
    Occupied
}

Occupation physique du canton observé. L’entrée de la tête l’occupe ; la queue doit le dégager. Une portion connue peut prouver une occupation, mais ne suffit pas à prouver un canton libre.

Occupancy.Unknown

nimby · enum-entry

Unknown

Occupation indéterminée : les données ne permettent pas de conclure libre ou occupé. Ne pas traiter comme Clear.

Occupancy.Clear

nimby · enum-entry

Clear

Canton observé physiquement libre. Vérifier aussi fresh et routeKnown ; ce constat seul ne crée aucune autorisation de conduite.

Occupancy.Occupied

nimby · enum-entry

Occupied

Présence physique observée dans le canton ou sa portion aval connue, même si sa limite complète reste inconnue.

SettingsStatus

nimby · class

enum class SettingsStatus {
    Unavailable,
    Absent,
    Present
}

Qualifie la disponibilité du profil de réglages indépendamment de ses valeurs. Un défaut déclaré n’est pas la preuve d’une lecture valide.

SettingsStatus.Unavailable

nimby · enum-entry

Unavailable

Le profil n’a pas pu être lu. SignalRuleContext rend alors l’observation non fraîche ; choisissez un repli explicite.

SettingsStatus.Absent

nimby · enum-entry

Absent

Aucun profil présent dans l’observation. SignalRuleContext applique les défauts déclarés tout en conservant ce statut consultable.

SettingsStatus.Present

nimby · enum-entry

Present

Profil disponible. Une clé nouvelle peut encore prendre sa valeur par défaut ; Present ne signifie pas que toutes les clés ont été enregistrées manuellement.

Observation

nimby · class

data class Observation(
    val block: Occupancy = Occupancy.Unknown, val fresh: Boolean = false,
    val routeKnown: Boolean = false, val forcedStop: Boolean = false,
    val lampFailed: Boolean = false, val redFlashCondition: Boolean = false, val next: Int = 0,
    val approachingTrain: Long? = null
)

Valeurs copiées utilisées par une règle ou un test isolé. Les défauts représentent une observation inconnue et non fraîche. Distinguez occupation, validité de l’itinéraire et demande d’approche.

Observation.block

nimby · val

val block: Occupancy = Occupancy.Unknown

Occupation physique observée ; Unknown par défaut. Une règle doit traiter explicitement l’inconnu.

Observation.fresh

nimby · val

val fresh: Boolean = false

Indique que l’observation est utilisable pour ce calcul. false interdit d’en déduire qu’une voie est libre ; aucun âge en millisecondes n’est fourni ici.

Observation.routeKnown

nimby · val

val routeKnown: Boolean = false

Indique que le parcours observé est connu. Indépendant de block : une occupation partielle peut être connue sans parcours complet.

Observation.forcedStop

nimby · val

val forcedStop: Boolean = false

Entrée booléenne de demande d’arrêt, notamment pour les scénarios isolés. Le mod choisit sa priorité dans ses règles ; ce champ n’est pas lui-même une consigne publiée.

Observation.lampFailed

nimby · val

val lampFailed: Boolean = false

Entrée de défaut d’éclairage disponible pour les règles et tests. Ne présume ni diagnostic automatique de texture ni aspect imposé par le SDK.

Observation.redFlashCondition

nimby · val

val redFlashCondition: Boolean = false

Condition booléenne destinée à l’interprétation du mod dans un calcul isolé. Son nom n’installe aucune règle nationale ni animation automatique.

Observation.next

nimby · val

val next: Int = 0

Code local de l’aspect suivant dans un diagnostic isolé. En réseau, utilisez le voisin typé de rules ; ce nombre n’est pas un identifiant de signal.

Observation.approachingTrain

nimby · val

val approachingTrain: Long? = null

Identifiant observé du train en approche, ou null. Utilisez approachingTrain ou trainApproaching du contexte pour bénéficier du contrôle de fraîcheur.

Decision

nimby · class

data class Decision(val aspect: Int, val reason: Int)

Résultat opaque d’un calcul de signal. Pour les modèles indépendants, utilisez mod.indication(decision) puis of(model) ; ne persistez pas les codes et ne les indexez pas dans une enum.

Decision.aspect

nimby · val

val aspect: Int

Code d’aspect opaque appartenant à la déclaration du mod. Sa valeur brute ne permet pas de comparer deux modèles.

Decision.reason

nimby · val

val reason: Int

Code de motif opaque. Décodez-le avec l’indication du mod pour retrouver l’enum propre au modèle.

Signal

nimby · class

data class Signal(
    val id: Long = 0, val nextSignal: Long = 0, val settings: Map<String, Boolean> = emptyMap(),
    val observation: Observation = Observation(), val settingsStatus: SettingsStatus = SettingsStatus.Present,
    
    val type: String = ""
)

Valeur de travail d’un signal dans le réseau du mod. Identité, lien aval, réglages et observation sont réunis pour une règle pure. Les valeurs par défaut facilitent les tests isolés, pas l’invention d’identités en jeu.

Signal.id

nimby · val

val id: Long = 0

Identifiant du signal dans la partie. Un réseau évalué exige des identifiants non nuls et uniques.

Signal.nextSignal

nimby · val

val nextSignal: Long = 0

Identifiant du signal aval fourni par le réseau ; zéro ou un lien absent ne constitue pas un voisin libre.

Signal.settings

nimby · val

val settings: Map<String, Boolean> = emptyMap()

Carte de réglages effectifs de ce signal. Pour un entier, utilisez NumberSetting.read ; modifier une copie ne persiste rien dans la partie.

Signal.observation

nimby · val

val observation: Observation = Observation()

Valeurs physiques et de validité sur lesquelles porte cette évaluation ; les données ne se rafraîchissent pas toutes seules.

Signal.settingsStatus

nimby · val

val settingsStatus: SettingsStatus = SettingsStatus.Present

Disponibilité du profil, indépendante du contenu de settings. Les règles peuvent distinguer absence et indisponibilité.

Signal.type

nimby · val

val type: String = ""

Identifiant SignalType fourni pour ce signal. Une chaîne vide sélectionne le premier type dans les helpers de calcul ; préférez un type explicite dans les tests multi-modèles.

Vehicle

nimby · class

data class Vehicle(
    val maxSpeedMps: Double = 0.0, val maxAccelerationMps2: Double = 0.0,
    val serviceBrakingMps2: Double = 0.0, val tractiveEffortN: Double = 0.0,
    val powerW: Double = 0.0, val emptyMassKg: Double = 0.0,
    val extraMassKg: Double = 0.0, val lengthM: Double = 0.0
)

Caractéristiques utilisées par un calcul de conduite, en unités SI. Les zéros par défaut ne prouvent pas une mesure valide. Ce type d’entrée ne remplace pas les données TrainMaterial observées.

Vehicle.maxSpeedMps

nimby · val

val maxSpeedMps: Double = 0.0

Vitesse maximale du matériel en mètres par seconde ; ce n’est pas la vitesse actuelle du train.

Vehicle.maxAccelerationMps2

nimby · val

val maxAccelerationMps2: Double = 0.0

Accélération maximale fournie au calcul, en mètres par seconde carrée.

Vehicle.serviceBrakingMps2

nimby · val

val serviceBrakingMps2: Double = 0.0

Capacité de décélération de service, exprimée comme une grandeur en m/s².

Vehicle.tractiveEffortN

nimby · val

val tractiveEffortN: Double = 0.0

Effort de traction en newtons, distinct de la puissance et de l’accélération.

Vehicle.powerW

nimby · val

val powerW: Double = 0.0

Puissance en watts ; convertir les kilowatts en multipliant par 1000 avant ce calcul.

Vehicle.emptyMassKg

nimby · val

val emptyMassKg: Double = 0.0

Masse à vide en kilogrammes, sans la charge supplémentaire.

Vehicle.extraMassKg

nimby · val

val extraMassKg: Double = 0.0

Charge supplémentaire en kilogrammes, à considérer avec emptyMassKg.

Vehicle.lengthM

nimby · val

val lengthM: Double = 0.0

Longueur totale en mètres, notamment utile au dégagement par l’arrière.

DrivingSettings

nimby · class

data class DrivingSettings(val brakeUse: Double = 0.8, val responseSeconds: Double = 2.0, val marginM: Double = 10.0)

Paramètres proposés au callback de planification : part du freinage, temps de réponse et marge. Le SDK les transmet au calcul ; le callback doit définir et valider sa politique.

DrivingSettings.brakeUse

nimby · val

val brakeUse: Double = 0.8

Part du freinage de service proposée au planificateur, sans unité ; 0,8 par défaut.

DrivingSettings.responseSeconds

nimby · val

val responseSeconds: Double = 2.0

Temps de réponse à intégrer au calcul, en secondes ; 2 par défaut.

DrivingSettings.marginM

nimby · val

val marginM: Double = 10.0

Marge de distance proposée, en mètres ; 10 par défaut.

Constraint

nimby · class

data class Constraint(val source: Long, val beginM: Double, val endM: Double, val speedMps: Double, val releaseByRear: Boolean = true)

Restriction de vitesse pour un calcul de planification. beginM et endM utilisent le même repère longitudinal que DrivingInput.headM ; cette valeur ne publie pas de restriction dans la partie.

Constraint.source

nimby · val

val source: Long

Identifiant de la source de restriction, conservé pour expliquer quelle contrainte limite le résultat.

Constraint.beginM

nimby · val

val beginM: Double

Début de la zone contrainte, en mètres dans le repère longitudinal du calcul.

Constraint.endM

nimby · val

val endM: Double

Fin de la zone contrainte, dans le même repère en mètres que beginM.

Constraint.speedMps

nimby · val

val speedMps: Double

Plafond de vitesse de la contrainte, en m/s ; zéro représente un objectif d’arrêt.

Constraint.releaseByRear

nimby · val

val releaseByRear: Boolean = true

Demande au planificateur de conserver la restriction jusqu’au dégagement par la queue ; true par défaut.

DrivingInput

nimby · class

data class DrivingInput(
    val headM: Double = 0.0, val speedMps: Double = 0.0, val lineSpeedMps: Double = 0.0,
    val fresh: Boolean = false, val routeKnown: Boolean = false,
    val onSight: Boolean = false, val visibleClearM: Double? = null
)

Situation d’entrée d’un calcul de conduite. Les positions sont longitudinales, les vitesses en m/s ; fresh et routeKnown doivent être traités avant de produire un plan utilisable.

DrivingInput.headM

nimby · val

val headM: Double = 0.0

Position longitudinale de la tête en mètres, dans le même repère que les contraintes.

DrivingInput.speedMps

nimby · val

val speedMps: Double = 0.0

Vitesse courante fournie au calcul, en mètres par seconde.

DrivingInput.lineSpeedMps

nimby · val

val lineSpeedMps: Double = 0.0

Limite de ligne fournie au calcul, en m/s, indépendante du maximum du matériel.

DrivingInput.fresh

nimby · val

val fresh: Boolean = false

Validité temporelle des données d’entrée ; false par défaut. Le callback doit décider d’un repli lorsque les données sont périmées.

DrivingInput.routeKnown

nimby · val

val routeKnown: Boolean = false

Indique si le parcours nécessaire au calcul est connu ; false par défaut ne permet pas de supposer une voie libre.

DrivingInput.onSight

nimby · val

val onSight: Boolean = false

Indique une situation de marche à vue pour le calcul ; ne crée aucune permission de franchissement.

DrivingInput.visibleClearM

nimby · val

val visibleClearM: Double? = null

Distance physiquement libre connue en mètres, ou null si indisponible. null ne signifie pas une distance infinie.

DrivingPlan

nimby · class

data class DrivingPlan(
    val available: Boolean = false, val speedCeilingMps: Double = 0.0,
    val serviceDecelerationMps2: Double = 0.0, val accelerationMps2: Double = 0.0,
    val brakingRequired: Boolean = false, val limitingSource: Long = 0
)

Résultat de calcul ou de diagnostic renvoyé par plan. Il ne commande pas directement le train ; la conduite en jeu utilise les DrivingRule publiées pour les signaux.

DrivingPlan.available

nimby · val

val available: Boolean = false

true seulement si le callback fournit un résultat exploitable. false par défaut : les autres zéros ne constituent pas une consigne d’arrêt.

DrivingPlan.speedCeilingMps

nimby · val

val speedCeilingMps: Double = 0.0

Plafond calculé en m/s, à interpréter seulement lorsque available=true.

DrivingPlan.serviceDecelerationMps2

nimby · val

val serviceDecelerationMps2: Double = 0.0

Décélération de service retenue par le calcul, en m/s².

DrivingPlan.accelerationMps2

nimby · val

val accelerationMps2: Double = 0.0

Accélération signée proposée par le calcul, en m/s² ; négative pour une décélération.

DrivingPlan.brakingRequired

nimby · val

val brakingRequired: Boolean = false

Indique que le planificateur estime un freinage nécessaire ; ce diagnostic n’actionne pas les freins.

DrivingPlan.limitingSource

nimby · val

val limitingSource: Long = 0

Source de la contrainte limitante choisie par le planificateur ; zéro par défaut si aucune n’est renseignée.

DrivingFlag

nimby · class

enum class DrivingFlag(val bit: Int) {
    Clear(1),
    HoldToClear(2),
    Stop(4),
    FollowTarget(8),
    OnSight(16),
    StopThenProceed(32),
    CancelAtNextClear(64),
    ApproachPassable(128)
}

Politiques qui composent une DrivingRule. Préférez les helpers AutomaticDriving, qui vérifient les combinaisons et les vitesses attendues.

DrivingFlag.bit

nimby · val

val bit: Int

Valeur numérique associée au drapeau. Les mods utilisent le Set<DrivingFlag> et les helpers ; aucun masque manuel n’est nécessaire.

DrivingFlag.Clear

nimby · enum-entry

Clear(1)

Marque une permission Clear servant de point de libération aux politiques qui la demandent.

DrivingFlag.HoldToClear

nimby · enum-entry

HoldToClear(2)

Conserve une restriction jusqu’au passage effectif d’un Clear puis au dégagement de ce point par la queue.

DrivingFlag.Stop

nimby · enum-entry

Stop(4)

Demande un arrêt au point visé. Seul, ce drapeau n’autorise pas de franchissement après l’arrêt.

DrivingFlag.FollowTarget

nimby · enum-entry

FollowTarget(8)

Permet de suivre la vitesse numérique déclarée par la cible d’une annonce ; n’interprète pas sa couleur.

DrivingFlag.OnSight

nimby · enum-entry

OnSight(16)

Politique de marche limitée avec freinage sur l’espace physiquement libre jusqu’au prochain signal.

DrivingFlag.StopThenProceed

nimby · enum-entry

StopThenProceed(32)

Avec Stop et OnSight, exige un arrêt préalable avant une entrée restreinte explicitement autorisée.

DrivingFlag.CancelAtNextClear

nimby · enum-entry

CancelAtNextClear(64)

Politique optionnelle d’annulation d’une annonce au prochain Clear. Le helper l’accepte seulement avec FollowTarget à deux signaux.

DrivingFlag.ApproachPassable

nimby · enum-entry

ApproachPassable(128)

Autorise le franchissement du signal courant selon la vitesse mémorisée, sans lever les autres restrictions.

DrivingRule

nimby · class

data class DrivingRule(
    val speedMps: Double = -1.0, val reopenedSpeedMps: Double = 0.0,
    val signalsAhead: Int = 0, val flags: Set<DrivingFlag> = emptySet()
)

Consigne déclarative de conduite associée à une indication. Privilégiez AutomaticDriving pour valider cible, vitesses et permissions. Construire une valeur ne la publie pas.

DrivingRule.speedMps

nimby · val

val speedMps: Double = -1.0

Vitesse cible en m/s ; zéro pour un arrêt. La valeur −1 par défaut signifie qu’aucun plafond numérique n’est fourni, notamment pour Clear.

DrivingRule.reopenedSpeedMps

nimby · val

val reopenedSpeedMps: Double = 0.0

Vitesse de remplacement à la réouverture d’une cible, ou plafond après entrée pour la marche restreinte ; en m/s. Le helper choisi définit ce rôle.

DrivingRule.signalsAhead

nimby · val

val signalsAhead: Int = 0

Position de la cible : 0 pour le signal courant, 1 ou 2 pour un signal aval. Les helpers limitent les valeurs selon la politique.

DrivingRule.flags

nimby · val

val flags: Set<DrivingFlag> = emptySet()

Ensemble explicite des politiques de passage, d’arrêt et de libération. Un ensemble vide ne donne aucune permission implicite.

SignallingMod

nimby · class

abstract class SignallingMod : GameMod

Base d’un mod de signalisation. Utilisez signalMod et signalModel pour construire son implémentation ; les méthodes de calcul restent appelables avec des valeurs copiées dans les tests.

SignallingMod.prepareNetwork

nimby · fun

open fun prepareNetwork(signals: List<Signal>): List<Signal>

Transformation pure des réglages effectifs du réseau observé. Conservez ordre, nombre, identités, liens, types et observations ; les valeurs dérivées ne sont pas sauvegardées. Par défaut, retourne la liste reçue.

SignallingMod.textureSet

nimby · val

open val textureSet: String = ""

Catalogue de la déclaration à un seul type. Pour plusieurs modèles, utilisez signalTypes et le catalogue de chaque SignalType.

SignallingMod.checkboxes

nimby · val

open val checkboxes: List<Checkbox>

Réglages de la déclaration à un seul type. Les nouveaux modèles enregistrent leurs propres cases dans signalModel.

SignallingMod.signalTypes

nimby · val

open val signalTypes: List<SignalType>

Types constructibles déclarés par le mod. Ils doivent posséder des identifiants et catalogues distincts, validés avant utilisation.

SignallingMod.migrateSettings

nimby · fun

open fun migrateSettings(type: String, saved: Map<String, Boolean>): Map<String, Boolean>

Convertit les clés effectivement enregistrées d’un type lors du chargement du profil. Le SDK complète ensuite les défauts ; ne pas inventer ici des valeurs pour les clés absentes.

SignallingMod.maximumLineSpeed

nimby · val

open val maximumLineSpeed: Boolean = false

Option de conduite remplaçant le plafond de marche lié à l’horaire par le maximum du matériel. Limites de voie et cibles de freinage restent applicables. false par défaut ; peut concerner aussi les trains sans contrainte de signal du mod.

SignallingMod.diagnosticFile

nimby · val

open val diagnosticFile: String = "nimby-kotlin-faults.jsonl"

Nom du fichier de diagnostic des défauts du mod ; nimby-kotlin-faults.jsonl par défaut. Il ne remplace pas les journaux d’actions de ToolContext.log.

SignallingMod.unknownDecision

nimby · val

abstract val unknownDecision: Decision

Repli de la déclaration par défaut lorsque le calcul isolé ne fournit pas d’indication. Pour un mod multi-modèles, demander unknownDecision(type).

SignallingMod.invalidNetworkDecision

nimby · val

abstract val invalidNetworkDecision: Decision

Repli de la déclaration par défaut pour un lien manquant ou cyclique nécessaire au calcul. La surcharge avec type choisit le modèle courant.

SignallingMod.modelLocalIndications

nimby · val

open val modelLocalIndications: Boolean = false

Indique que les indications conservent l’identité de leur modèle. Fourni par signalMod ; les auteurs lisent les décisions avec indication et of.

SignallingMod.unknownDecision

nimby · fun

open fun unknownDecision(type: String): Decision

Renvoie le repli d’observation du type demandé. Ce résultat opaque se lit avec indication pour retrouver ses enums.

SignallingMod.invalidNetworkDecision

nimby · fun

open fun invalidNetworkDecision(type: String): Decision

Renvoie le repli de réseau invalide du modèle demandé, notamment quand une dépendance aval ne peut pas être résolue.

SignallingMod.indication

nimby · fun

open fun indication(decision: Decision): SignalIndication?

Décode une décision produite par les modèles indépendants de ce mod. null signifie un code non reconnu ou une implémentation sans cette lecture ; utilisez ensuite of(model).

SignallingMod.evaluate

nimby · fun

abstract fun evaluate(settings: Map<String, Boolean>, observation: Observation): Decision

Calcule une indication isolée du type par défaut, sans résoudre de réseau. Pour plusieurs types, préférez la surcharge avec type ; ce calcul ne publie rien en jeu.

SignallingMod.evaluate

nimby · fun

open fun evaluate(type: String, settings: Map<String, Boolean>, observation: Observation): Decision

Calcule le type demandé à partir de réglages et d’une observation copiés. Utilise son callback evaluate ou sa règle isolée ; ne remplace pas evaluateNetwork pour les dépendances aval.

SignallingMod.decide

nimby · fun

abstract fun decide(signal: Signal, next: Decision?): Decision?

Étape pure de résolution : next=null au premier appel. Retourner une décision conclut localement ; retourner null demande la résolution du voisin. Un second null utilise le repli de réseau invalide.

SignallingMod.fromLive

nimby · fun

open fun fromLive(signal: Signal): Signal

Prépare la valeur observée avec le callback prepareObservation du type. Le comportement par défaut est l’identité ; cette transformation ne modifie pas le signal dans la partie.

SignallingMod.texture

nimby · fun

abstract fun texture(decision: Decision, simulationMs: Long, halfPeriodMs: Long): String

Choisit un chemin d’image déclaré à partir de l’indication, du temps simulé et de la demi-période en millisecondes. Pour une animation usuelle, préférez appearance avec steady ou blink.

SignallingMod.animation

nimby · fun

open fun animation(decision: Decision): SignalAnimation?

Renvoie la description d’affichage déclarée avec appearance. null conserve la sélection via texture ; la description ne change aucune règle de conduite.

SignallingMod.forcedDecision

nimby · fun

open fun forcedDecision(aspect: Int): Decision?

Demande une indication de recette autorisée pour le type par défaut. Le code est un ordinal local ; null refuse le forçage, notamment sans allowForcedAspect.

SignallingMod.forcedDecision

nimby · fun

open fun forcedDecision(type: String, aspect: Int): Decision?

Demande au modèle indiqué d’autoriser un aspect de recette. Le callback choisit aussi le motif ; null refuse. N’utilisez pas un code Decision.aspect brut.

SignallingMod.drivingRule

nimby · fun

abstract fun drivingRule(decision: Decision): DrivingRule?

Lit la consigne explicitement choisie par le modèle pour cette décision. null indique qu’aucune consigne n’est fournie ; aucune vitesse n’est déduite de l’image.

SignallingMod.isFault

nimby · fun

abstract fun isFault(decision: Decision): Boolean

Classe la décision comme défaut selon le callback faults du mod. Ce classement de diagnostic ne choisit pas automatiquement une image ou une consigne.

SignallingMod.isActive

nimby · fun

open fun isActive(decision: Decision): Boolean

Indique si le mod gère activement cette indication selon activeWhen ; true par défaut. Il s’agit de l’activité du modèle, pas de l’occupation physique.

SignallingMod.aspectName

nimby · fun

open fun aspectName(aspect: Int): String

Libellé de diagnostic d’un aspect appartenant à ce mod. Avec les modèles indépendants, utilisez la valeur encodée du résultat, sans fabriquer d’ordinal global.

SignallingMod.reasonName

nimby · fun

abstract fun reasonName(reason: Int): String

Libellé de diagnostic du motif, choisi par reasonNames. Le motif explique la décision ; il ne vaut pas une permission de mouvement.

SignallingMod.plan

nimby · fun

open fun plan(vehicle: Vehicle, settings: DrivingSettings, input: DrivingInput, constraints: List<Constraint>): DrivingPlan

Exécute le callback drivingPlan sur des valeurs copiées. Sans callback, renvoie un DrivingPlan indisponible. Le résultat est consultatif et n’actionne pas la conduite du train.

maximumSignalNetworkSize

nimby · val

const val maximumSignalNetworkSize: Int = 4096

Limite de 4096 signaux pour un appel au résolveur Kotlin. Une liste plus grande est refusée ; ce nombre n’est pas une promesse de taille maximale de carte.

prepareObservedNetwork

nimby · fun

fun SignallingMod.prepareObservedNetwork(input: List<Signal>): List<Signal>

Valide taille, types et identités de la liste, puis contrôle que prepareNetwork conserve les liens et observations. La préparation peut dériver des réglages effectifs. Les liens absents ou cycliques sont traités ensuite par evaluateNetwork.

evaluateNetwork

nimby · fun

fun SignallingMod.evaluateNetwork(input: List<Signal>): List<Decision>

Résout les décisions dans l’ordre de la liste fournie, après préparation validée. Les décisions locales terminent immédiatement ; les dépendances manquantes ou cycliques utilisent invalidNetwork. Fonction pure adaptée aux tests.