Support YSM runtime extensions in Molang evaluation

Normalize YSM variable names and execute item, food, bone rotation, yaw speed, and second-order expressions against live ModelEngine entity state.

Author: Arbousier1

build.gradle.kts

@@ -24,6 +24,10 @@ dependencies {
 
     testImplementation("org.junit.jupiter:junit-jupiter:5.12.2")
     testRuntimeOnly("org.junit.platform:junit-platform-launcher")
+    testRuntimeOnly("io.papermc.paper:paper-api:1.21.8-R0.1-SNAPSHOT")
+    testRuntimeOnly("com.ticxo.modelengine:ModelEngine:R4.1.0") {
+        isTransitive = false
+    }
     testCompileOnly("io.papermc.paper:paper-api:1.21.8-R0.1-SNAPSHOT")
     testCompileOnly("com.ticxo.modelengine:ModelEngine:R4.1.0") {
         isTransitive = false

src/main/java/com/ysm/modelengine/molang/MolangCompilerFacade.java

@@ -5,12 +5,23 @@
 import gg.moonflower.molangcompiler.api.MolangExpression;
 import gg.moonflower.molangcompiler.api.exception.MolangException;
 
+import java.util.Locale;
 import java.util.Map;
 import java.util.concurrent.ConcurrentHashMap;
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
 
 final class MolangCompilerFacade {
+    private static final Pattern NAMESPACE_IDENTIFIER = Pattern.compile(
+            "(?i)\\b(v|variable|ctrl|query|q|math|ysm)\\.([a-z_][a-z0-9_]*)");
+    private static final Pattern SECOND_ORDER_CALL = Pattern.compile(
+            "(?i)\\bysm\\.second_order\\(\\s*'([^']*)'\\s*,");
+    private static final Pattern BONE_ROTATION_CALL = Pattern.compile(
+            "(?i)\\bysm\\.bone_rot\\(\\s*'([^']*)'\\s*\\)\\s*\\.\\s*([xyz])\\b");
+
     private final MolangCompiler compiler = GlobalMolangCompiler.get();
     private final Map<String, MolangExpression> cache = new ConcurrentHashMap<>();
+    private final MolangSymbolTable symbols = new MolangSymbolTable();
     private final int maxEntries;
     private final RateLimitedDiagnostics diagnostics;
 
@@ -20,7 +31,7 @@ final class MolangCompilerFacade {
     }
 
     MolangExpression compile(String source) {
-        String normalized = normalize(source);
+        String normalized = rewriteDynamicFunctionArguments(normalize(source));
         if (normalized.isBlank()) {
             throw new IllegalArgumentException("Molang expression cannot be blank");
         }
@@ -40,6 +51,11 @@ MolangExpression compile(String source) {
 
     void clear() {
         cache.clear();
+        symbols.clear();
+    }
+
+    MolangSymbolTable symbols() {
+        return symbols;
     }
 
     int size() {
@@ -59,12 +75,48 @@ private MolangExpression compileUncached(String source) {
     static String normalize(String source) {
         if (source == null) return "";
         String normalized = source.trim();
-        if (normalized.startsWith("molang:")) normalized = normalized.substring("molang:".length()).trim();
-        normalized = normalized.replace("ysm.head_yaw", "query.head_y_rotation");
-        normalized = normalized.replace("ysm.head_pitch", "query.head_x_rotation");
-        normalized = normalized.replace("ysm.body_yaw", "query.body_y_rotation");
-        normalized = normalized.replace("variable.", "v.");
-        normalized = normalized.replace("ctrl.", "v.ctrl_");
-        return normalized;
+        if (normalized.regionMatches(true, 0, "molang:", 0, "molang:".length())) {
+            normalized = normalized.substring("molang:".length()).trim();
+        }
+        normalized = normalized.replaceAll("(?i)\\bysm\\.head_yaw\\b", "query.head_y_rotation");
+        normalized = normalized.replaceAll("(?i)\\bysm\\.head_pitch\\b", "query.head_x_rotation");
+        normalized = normalized.replaceAll("(?i)\\bysm\\.body_yaw\\b", "query.body_y_rotation");
+
+        Matcher matcher = NAMESPACE_IDENTIFIER.matcher(normalized);
+        StringBuffer output = new StringBuffer();
+        while (matcher.find()) {
+            String namespace = matcher.group(1).toLowerCase(Locale.ROOT);
+            String member = matcher.group(2).toLowerCase(Locale.ROOT);
+            String replacement = switch (namespace) {
+                case "variable" -> "v." + member;
+                case "ctrl" -> "v.ctrl_" + member;
+                default -> namespace + "." + member;
+            };
+            matcher.appendReplacement(output, Matcher.quoteReplacement(replacement));
+        }
+        matcher.appendTail(output);
+        return output.toString();
+    }
+
+    private String rewriteDynamicFunctionArguments(String source) {
+        Matcher secondOrder = SECOND_ORDER_CALL.matcher(source);
+        StringBuffer output = new StringBuffer();
+        while (secondOrder.find()) {
+            int symbolId = symbols.idFor(secondOrder.group(1));
+            String replacement = "ysm.second_order(" + symbolId + ",";
+            secondOrder.appendReplacement(output, Matcher.quoteReplacement(replacement));
+        }
+        secondOrder.appendTail(output);
+
+        Matcher boneRotation = BONE_ROTATION_CALL.matcher(output.toString());
+        StringBuffer rewritten = new StringBuffer();
+        while (boneRotation.find()) {
+            int symbolId = symbols.idFor(boneRotation.group(1));
+            String axis = boneRotation.group(2).toLowerCase(Locale.ROOT);
+            String replacement = "ysm.bone_rot_" + axis + "(" + symbolId + ")";
+            boneRotation.appendReplacement(rewritten, Matcher.quoteReplacement(replacement));
+        }
+        boneRotation.appendTail(rewritten);
+        return rewritten.toString();
     }
 }