Track LocalMods as part of monolith

LocalMods/MicroLua/CSharp/RunConfig.xml

@@ -0,0 +1,5 @@
+<?xml version="1.0" encoding="utf-8"?>
+<RunConfig>
+  <Server>Standard</Server>
+  <Client>Standard</Client>
+</RunConfig>

LocalMods/MicroLua/CSharp/Shared/MicroLua.cs

@@ -0,0 +1,167 @@
+// SPDX-FileCopyrightText: 2023 Matheus Izvekov <mizvekov@gmail.com>
+// SPDX-License-Identifier: ISC
+
+using Barotrauma;
+using Barotrauma.Items.Components;
+using Barotrauma.Networking;
+using MoonSharp.Interpreter.Interop;
+using MoonSharp.Interpreter;
+using System;
+using System.Collections.Generic;
+using System.Globalization;
+using System.Text.RegularExpressions;
+
+namespace miz {
+    partial class MicroLua : ItemComponent, IServerSerializable {
+        private readonly static Regex inpRegex = new Regex(@"^signal_in(\d+)$");
+        private readonly static Regex outRegex = new Regex(@"^signal_out(\d+)$");
+        private List<Connection> outConns = new();
+
+        private Script script;
+
+        private readonly struct EventData : IEventData {
+            public readonly string data;
+            public EventData(string data) { this.data = data; }
+        }
+
+        private void handleException(string source, InterpreterException e) {
+            LuaCsLogger.LogError($"[{Item}] [{source}] {e.DecoratedMessage}", LuaCsMessageOrigin.LuaMod);
+        }
+
+        private bool toNumber(string s, out double value) {
+            return double.TryParse(s, NumberStyles.AllowLeadingSign | NumberStyles.AllowDecimalPoint,
+                                      CultureInfo.InvariantCulture, out value);
+        }
+
+        private string source;
+        [InGameEditable, Serialize("", IsPropertySaveable.Yes, description: "The Lua source code.", alwaysUseInstanceValues: true)]
+        public string Source {
+            get => source;
+            set {
+                if (value == null) { return; }
+                source = value;
+                script = null;
+                IsActive = false;
+
+                if (source.IsNullOrWhiteSpace()) { return; }
+                Script newscript = new(CoreModules.Preset_HardSandbox | CoreModules.Metatables |
+                                       CoreModules.ErrorHandling | CoreModules.Coroutine);
+                newscript.Options.DebugPrint = (string o) => LuaCsLogger.LogMessage($"[{Item}] {o}");
+                newscript.Options.CheckThreadAccess = false;
+
+                newscript.Globals.Get("table").Table["clear"] = (Table t) => t.Clear();
+
+                // MoonSharp's tonumber is too permissive. However, ours does not support base.
+                newscript.Globals["tonumber"] = double? (string s) => toNumber(s, out double value) ? value : null;
+
+                newscript.Globals["mode"] = GameMain.NetworkMember?.IsClient switch {
+                    null => "single", false => "server", true => "client"
+                };
+                newscript.Globals["out"] = UserData.Create(this, new OutDesc());
+                newscript.Globals["time"] = () => GameMain.GameScreen.GameTime;
+
+                if (GameMain.NetworkMember is not null) {
+#if SERVER
+                    newscript.Globals["send"] = (string data) => item.CreateServerEvent(this, new EventData(data));
+#endif
+                }
+
+                try { newscript.DoString(source, codeFriendlyName: "source"); }
+                catch (SyntaxErrorException e)   {
+                    handleException("syntax", e);
+                    return;
+                }
+                catch (ScriptRuntimeException e) {
+                    handleException("runtime", e);
+                    return;
+                }
+
+                IsActive = true;
+                script = newscript;
+            }
+        }
+
+        public MicroLua(Item item, ContentXElement element) : base(item, element) {}
+
+        class OutDesc : IUserDataDescriptor {
+            public string Name {
+                get { return "out"; }
+            }
+            public Type Type {
+                get { return typeof(OutDesc); }
+            }
+
+            public DynValue Index(Script script, object obj, DynValue index, bool isDirectIndexing) {
+                throw new ScriptRuntimeException("__index metamethod not implemented");
+            }
+            public bool SetIndex(Script script, object obj, DynValue index, DynValue value, bool isDirectIndexing) {
+                var parent = (MicroLua)obj;
+                if (index.Type != DataType.Number) { throw new ScriptRuntimeException("pin must be an integer"); }
+                var indexNumber = index.Number;
+                var pin = (int)indexNumber;
+                if ((double)pin != indexNumber) { throw new ScriptRuntimeException("pin must be an integer"); }
+
+                if (pin < 0 || pin > parent.outConns.Count) { throw new ScriptRuntimeException($"invalid pin {pin}"); }
+                var connection = parent.outConns[pin - 1] ?? throw new ScriptRuntimeException($"invalid pin {pin}");
+                parent.item.SendSignal(new Signal(value.Type switch {
+                    DataType.Number  => value.Number.ToString(CultureInfo.InvariantCulture),
+                    DataType.String  => value.String,
+                    _ => throw new ScriptRuntimeException($"invalid value type {value.Type}")
+                }), connection);
+
+                return true;
+            }
+            public string AsString(object obj) { throw new ScriptRuntimeException("__tostring metamethod not implemented"); }
+            public DynValue MetaIndex(Script script, object obj, string metaname) { throw new ScriptRuntimeException($"{metaname} metamethod not implemented"); }
+            public bool IsTypeCompatible(Type type, object obj) { return type.IsInstanceOfType(obj); }
+        };
+
+        public override void OnItemLoaded() {
+            base.OnItemLoaded();
+            foreach(var connection in item.Connections) {
+                var match = outRegex.Match(connection.Name);
+                if (!match.Success) { continue; }
+                var index = int.Parse(match.Groups[1].Value);
+                outConns.Insert(index - 1, connection);
+            }
+        }
+
+        private void Call(string field, params object[] objs) {
+            DynValue cb = script.Globals.Get(field);
+            if (cb.Type == DataType.Nil) { return; }
+            try { script.Call(cb, objs); }
+            catch (ScriptRuntimeException e) { handleException(field, e); }
+        }
+
+        public override void Update(float deltaTime, Camera cam) { Call("upd", deltaTime); }
+
+        public override void ReceiveSignal(Signal signal, Connection connection) {
+            if (script == null) { return; }
+
+            var match = inpRegex.Match(connection.Name);
+            if (!match.Success) { return; }
+
+            var index = int.Parse(match.Groups[1].Value);
+            var value = toNumber(signal.value, out double dynvalue) ? DynValue.NewNumber(dynvalue) :
+                                                                      DynValue.NewString(signal.value);
+            DynValue inp = script.Globals.Get("inp");
+            switch(inp.Type) {
+            case DataType.Nil: break;
+            case DataType.Table: inp.Table.Set(index, value); break;
+            default:
+                try { script.Call(inp, index, value); }
+                catch (ScriptRuntimeException e) { handleException("inp", e); }
+                break;
+            }
+        }
+
+#if CLIENT
+        public void ClientEventRead(IReadMessage msg, float sendingTime) { Call("recv", msg.ReadString()); }
+#endif
+#if SERVER
+        public void ServerEventWrite(IWriteMessage msg, Client c, NetEntityEvent.IData extraData) {
+            msg.WriteString(ExtractEventData<EventData>(extraData).data);
+        }
+#endif
+    }
+}