feat(Rendering): Add custom function support and extend data range for template engine

Added the `RegisterFunctions` method to register custom functions with `AsyncNCalcEngine`, currently including the `ToString` function. Meanwhile, four fields—`everMax`, `everMin`, `currentMax`, and `currentMin`—have been added to the drawing data range to retrieve the maximum and minimum values of rating data in templates. This enhances the expressiveness of templates and enables more flexible data formatting and display.

Author: Yushu2606

src/Render/Drawer.cs

@@ -32,6 +32,10 @@ public async Task<Image> DrawBestsAsync(CommonUser user, IEnumerable<CommonRecor
             [.. currentList.Select((record, idx) => new { Record = record, Index = idx + everList.Count + 1 })];
         int everDelta = everList.Count > 34 ? everList[0].DXRating - everList[^1].DXRating : everList.Count > 0 ? everList[0].DXRating : 0;
         int currentDelta = currentList.Count > 14 ? currentList[0].DXRating - currentList[^1].DXRating : currentList.Count > 0 ? currentList[0].DXRating : 0;
+        int everMax = everList.Count > 0 ? everList[0].DXRating : 0;
+        int everMin = everList.Count > 0 ? everList[^1].DXRating : 0;
+        int currentMax = currentList.Count > 0 ? currentList[0].DXRating : 0;
+        int currentMin = currentList.Count > 0 ? currentList[^1].DXRating : 0;
         int realRating = everTotal + currentTotal;
         string proberState = "on";
         if (user.Rating != realRating)
@@ -59,6 +63,10 @@ public async Task<Image> DrawBestsAsync(CommonUser user, IEnumerable<CommonRecor
             ["isAnime"] = isAnime,
             ["drawLevelSeg"] = drawLevelSeg,
             ["proberState"] = proberState,
+            ["everMax"] = everMax,
+            ["everMin"] = everMin,
+            ["currentMax"] = currentMax,
+            ["currentMin"] = currentMin,
         };
         return await DrawAsync(scope, xmlPath);
     }
@@ -93,9 +101,15 @@ public async Task<Image> DrawListAsync(CommonUser user, IEnumerable<CommonRecord
     private async Task<Image> DrawAsync(Dictionary<string, object?> scope, string xmlPath)
     {
         AsyncNCalcEngine expr = new();
+        RegisterFunctions(expr);
         TemplateReader loader = new(expr);
         Node tree = await loader.LoadAsync(xmlPath, scope);
         AssetProvider assets = AssetProvider.Shared;
         return NodeRenderer.Render((CanvasNode)tree, assets, assets);
     }
+
+    private void RegisterFunctions(AsyncNCalcEngine expr)
+    {
+        expr.RegisterFunction("ToString", (object x) => Convert.ToString(x));
+    }
 }

src/Render/ExpressionEngine/AsyncNCalcEngine.cs

@@ -1,11 +1,17 @@
 using NCalc;
 using System.Collections;
+using System.Collections.Concurrent;
 using System.Globalization;
+using System.Reflection;
 
 namespace Limekuma.Render.ExpressionEngine;
 
 public sealed class AsyncNCalcEngine
 {
+    private readonly ConcurrentDictionary<string, Delegate> _functions = new();
+
+    public void RegisterFunction(string name, Delegate func) => _functions[name] = func;
+
     public async Task<T?> EvalAsync<T>(string expr, object? scope)
     {
         object? result = await EvalAsync(expr, scope);
@@ -44,6 +50,23 @@ public sealed class AsyncNCalcEngine
         {
             expression.Parameters[key] = value is Enum e ? Convert.ToInt32(e, CultureInfo.InvariantCulture) : value;
         }
+        expression.EvaluateFunctionAsync += async (name, args) =>
+        {
+            if (_functions.TryGetValue(name, out Delegate? func))
+            {
+                ParameterInfo[] parameters = func.Method.GetParameters();
+                object?[] funcArgs = new object[args.Parameters.Length];
+                for (int i = 0; i < args.Parameters.Length; ++i)
+                {
+                    object? paramValue = await args.Parameters[i].EvaluateAsync();
+                    funcArgs[i] = CoerceValue(paramValue,
+                        i < parameters.Length ? parameters[i].ParameterType : typeof(object));
+                }
+
+                object? result = func.DynamicInvoke(funcArgs);
+                args.Result = result;
+            }
+        };
 
         return await expression.EvaluateAsync();
     }
@@ -100,4 +123,68 @@ public sealed class AsyncNCalcEngine
 
         return finalTarget == typeof(string) ? value.ToString() : value;
     }
+
+    private object? CoerceValue(object? value, Type targetType)
+    {
+        if (value is null)
+        {
+            if (targetType.IsValueType)
+            {
+                return Activator.CreateInstance(targetType);
+            }
+
+            return value;
+        }
+
+        if (targetType.IsInstanceOfType(value))
+        {
+            return value;
+        }
+
+        if (targetType == typeof(string))
+        {
+            return value.ToString();
+        }
+
+        if (targetType == typeof(bool))
+        {
+            if (value is string sv)
+            {
+                if (bool.TryParse(sv, out bool bv))
+                {
+                    return bv;
+                }
+
+                if (double.TryParse(sv, out double dv))
+                {
+                    return Math.Abs(dv) > 0.0000001;
+                }
+            }
+
+            if (value is not IConvertible conv)
+            {
+                return false;
+            }
+
+            double dvd = conv.ToDouble(CultureInfo.InvariantCulture);
+            return Math.Abs(dvd) > 0.0000001;
+        }
+
+        if (!typeof(IConvertible).IsAssignableFrom(targetType))
+        {
+            return value;
+        }
+
+        if (value is IConvertible)
+        {
+            return Convert.ChangeType(value, targetType, CultureInfo.InvariantCulture);
+        }
+
+        if (value is string s2)
+        {
+            return Convert.ChangeType(s2, targetType, CultureInfo.InvariantCulture);
+        }
+
+        return value;
+    }
 }