Нарративный скриптинг и отдельный аддон для него

addons/README.md

@@ -15,6 +15,8 @@ Copy the jar to either of these directories:
 - `mods/` - the usual choice for distributed addons and modpacks;
 - `hollowengine/addons/`- useful during development or when you want to keep addons separate from mods.
 
+In a development run of this repository nothing has to be copied: `runClient` and `runServer` build every addon first and pass `build/addon-jars` to the game with `-Dhollowengine.devAddons`. That directory is looked at before the two others, so a copy of the same addon left in `mods/` never wins, and it is watched like them: run `./gradlew buildAddons` while the game is open and the rebuilt addons are reloaded in place. Addons with bootstrap libraries still need a restart.
+
 The runtime scans and watches both directories. If the same addon id is present in both at startup, the newest version wins; when the versions are equal, the copy in `hollowengine/addons/` has priority. Do not keep duplicate copies unless you are deliberately testing version selection.
 
 Runtime diagnostics and lifecycle controls are available to operators:

addons/compiler/build.gradle.kts

@@ -30,6 +30,10 @@ val ijPlatform = "261.25134.147"
 val ijJava = "261.25134.137"
 
 val runtimeProjectPath = ":runtime"
+val minecraftTestClasspath = project(runtimeProjectPath).configurations.named("compileClasspath").map { classpath ->
+    classpath.filter { file -> listOf("org.jetbrains", "androidx", "io.insert-koin").none { file.path.contains(it) } }
+}
+val narrativeTestJar = provider { project(":addons:narrative").tasks.named<Jar>("jar").get().archiveFile.get() }
 val lightTreeClasses = project.projectDir.resolve("lightTree")
 val patchedLightTreeJar = tasks.register<ShadowJar>("patchedLightTreeJar") {
     archiveBaseName.set("hollowengine-light-tree")
@@ -169,14 +173,19 @@ dependencies {
     runtimeOnly(files(patchedLightTreeJar.flatMap { it.archiveFile }))
 
     testImplementation(kotlin("test"))
+    testImplementation("io.insert-koin:koin-core:${rootProject.property("koinVersion")}")
     testImplementation("androidx.compose.runtime:runtime:$composeRuntimeVersion")
+    testImplementation(files(narrativeTestJar) { builtBy(":addons:narrative:jar") })
+    testImplementation("org.jetbrains.kotlinx:kotlinx-coroutines-test:1.11.0")
+    testImplementation(files(minecraftTestClasspath))
     testRuntimeOnly(files(patchedLightTreeJar.flatMap { it.archiveFile }))
     testRuntimeOnly(files(compilerPluginRuntimeJar.flatMap { it.archiveFile }))
     testRuntimeOnly("org.jetbrains.kotlin:kotlin-reflect:$kotlinVersion")
     testRuntimeOnly("org.jetbrains.kotlinx:kotlinx-coroutines-core:1.11.0")
-    testRuntimeOnly("org.jetbrains.kotlinx:kotlinx-serialization-core:$serializationVersion")
+    testImplementation("org.jetbrains.kotlinx:kotlinx-serialization-core:$serializationVersion")
     testRuntimeOnly("org.jetbrains.kotlinx:kotlinx-serialization-json:$serializationVersion")
     testRuntimeOnly("org.apache.logging.log4j:log4j-api:2.23.1")
+    testRuntimeOnly("org.apache.logging.log4j:log4j-core:2.23.1")
     testRuntimeOnly("org.junit.platform:junit-platform-launcher")
 }
 
@@ -305,7 +314,8 @@ tasks.withType<Test>().configureEach {
     })
     inputs.files(analysisClasspath).withPropertyName("ideAnalysisClasspath")
     doFirst {
-        systemProperty("hollowengine.ide.testClasspath", analysisClasspath.get().asPath)
+        val classpath = analysisClasspath.get().files + narrativeTestJar.get().asFile
+        systemProperty("hollowengine.ide.testClasspath", classpath.joinToString(File.pathSeparator))
     }
     useJUnitPlatform()
     maxHeapSize = "2g"

addons/compiler/src/main/java/ru/hollowhorizon/hollowengine/common/ScriptingEnvironmentFactory.kt

@@ -5,10 +5,12 @@ import kotlinx.coroutines.*
 import org.jetbrains.kotlin.scripting.definitions.ScriptDefinition
 import ru.hollowhorizon.hollowengine.common.addons.HollowAddonContext
 import ru.hollowhorizon.hollowengine.common.addons.HollowAddonEntrypoint
