Antigravity take on the Gestalt DI PR - fixes multiplayer!

AGENTS.md

@@ -0,0 +1,70 @@
+# Agent Workflow & Lessons Learned
+
+This document serves as a living guide for AI agents working on the Terasology project. It captures workflow best practices, platform-specific quirks, and useful commands to ensure efficient collaboration.
+
+## Platform: Windows & PowerShell
+
+General coding on Linux and Mac are well-understood by AI, while Java on Windows with PowerShell is less so, meaning we need extra tips and options here.
+
+- **Path Separators**: Use forward slashes `/` for Gradle tasks and Java paths where possible, but be aware that Windows system paths use backslashes `\`.
+- **Command Syntax**: PowerShell handles quotes and environment variables differently than Bash.
+    - *Env Vars*: `$env:VAR="value"; command`
+    - *Chaining*: Use `;` instead of `&&` if you want unconditional execution, or `if ($?) { command }` for conditional.
+    - **File Search**: To find files recursively:
+      ```powershell
+      Get-ChildItem -Path . -Filter filename.txt -Recurse
+      ```
+- **Environment Setup**:
+    - **JAVA_HOME**: PowerShell terminals in the IDE may not inherit system variables correctly. Set it explicitly for the session plus update the PATH:
+      ```powershell
+      $env:JAVA_HOME = "D:\Dev\Java\TemurinJDK17"
+      $env:Path = "$env:JAVA_HOME\bin;$env:Path"
+      ```
+    - **Path**: You can verify java is accessible with `& "$env:JAVA_HOME\bin\java" -version`.
+
+## Search and Navigation
+*   **Use Search Tools**: When looking for specific method calls, variable usages, or class definitions across the codebase, try to use `grep_search` or `codebase_search` instead of manually traversing files one by one. This is faster and more exhaustive.
+*   **Scoped Search**: Narrow down search scope using `TargetDirectories` or `SearchPath` to reduce noise.
+
+## Gradle & Build System
+
+- **Verbosity**: Gradle output can be overwhelming.
+    - Avoid `--info` or `--debug` unless necessary.
+    - If output is truncated, check XML reports: `build/test-results/test/TEST-*.xml`.
+- **Running Tests**:
+    - Use specific filters: `./gradlew :project:test --tests "package.ClassName"`
+    - Example: `./gradlew :engine-tests:test --tests "org.terasology.engine.BuildValidationTest"`
+- **Task Execution**:
+    - **Force Run**: To force a test to run without rebuilding the whole project, use `cleanTest` before the test task:
+      ` ./gradlew :engine-tests:cleanTest :engine-tests:test --tests "org.terasology.metatesting.MTETwoClientChatTest"`
+    - **Nuclear Option**: `--rerun-tasks` will rerun EVERYTHING. Use sparingly.
+    - **Clean Builds**: When in doubt (class not found, weird linkage errors), run `./gradlew clean`.
+
+## Context Management
+
+- **Logs**: Do not dump full log files into the chat context.
+    - Use `grep` (or `Select-String` in PS) to find relevant lines.
+    - Read specific blocks of XML reports.
+- **File Viewing**: Use `view_file` with line ranges to inspect relevant code sections.
+- **Debugging**: When tests fail or timeout, use `System.out.println` *before* assertions or inside `runUntil` loops to dump relevant state (e.g., object counts, flags, current states). This is often faster than attaching a debugger.
+
+## Testing Strategy: "Meta-Test Suite"
+
+We are building a validation suite from the ground up to verify the test infrastructure itself.
+1.  **Build & Classpath**: Verify resources can be loaded.
+2.  **Module Loading**: Verify `ModuleManager` works.
+3.  **DI & Registry**: Verify injection and `CoreRegistry`.
+4.  **Entity System**: Verify `EntityManager` and Events.
+5.  **MTE/Multiplayer**: Verify full game environment.
+
+## Common Issues
+
+- **Context Pollution**: `CoreRegistry` is a deprecated static singleton meant to be removed. Tests running in the same JVM must be careful about cleaning it up or isolating contexts.
+- **Module Permissions**: The `SecurityManager` (via `ModuleSecurityManager`) can block access to classes. Ensure modules have correct dependencies and permissions.
+- **Service vs System**: Distinguish between `Context`/`CoreRegistry` services (global, available via `@In`) and ECS Systems (event-driven, registered with `ComponentSystemManager`). Some functionality (like Chat) relies on ECS systems processing events, not just the service being present.
+
+## Conventions
+
+* Max line length in code files is 150 characters
+* Do not make linting or whitespace-only changes to files unless explicitly requested
+* If edits repeatedly result in corrupted files (large deleted chunks) start solely rewriting the file from scratch

config/gradle/common.gradle

@@ -43,3 +43,21 @@ tasks.javadoc {
     // TODO: Temporary until javadoc has been fixed for Java 8 everywhere
     failOnError = false
 }
+
+apply plugin: 'jacoco'
+
+jacoco {
+    toolVersion = "0.8.13"
+}
+
+test {
+    finalizedBy jacocoTestReport
+}
+
+jacocoTestReport {
+    dependsOn test
+    reports {
+        xml.required = true
+        html.required = true
+    }
+}

engine-tests/build.gradle.kts

@@ -116,6 +116,10 @@ tasks.named<Test>("test") {
     description = "Runs all tests (slow)"
     useJUnitPlatform ()
     systemProperty("junit.jupiter.execution.timeout.default", "4m")
+    testLogging {
+        events("passed", "skipped", "failed")
+        showStandardStreams = true
+    }
 }
 
 tasks.register<Test>("unitTest") {
@@ -160,3 +164,19 @@ idea {
         isDownloadSources = true
     }
 }
+
+tasks.named<org.gradle.testing.jacoco.tasks.JacocoReport>("jacocoTestReport") {
+    // Cross-module support: The tests in this module (:engine-tests) exercise code located in the :engine module.
+    // By default, JaCoCo only looks at sources in the current project. We must explicitly add the :engine
+    // main source set and output classes so that the coverage report includes the actual engine code.
+    val engineProject = project(":engine")
+    val sourceSets = engineProject.extensions.getByType(SourceSetContainer::class)
+    val mainSourceSet = sourceSets.getByName("main")
+
+    additionalSourceDirs.from(mainSourceSet.allSource)
+    additionalClassDirs.from(mainSourceSet.output)
+    reports {
+        xml.required.set(true)
+        html.required.set(true)
+    }
+}

engine-tests/src/test/java/org/terasology/metatesting/BuildValidationTest.java

@@ -0,0 +1,55 @@
+package org.terasology.metatesting;
+
+import org.junit.jupiter.api.Test;
+import static org.junit.jupiter.api.Assertions.assertNotNull;
+
+import java.net.URL;
+import java.util.Enumeration;
+
+public class BuildValidationTest {
+
+    @Test
+    public void testClasspathSanity() {
+        System.out.println("Running BuildValidationTest: Checking classpath sanity...");
+
+        // 1. Check if we can load a standard Java class
+        assertNotNull(String.class, "Should be able to load String class");
+
+        // 2. Check if we can find the TerasologyEngine class
+        URL resource = getClass().getResource("/org/terasology/engine/core/TerasologyEngine.class");
+
+        if (resource == null) {
+            System.out.println("FATAL: TerasologyEngine class not found!");
+            System.out.println("Current ClassLoader: " + getClass().getClassLoader());
+            System.out.println("Java Classpath: " + System.getProperty("java.class.path"));
+        } else {
+            System.out.println("Classpath sanity check passed. Found TerasologyEngine at: " + resource);
+        }
+
+        assertNotNull(resource, "Should be able to find TerasologyEngine class resource");
+
+        // 3. Check for module.txt
+        // We found it at org/terasology/engine/module.txt in the source
+        URL moduleTxt = getClass().getResource("/org/terasology/engine/module.txt");
+
+        if (moduleTxt == null) {
+            System.out.println("WARNING: /org/terasology/engine/module.txt not found. Checking for any module.txt...");
+            try {
+                Enumeration<URL> resources = getClass().getClassLoader().getResources("module.txt");
+                while (resources.hasMoreElements()) {
+                    URL url = resources.nextElement();
+                    System.out.println("Found a module.txt at: " + url);
+                    if (url.toString().contains("engine")) {
+                        moduleTxt = url;
+                    }
+                }
+            } catch (Exception e) {
+                e.printStackTrace();
+            }
+        } else {
+            System.out.println("Found engine module.txt at: " + moduleTxt);
+        }
+
+        assertNotNull(moduleTxt, "Should be able to find module.txt for the engine module");
+    }
+}