Merge branch 'dev' of https://github.com/ScriptedEvents/ScriptedEventsReloaded into dev

Tosoks67 · Tosoks67 · commit e4aacad49b8a · 2026-01-24T19:17:17.000+01:00
diff --git a/Code/ArgumentSystem/BaseArguments/Argument.cs b/Code/ArgumentSystem/BaseArguments/Argument.cs
@@ -6,6 +6,8 @@ public abstract class Argument(string name)
 {
     public string Name { get; } = name;
     
+    public bool IsRequired => DefaultValue is null;
+    
     /// <summary>
     /// Allows for this argument to get an unlimited amount of values of this type
     /// Every value after this argument also counts towards this one.
diff --git a/Code/ContextSystem/Contexter.cs b/Code/ContextSystem/Contexter.cs
@@ -48,9 +48,9 @@ private static Result TryAddResult(
         Stack<StatementContext> statementStack, 
         List<Context> contexts
     ) {
-        Result rs = $"Invalid context {context} in line {lineNum}.";
+        Result rs = $"Invalid context {context}";
 
-        Log.Debug($"Trying to add context {context} in line {lineNum}");
+        Log.Debug($"Trying to add context {context}");
         
         switch (context)
         {
diff --git a/Code/ContextSystem/Contexts/MethodContext.cs b/Code/ContextSystem/Contexts/MethodContext.cs
@@ -14,7 +14,6 @@
 using SER.Code.TokenSystem.Tokens;
 using SER.Code.ValueSystem;
 using MethodToken = SER.Code.TokenSystem.Tokens.MethodToken;
-using ReturningMethod = SER.Code.MethodSystem.BaseMethods.Synchronous.ReturningMethod;
 
 namespace SER.Code.ContextSystem.Contexts;
 
@@ -53,9 +52,12 @@ public override TryAddTokenRes TryAddToken(BaseToken token)
 
     public override Result VerifyCurrentState()
     {
-        return Result.Assert(_providedArguments >= Method.ExpectedArguments.Count(arg => arg.DefaultValue is null),
+        return Result.Assert(_providedArguments >= Method.ExpectedArguments.Count(arg => arg.IsRequired),
             $"Method '{Method.Name}' is missing required arguments: " +
-            $"{", ".Join(Method.ExpectedArguments.Skip(_providedArguments).Select(arg => arg.Name))}");
+            $"{", ".Join(Method.ExpectedArguments
+                .Skip(_providedArguments)
+                .Where(arg => arg.IsRequired)
+                .Select(arg => arg.Name))}");
     }
 
     protected override IEnumerator<float> Execute()
diff --git a/Code/Helpers/Compiler/CompilerRequiredAttributes.cs b/Code/Helpers/Compiler/CompilerRequiredAttributes.cs
diff --git a/Code/Helpers/Compiler/IsExternalInit.cs.cs b/Code/Helpers/Compiler/IsExternalInit.cs.cs
diff --git a/Code/Helpers/Compiler/NotNullWhenAttribute.cs b/Code/Helpers/Compiler/NotNullWhenAttribute.cs
diff --git a/Code/Helpers/Extensions/StringExtensions.cs b/Code/Helpers/Extensions/StringExtensions.cs
@@ -13,7 +13,7 @@ public static class StringExtensions
     [Pure]
     public static string LowerFirst(this string str)
     {
-        return str.Substring(0, 1).ToLower() + str.Substring(1);
+        return str[0].ToString().ToLower() + str[1..];
     }
 
     // python ahh
diff --git a/Code/MethodSystem/Methods/DiscordMethods/SendDiscordMessageMethod.cs b/Code/MethodSystem/Methods/DiscordMethods/SendDiscordMessageMethod.cs
@@ -0,0 +1,51 @@
+﻿using JetBrains.Annotations;
+using MEC;
+using Newtonsoft.Json.Linq;
+using SER.Code.ArgumentSystem.Arguments;
+using SER.Code.ArgumentSystem.BaseArguments;
+using SER.Code.Helpers.Extensions;
+using SER.Code.MethodSystem.BaseMethods.Synchronous;
+using SER.Code.MethodSystem.MethodDescriptors;
+using SER.Code.MethodSystem.Methods.HTTPMethods;
+
+namespace SER.Code.MethodSystem.Methods.DiscordMethods;
+
+[UsedImplicitly]
+public class SendDiscordMessageMethod : SynchronousMethod, ICanError
+{
+    public override string Description => "Sends a message using a discord webhook.";
+
+    public string[] ErrorReasons => HTTPPostMethod.HttpErrorReasons;
+
+    public override Argument[] ExpectedArguments { get; } =
+    [
+        new TextArgument("webhook url"),
+        new TextArgument("message content"),
+        new TextArgument("webhook name")
+        {
+            DefaultValue = new(null, "default")
+        },
+        new TextArgument("avatar url")
+        {
+            DefaultValue = new(null, "default")
+        }
+    ];
+
+    public override void Execute()
+    {
+        var webhookUrl = Args.GetText("webhook url");
+        var messageContent = Args.GetText("message content");
+        var webhookName = Args.GetText("webhook name").MaybeNull();
+        var avatarUrl = Args.GetText("avatar url").MaybeNull();
+        
+        JObject json = new()
+        {
+            ["content"] = messageContent
+        };
+
+        if (webhookName != null) json["username"] = webhookName;
+        if (avatarUrl != null) json["avatar_url"] = avatarUrl;
+
+        Timing.RunCoroutine(HTTPPostMethod.SendPost(this, webhookUrl, json.ToString()));
+    }
+}
diff --git a/Code/MethodSystem/Methods/GeneralVariableMethods/GlobalVariableMethod.cs b/Code/MethodSystem/Methods/GeneralVariableMethods/GlobalVariableMethod.cs
@@ -1,10 +1,8 @@
 ﻿using JetBrains.Annotations;
 using SER.Code.ArgumentSystem.Arguments;
 using SER.Code.ArgumentSystem.BaseArguments;
-using SER.Code.Helpers.Exceptions;
 using SER.Code.MethodSystem.BaseMethods.Synchronous;
 using SER.Code.MethodSystem.MethodDescriptors;
-using SER.Code.TokenSystem.Tokens.VariableTokens;
 using SER.Code.VariableSystem;
 
 namespace SER.Code.MethodSystem.Methods.GeneralVariableMethods;
@@ -21,17 +19,12 @@ public class GlobalVariableMethod : SynchronousMethod, ICanError
 
     public override Argument[] ExpectedArguments { get; } =
     [
-        new TokenArgument<VariableToken>("variable to make global")
+        new VariableArgument("variable to make global")
     ];
 
     public override void Execute()
     {
-        var variableToken = Args.GetToken<VariableToken>("variable to make global");
-        if (variableToken.TryGetVariable().HasErrored(out var error, out var variable))
-        {
-            throw new ScriptRuntimeError(this, error);
-        }
-
+        var variable = Args.GetVariable("variable to make global");
         VariableIndex.GlobalVariables.RemoveAll(existingVar => existingVar.Name == variable.Name);
         VariableIndex.GlobalVariables.Add(variable);
     }
diff --git a/Code/MethodSystem/Methods/HTTPMethods/HTTPGetMethod.cs b/Code/MethodSystem/Methods/HTTPMethods/HTTPGetMethod.cs
@@ -18,12 +18,9 @@ public class HTTPGetMethod : YieldingReferenceReturningMethod<JObject>, ICanErro
     public override string Description =>
         "Sends a GET request to a provided URL and returns the response as a JSON object.";
 
-    public string[] ErrorReasons =>
-    [
-        "Fetched value from the URL is not a valid JSON object.",
-        nameof(UnityWebRequest.Result.ConnectionError),
-        nameof(UnityWebRequest.Result.DataProcessingError),
-        nameof(UnityWebRequest.Result.ProtocolError)
+    public string[] ErrorReasons => [
+        ..HTTPPostMethod.HttpErrorReasons, 
+        "Provided response was not a valid JSON object."
     ];
 
     public override Argument[] ExpectedArguments { get; } =
@@ -38,12 +35,11 @@ public override IEnumerator<float> Execute()
         using UnityWebRequest webRequest = UnityWebRequest.Get(address);
 
         yield return Timing.WaitUntilDone(webRequest.SendWebRequest());
-
-        if (webRequest.result != UnityWebRequest.Result.Success)
+        
+        if (webRequest.error is { } error)
         {
-            throw new ScriptRuntimeError(
-                this, 
-                $"Address {address} has returned {webRequest.result} ({webRequest.responseCode}): {webRequest.error}"
+            throw new ScriptRuntimeError(this, 
+                $"Address {address} has returned an error: {error}"
             );
         }
 
diff --git a/Code/MethodSystem/Methods/HTTPMethods/HTTPPostMethod.cs b/Code/MethodSystem/Methods/HTTPMethods/HTTPPostMethod.cs
@@ -4,6 +4,7 @@
 using SER.Code.ArgumentSystem.Arguments;
 using SER.Code.ArgumentSystem.BaseArguments;
 using SER.Code.Helpers.Exceptions;
+using SER.Code.MethodSystem.BaseMethods;
 using SER.Code.MethodSystem.BaseMethods.Synchronous;
 using SER.Code.MethodSystem.MethodDescriptors;
 using UnityEngine.Networking;
@@ -21,23 +22,25 @@ public class HTTPPostMethod : SynchronousMethod, ICanError
         new TextArgument("address"),
         new ReferenceArgument<JObject>("json data to post")
     ];
-
-    public string[] ErrorReasons =>
+    
+    public static string[] HttpErrorReasons { get; } =
     [
         nameof(UnityWebRequest.Result.ConnectionError),
         nameof(UnityWebRequest.Result.DataProcessingError),
         nameof(UnityWebRequest.Result.ProtocolError)
     ];
-    
+
+    public string[] ErrorReasons => HttpErrorReasons;
+
     public override void Execute()
     {
         var address = Args.GetText("address");
         var jsonData = Args.GetReference<JObject>("json data to post");
         
-        Timing.RunCoroutine(SendPost(address, jsonData.ToString()));
+        Timing.RunCoroutine(SendPost(this, address, jsonData.ToString()));
     }
     
-    private IEnumerator<float> SendPost(string url, string jsonData)
+    public static IEnumerator<float> SendPost(Method caller, string url, string jsonData)
     {
         using UnityWebRequest request = new UnityWebRequest(url, "POST");
         byte[] bodyRaw = System.Text.Encoding.UTF8.GetBytes(jsonData);
@@ -46,12 +49,12 @@ private IEnumerator<float> SendPost(string url, string jsonData)
         request.SetRequestHeader("Content-Type", "application/json");
 
         yield return Timing.WaitUntilDone(request.SendWebRequest());
-
-        if (request.result != UnityWebRequest.Result.Success)
+        
+        if (request.error is { } error)
         {
             throw new ScriptRuntimeError(
-                this, 
-                $"Address {url} has returned {request.result} ({request.responseCode}): {request.error}"
+                caller,
+                $"Address {url} has returned an error: {error}"
             );
         }
     }
diff --git a/Code/MethodSystem/Methods/HTTPMethods/ParseJSONMethod.cs b/Code/MethodSystem/Methods/HTTPMethods/ParseJSONMethod.cs
diff --git a/Code/MethodSystem/Methods/NumberMethods/HexToIntMethod.cs b/Code/MethodSystem/Methods/NumberMethods/HexToIntMethod.cs
@@ -1,5 +1,4 @@
 ﻿using System.Globalization;
-using Exiled.Permissions.Commands.Permissions;
 using JetBrains.Annotations;
 using SER.Code.ArgumentSystem.Arguments;
 using SER.Code.ArgumentSystem.BaseArguments;
diff --git a/Code/Plugin/Commands/HelpSystem/HelpCommand.cs b/Code/Plugin/Commands/HelpSystem/HelpCommand.cs
@@ -10,7 +10,6 @@
 using SER.Code.MethodSystem.BaseMethods;
 using SER.Code.MethodSystem.BaseMethods.Interfaces;
 using SER.Code.MethodSystem.BaseMethods.Synchronous;
-using SER.Code.MethodSystem.BaseMethods.Yielding;
 using SER.Code.MethodSystem.MethodDescriptors;
 using SER.Code.Plugin.Commands.Interfaces;
 using SER.Code.TokenSystem.Tokens;
diff --git a/Code/TokenSystem/Tokens/TextToken.cs b/Code/TokenSystem/Tokens/TextToken.cs
@@ -1,12 +1,7 @@
-﻿using System.Text.RegularExpressions;
-using SER.Code.Helpers;
-using SER.Code.Helpers.Exceptions;
-using SER.Code.Helpers.Extensions;
-using SER.Code.Helpers.ResultSystem;
+﻿using SER.Code.Helpers.ResultSystem;
 using SER.Code.ScriptSystem;
 using SER.Code.TokenSystem.Slices;
 using SER.Code.TokenSystem.Structures;
-using SER.Code.TokenSystem.Tokens.ExpressionTokens;
 using SER.Code.ValueSystem;
 
 namespace SER.Code.TokenSystem.Tokens;
diff --git a/SER.csproj b/SER.csproj
@@ -19,15 +19,15 @@
         <DebugSymbols>true</DebugSymbols>
         <DebugType>embedded</DebugType>
         <Optimize>false</Optimize>
-        <DefineConstants>DEBUG;TRACE</DefineConstants>
+        <DefineConstants>DEBUG;TRACE;HAVE_NULLABLE_ATTRIBUTES</DefineConstants>
         <OutputPath>bin\Debug\</OutputPath>
         <WarningLevel>4</WarningLevel>
     </PropertyGroup>
 
     <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|AnyCPU'">
         <DebugType>full</DebugType>
         <Optimize>true</Optimize>
-        <DefineConstants>TRACE</DefineConstants>
+        <DefineConstants>TRACE;HAVE_NULLABLE_ATTRIBUTES</DefineConstants>
         <OutputPath>bin\Release\</OutputPath>
         <WarningLevel>4</WarningLevel>
     </PropertyGroup>
@@ -92,6 +92,10 @@
         <PackageReference Include="NCalc" Version="1.3.8" />
         <PackageReference Include="Newtonsoft.Json" Version="13.0.4" />
         <PackageReference Include="Northwood.LabAPI" Version="1.1.5" />
+        <PackageReference Include="PolySharp" Version="1.15.0">
+          <PrivateAssets>all</PrivateAssets>
+          <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
+        </PackageReference>
     </ItemGroup>
     <ItemGroup>
       <Folder Include="Code\" />

Original file line number	Diff line number	Diff line change
`@@ -6,6 +6,8 @@ public abstract class Argument(string name)`
`6`	`6`	`{`
`7`	`7`	`public string Name { get; } = name;`
`8`	`8`
	`9`	`+ public bool IsRequired => DefaultValue is null;`
	`10`	`+`
`9`	`11`	`/// <summary>`
`10`	`12`	`/// Allows for this argument to get an unlimited amount of values of this type`
`11`	`13`	`/// Every value after this argument also counts towards this one.`
Original file line number	Diff line number	Diff line change
`@@ -13,7 +13,7 @@ public static class StringExtensions`
`13`	`13`	`[Pure]`
`14`	`14`	`public static string LowerFirst(this string str)`
`15`	`15`	`{`
`16`		`- return str.Substring(0, 1).ToLower() + str.Substring(1);`
	`16`	`+ return str[0].ToString().ToLower() + str[1..];`
`17`	`17`	`}`
`18`	`18`
`19`	`19`	`// python ahh`