+import ru.hollowhorizon.hollowengine.common.addons.HollowAddonsChangedEvent
 import ru.hollowhorizon.hollowengine.common.addons.publish
 import ru.hollowhorizon.hollowengine.common.compiler.ScriptingCompilerImpl
 import ru.hollowhorizon.hollowengine.common.compiler.configuration.HollowScriptConfiguration
 import ru.hollowhorizon.hollowengine.common.compiler.configuration.clientSideImplicitReceivers
+import ru.hollowhorizon.hollowengine.common.events.SubscribeEvent
 import ru.hollowhorizon.hollowengine.common.ide.session.AnalysisEnvironment
 import ru.hollowhorizon.hollowengine.common.ide.session.EmptyLogger
 import ru.hollowhorizon.hollowengine.common.scripting.DefaultScriptDefinitions
@@ -33,10 +35,16 @@ import kotlin.script.experimental.jvm.JvmDependency
 import kotlin.script.experimental.jvm.JvmGetScriptingClass
 import kotlin.script.experimental.jvm.defaultJvmScriptingHostConfiguration
 
-class ScriptingEnvironmentInitializerImpl : ScriptingEnvironmentInitializer, HollowAddonEntrypoint {
+class ScriptingEnvironmentInitializerImpl(
+    private val prepareClasspath: (File) -> Pair<Mappings, List<File>> = CommonEnvironment::setup,
+    private val definitions: () -> List<ScriptClassProvider> = DefaultScriptDefinitions::providers,
+) : ScriptingEnvironmentInitializer, HollowAddonEntrypoint {
     @Volatile
     private var loaded: LoadedAddon? = null
 
+    @Volatile
+    private var built: BuiltEnvironment? = null
+
     override suspend fun load(context: HollowAddonContext, scope: CoroutineScope) {
         loaded = LoadedAddon(context.addonFile, scope)
         setUp(context.addonFile, scope)
@@ -45,6 +53,7 @@ class ScriptingEnvironmentInitializerImpl : ScriptingEnvironmentInitializer, Hol
 
     override suspend fun unload(context: HollowAddonContext) {
         loaded = null
+        built = null
         ScriptingEnvironment.clear()
     }
 
@@ -56,20 +65,52 @@ class ScriptingEnvironmentInitializerImpl : ScriptingEnvironmentInitializer, Hol
         setUp(addon.file, addon.scope)
     }
 
+    /**
+     * Addons loaded after this one may add script types and imports. Once they are all in, the
+     * environment is recreated with them on the same classpath, so nothing is remapped again.
+     */
+    @SubscribeEvent
+    @Synchronized
+    fun onAddonsChanged(event: HollowAddonsChangedEvent) {
+        val addon = loaded ?: return
+        val current = built ?: return
+        val scriptTypes = definitions()
+        if (scriptTypes == current.scriptTypes) return
+        logI("Reloading script definitions after addon imports or script types changed")
+        ScriptingEnvironment.clear()
+        start(addon, current.mappings, current.classpath, scriptTypes)
+    }
+
     private fun setUp(addonFile: File, scope: CoroutineScope) {
-        val (mappings, classpath) = CommonEnvironment.setup(addonFile)
+        val (mappings, classpath) = prepareClasspath(addonFile)
+        start(LoadedAddon(addonFile, scope), mappings, classpath, definitions())
+    }
+
+    private fun start(
+        addon: LoadedAddon,
+        mappings: Mappings,
+        classpath: List<File>,
+        scriptTypes: List<ScriptClassProvider>,
+    ) {
         val environment = initialize(
             javaHome = File(System.getProperty("java.home")),
             classpath = classpath,
-            hostClasspath = classpath + addonFile,
-            scriptTypes = DefaultScriptDefinitions.providers(),
+            hostClasspath = classpath + addon.file,
+            scriptTypes = scriptTypes,
             mappings = mappings,
         )
-        environment.warmUpAnalysis(scope)
+        built = BuiltEnvironment(mappings, classpath, scriptTypes)
+        environment.warmUpAnalysis(addon.scope)
     }
 
     private class LoadedAddon(val file: File, val scope: CoroutineScope)
 
+    private class BuiltEnvironment(
+        val mappings: Mappings,
+        val classpath: List<File>,
+        val scriptTypes: List<ScriptClassProvider>,
+    )
+
     override fun initialize(
         javaHome: File,
         classpath: List<File>,

addons/compiler/src/main/java/ru/hollowhorizon/hollowengine/common/compiler/CompiledScript.kt

@@ -13,15 +13,19 @@ import kotlin.script.experimental.api.ScriptCompilationConfiguration
 import kotlin.script.experimental.api.ScriptEvaluationConfiguration
 import kotlin.script.experimental.api.implicitReceivers
 import kotlin.script.experimental.api.with
+import kotlin.script.experimental.api.valueOr
+import kotlin.script.experimental.api.CompiledScript as KotlinCompiledScript
 
 data class CompiledScriptImpl(
     override val name: String,
-    val script: kotlin.script.experimental.api.CompiledScript,
+    val script: KotlinCompiledScript,
     val evalConfiguration: ScriptEvaluationConfiguration,
 ) : CompiledScript {
     private val scriptClassDelegate = lazy {
         runScriptingBlocking {
-            (script.getClass(evalConfiguration) as ResultWithDiagnostics.Success).value
+            script.getClass(evalConfiguration).valueOr { failure ->
+                throw ScriptEvaluationException(name, failure.reports.map { it.convert() })
+            }
         }
     }
 

addons/compiler/src/main/java/ru/hollowhorizon/hollowengine/common/compiler/configuration/HollowScriptConfigurator.kt

@@ -5,6 +5,7 @@ import ru.hollowhorizon.hollowengine.common.scripting.annotations.Import
 import ru.hollowhorizon.hollowengine.common.scripting.source.ScriptId
 import ru.hollowhorizon.hollowengine.common.scripting.source.ScriptImports
 import ru.hollowhorizon.hollowengine.common.scripting.source.ScriptRegistry
+import ru.hollowhorizon.hollowengine.common.scripting.source.ScriptTranslators
 import java.io.File
 import kotlin.script.experimental.api.*
 import kotlin.script.experimental.host.FileBasedScriptSource
@@ -67,7 +68,8 @@ class HollowScriptConfigurator : RefineScriptCompilationConfigurationHandler {
     private fun resolve(owner: ScriptId?, scriptFile: File?, reference: String): File? {
         if (owner != null) {
             val id = ScriptImports.resolve(owner, reference) ?: return null
-            return ScriptRegistry.artifacts(id)?.sourceFile
+            val source = ScriptRegistry.artifacts(id)?.sourceFile ?: return null
+            return ScriptTranslators.kotlinSource(id, source)
         }
         val base = scriptFile?.parentFile ?: return File(reference).takeIf(File::isFile)
         return base.resolve(reference).takeIf(File::isFile) ?: File(reference).takeIf(File::isFile)

addons/compiler/src/main/java/ru/hollowhorizon/hollowengine/common/compiler/configuration/SharedScriptValidation.kt

@@ -0,0 +1,28 @@
+package ru.hollowhorizon.hollowengine.common.compiler.configuration
+
+import ru.hollowhorizon.hollowengine.common.scripting.compiling.isSharedScript
+import ru.hollowhorizon.hollowengine.common.scripting.compiling.sharedScriptImportError
+import org.jetbrains.kotlin.scripting.resolve.resolvedImportScripts
+import kotlin.script.experimental.api.ScriptCompilationConfiguration
+import kotlin.script.experimental.api.ScriptDiagnostic
+import kotlin.script.experimental.api.SourceCode
+
+internal fun sharedImportDiagnostics(
+    sources: List<SourceCode>,
+    configuration: (SourceCode) -> ScriptCompilationConfiguration,
+): List<ScriptDiagnostic> = buildList {
+    sources.forEach { script ->
+        val configured = configuration(script)
+        if (configured[ScriptCompilationConfiguration.isSharedScript] != true) return@forEach
+        configured[ScriptCompilationConfiguration.resolvedImportScripts].orEmpty().filter {
+            configuration(it)[ScriptCompilationConfiguration.isSharedScript] != true
+        }.forEach { dependency ->
+            add(ScriptDiagnostic(
+                ScriptDiagnostic.unspecifiedError,
+                sharedScriptImportError(script.locationId ?: script.name.orEmpty(), dependency.locationId ?: dependency.name.orEmpty()),
+                ScriptDiagnostic.Severity.ERROR,
+                script.locationId,
+            ))
+        }
+    }
+}