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

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")
     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/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,
+            ))
+        }
+    }
+}

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

@@ -39,7 +39,6 @@ import org.jetbrains.kotlin.name.Name
 import org.jetbrains.kotlin.name.NameUtils
 import org.jetbrains.kotlin.platform.jvm.JvmPlatforms
 import org.jetbrains.kotlin.scripting.compiler.plugin.configureFirSession
-import org.jetbrains.kotlin.scripting.compiler.plugin.definitions.getOrStoreRefinedCompilationConfiguration
 import org.jetbrains.kotlin.scripting.compiler.plugin.definitions.getRefinedOrBaseCompilationConfiguration
 import org.jetbrains.kotlin.scripting.compiler.plugin.definitions.scriptRefinedCompilationConfigurationsCache
 import org.jetbrains.kotlin.scripting.compiler.plugin.dependencies.collectScriptsCompilationDependenciesRecursively
@@ -53,6 +52,8 @@ import org.jetbrains.kotlin.scripting.compiler.plugin.impl.makeCompiledScript
 import org.jetbrains.kotlin.scripting.compiler.plugin.impl.refineAllForK2
 import org.jetbrains.kotlin.scripting.compiler.plugin.impl.selectJvmTarget
 import org.jetbrains.kotlin.scripting.compiler.plugin.impl.updateWithCompilerOptions
+import org.jetbrains.kotlin.scripting.definitions.ScriptDefinition
+import ru.hollowhorizon.hollowengine.common.compiler.configuration.sharedImportDiagnostics
 import org.jetbrains.kotlin.utils.addToStdlib.firstIsInstanceOrNull
 import kotlin.script.experimental.api.CompiledScript
 import kotlin.script.experimental.api.ResultWithDiagnostics
@@ -83,6 +84,7 @@ import kotlin.script.experimental.jvm.util.toClassPathOrEmpty
 internal class AnnotationFirScriptJvmCompiler(
     state: K2ScriptingCompilerEnvironment,
     private val convertToFir: SourceCode.(FirSession, BaseDiagnosticsCollector) -> FirFile,
+    private val definitions: List<ScriptDefinition>,
 ) {
     private val state = state as? K2ScriptingCompilerEnvironmentInternal
         ?: error("Expected the internal K2 scripting compiler environment, got ${state::class}")
@@ -160,12 +162,21 @@ internal class AnnotationFirScriptJvmCompiler(
         val allSourceFiles = mutableListOf(script)
         val (classpath, importedSources, sourceDependencies) =
             collectScriptsCompilationDependenciesRecursively(allSourceFiles) { importedScript ->
-                state.hostConfiguration.getOrStoreRefinedCompilationConfiguration(importedScript) { source, baseConfig ->
-                    baseConfig.refineAll(source)
+                if (importedScript == script) scriptRefinedCompilationConfiguration.asSuccess()
+                else {
+                    val definition = definitions.filter { importedScript.name?.endsWith(it.fileExtension) == true }
+                        .maxByOrNull { it.fileExtension.length }
+                    val refined = (definition?.compilationConfiguration ?: state.baseScriptCompilationConfiguration)
+                        .refineAll(importedScript)
+                    state.hostConfiguration[ScriptingHostConfiguration.scriptRefinedCompilationConfigurationsCache]
+                        ?.storeRefinedCompilationConfiguration(importedScript, refined)
+                    refined
                 }
             }.valueOr { return it }
         allSourceFiles.addAll(importedSources)
         val compilationSources = importedSources + script
+        val sharedErrors = sharedImportDiagnostics(compilationSources, ::getRefinedConfiguration)
+        if (sharedErrors.isNotEmpty()) return failure(reporting, reporting.diagnosticsCollector, *sharedErrors.toTypedArray())
 
         val ignoredOptionsReportingState = state.compilerContext.ignoredOptionsReportingState
         val updatedCompilerOptions = allSourceFiles.flatMapTo(mutableListOf()) {