Préparer son projet

Préparer les outils et le kit #

• Utilisez Windows x64, IntelliJ IDEA et un JDK 21. Sélectionnez ce JDK comme JVM de Gradle dans IntelliJ.
• Dans le Hub, préparez le SDK du jeu et sélectionnez un kit Kotlin correspondant. Le kit sert à compiler ; le SDK installé sert à exécuter vos mods.
• Dans les réglages développeur, utilisez « Télécharger un kit Kotlin », puis « Télécharger et utiliser ». Conservez le chemin du dossier contenant sdk.json.

Créer un projet avec le Hub #

• Sélectionnez le profil « Développer ». Dans Paramètres, choisissez « Projets locaux de mods » et le « Kit SDK Kotlin pour compiler » correspondant au SDK à utiliser. Le chemin d’IntelliJ est facultatif pour créer le projet.
• Dans Mods, cliquez sur « Créer un projet », puis choisissez « Signal » pour un modèle de signal ou « Outil en jeu » pour un outil accessible dans NIMBY Rails.
• Renseignez l’identifiant, le nom, l’auteur, la description et la version initiale. Un identifiant comme mon-premier-mod utilise des lettres minuscules, des chiffres et des tirets, en commençant par une lettre. Vérifiez le dossier à créer et la version du kit affichés.
• Cliquez sur « Créer le projet ». Le Hub prépare mod.json, Gradle et son wrapper, Entry.kt et les tests. Le modèle Signal comprend aussi ses textures dans assets. Choisissez un nouvel identifiant et un nouveau dossier : un projet existant n’est pas remplacé.
• Dans la fiche du projet, utilisez « Compiler », puis « Ouvrir dans IntelliJ » pour personnaliser les sources. La création prépare le projet ; la compilation prépare son paquet local. Gardez un kit de compilation et un SDK installé compatibles avant les essais en jeu.

Le projet généré peut ensuite être modifié comme n’importe quel projet Kotlin. Les sections suivantes expliquent la création manuelle des mêmes fichiers de base ; elles restent utiles pour comprendre leur rôle et ne sont pas à recopier par-dessus un projet déjà créé.

Créer le projet Gradle manuellement #

Dans IntelliJ, créez un projet Kotlin avec Gradle et le DSL Kotlin. Gardez son wrapper Gradle. Avant de remplacer les fichiers générés, exécutez la commande suivante dans son terminal, puis retirez le Main.kt de démonstration.

.\gradlew.bat wrapper --gradle-version 8.14.3

Créez gradle.properties avec le chemin réel de votre kit. Remplacez ensuite settings.gradle.kts et build.gradle.kts par ces contenus et rechargez les projets Gradle.

nrfSdkDir=C:/NRF/kotlin-sdk

pluginManagement {
    val sdk = providers.gradleProperty("nrfSdkDir")
        .orElse(providers.environmentVariable("NRF_KOTLIN_SDK"))
        .orNull ?: error("Configure nrfSdkDir with the Kotlin kit directory.")
    repositories {
        maven { url = uri(file(sdk).resolve("gradle-repository")) }
        gradlePluginPortal()
        mavenCentral()
    }
    val metadata = groovy.json.JsonSlurper()
        .parseText(file(sdk).resolve("sdk.json").readText().removePrefix("\uFEFF")) as Map<*, *>
    plugins {
        id("fr.nimbyrails.mod") version (metadata["gradlePluginVersion"] as String)
    }
}
dependencyResolutionManagement { repositories { mavenCentral() } }
rootProject.name = "mon-premier-mod"

plugins { id("fr.nimbyrails.mod") }

La version du plugin vient de sdk.json et son dépôt est fourni dans le kit. Vous n’avez pas à choisir séparément une version de Kotlin ni à écrire un adaptateur natif. nrfSdkDir prend priorité sur la variable NRF_KOTLIN_SDK.

Déclarer l’identité et la compatibilité #

Créez ce manifeste à la racine du projet. Les identifiants décrivent votre mod ; gameSha256 décrit les binaires du jeu avec lesquels vous le validez. La valeur de cet exemple correspond au jeu pris en charge par le kit documenté : elle ne permet pas de déclarer un autre binaire compatible.

{
  "id": "mon-premier-mod",
  "name": "Mon premier mod",
  "modId": "MonPremierMod",
  "module": "MonPremierMod",
  "version": "0.1.0",
  "language": "kotlin-native",
  "sdkMin": "0.9.0-alpha.1",
  "sdkMaxExclusive": "0.10.0",
  "gameSha256": ["fff49ac21720abfc824c2b4f68b862727630eb0db71cfe1f9ea8f685d0db10ae"]
}

Construire, vérifier, puis activer #