fix some broken stuff

Elektryk-Andrzej · Elektryk-Andrzej · commit cfcf416348ce · 2025-10-30T22:02:08.000+01:00
diff --git a/ArgumentSystem/Arguments/DurationArgument.cs b/ArgumentSystem/Arguments/DurationArgument.cs
@@ -16,7 +16,7 @@ public class DurationArgument(string name) : Argument(name)
     [UsedImplicitly]
     public DynamicTryGet<TimeSpan> GetConvertSolution(BaseToken token)
     {
-        if (token is not IValueToken valueToken || valueToken.CanReturn<DurationValue>(out var get))
+        if (token is not IValueToken valueToken || !valueToken.CanReturn<DurationValue>(out var get))
         {
             return $"Value '{token.RawRep}' is not a duration.";
         }
diff --git a/ArgumentSystem/Arguments/FloatArgument.cs b/ArgumentSystem/Arguments/FloatArgument.cs
@@ -58,6 +58,7 @@ public DynamicTryGet<float> GetConvertSolution(BaseToken token)
         {
             return VerifyRange(number.Value.ExactValue);
         }
+        
         return new(() => token.TryGetLiteralValue<NumberValue>().OnSuccess(VerifyRange));
     }
 
diff --git a/ArgumentSystem/Arguments/TextArgument.cs b/ArgumentSystem/Arguments/TextArgument.cs
@@ -20,16 +20,16 @@ public DynamicTryGet<string> GetConvertSolution(BaseToken token)
             return textToken.GetDynamicResolver();
         }    
         
-        if (token is not IValueToken valToken || valToken.CanReturn<TextValue>(out var get))
+        if (token is not IValueToken valToken || !valToken.CanReturn<LiteralValue>(out var get))
         {
             return DynamicTryGet.Error($"Value '{token.RawRep}' cannot represent text.");
         }
 
         if (valToken.IsConstant)
         {
-            return get().OnSuccess(v => v.ExactValue);
+            return get().OnSuccess(v => v.StringRep);
         }
 
-        return new(() => get().OnSuccess(v => v.ExactValue));
+        return new(() => get().OnSuccess(v => v.StringRep));
     }
 }
diff --git a/ArgumentSystem/Arguments/UnknownReferenceArgument.cs b/ArgumentSystem/Arguments/UnknownReferenceArgument.cs
@@ -0,0 +1,35 @@
+﻿using JetBrains.Annotations;
+using SER.ArgumentSystem.BaseArguments;
+using SER.Helpers.Extensions;
+using SER.Helpers.ResultSystem;
+using SER.TokenSystem.Tokens;
+using SER.TokenSystem.Tokens.Interfaces;
+using SER.ValueSystem;
+
+namespace SER.ArgumentSystem.Arguments;
+
+public class UnknownReferenceArgument(string name) : Argument(name)
+{
+    public override string InputDescription => "an unverified reference e.g. @room";
+    
+    [UsedImplicitly]
+    public DynamicTryGet<bool> GetConvertSolution(BaseToken token)
+    {
+        if (token is TextToken textToken)
+        {
+            return textToken.GetDynamicResolver();
+        }    
+        
+        if (token is not IValueToken valToken || !valToken.CanReturn<LiteralValue>(out var get))
+        {
+            return DynamicTryGet.Error($"Value '{token.RawRep}' cannot represent text.");
+        }
+
+        if (valToken.IsConstant)
+        {
+            return get().OnSuccess(v => v.StringRep);
+        }
+
+        return new(() => get().OnSuccess(v => v.StringRep));
+    }
+}
diff --git a/ArgumentSystem/Arguments/ValueArgument.cs b/ArgumentSystem/Arguments/ValueArgument.cs
@@ -14,7 +14,7 @@ public class ValueArgument<T>(string name) : Argument(name) where T : Value
     [UsedImplicitly]
     public DynamicTryGet<T> GetConvertSolution(BaseToken token)
     {
-        if (token.CanReturn<T>(out var get))
+        if (!token.CanReturn<T>(out var get))
         {
             return $"Value '{token.RawRep}' cannot represent {InputDescription}";
         }
diff --git a/ContextSystem/Contexts/Control/Loops/RepeatLoopContext.cs b/ContextSystem/Contexts/Control/Loops/RepeatLoopContext.cs
@@ -38,7 +38,12 @@ public override TryAddTokenRes TryAddToken(BaseToken token)
                 
                 _repeatCount = (uint)numberToken.Value;
                 return TryAddTokenRes.End();
-            case IValueToken valToken when valToken.CanReturn<NumberValue>(out var getNumber):
+            case IValueToken valToken:
+                if (!valToken.CanReturn<NumberValue>(out var getNumber))
+                {
+                    return TryAddTokenRes.Error($"Value '{token.RawRep}' returns a value, but.");   
+                }
+                
                 _repeatCountExpression = () =>
                 {
                     if (getNumber().HasErrored(out var error, out var value))
diff --git a/Helpers/Extensions/SerExtensions.cs b/Helpers/Extensions/SerExtensions.cs
@@ -1,5 +1,6 @@
 ﻿using System;
 using System.Linq;
+using System.Runtime.InteropServices;
 using JetBrains.Annotations;
 using SER.Helpers.Exceptions;
 using SER.Helpers.ResultSystem;
@@ -37,16 +38,22 @@ public static bool CanReturn<T>(this BaseToken token, out Func<TryGet<T>> get) w
     {
         get = null!;
         if (token is not IValueToken valToken) return false;
-        return valToken.CanReturn<T>(out get);
+        return valToken.CanReturn(out get);
     }
     
     public static bool CanReturn<T>(this IValueToken valToken, out Func<TryGet<T>> get) where T : Value
     {
-        get = null!;
+        get = valToken.TryGet<T>;
+        
         if (valToken.PossibleValueTypes is null) return true;
+        return valToken.PossibleValueTypes.Any(type => typeof(T).IsAssignableFrom(type) || type.IsAssignableFrom(typeof(T)));
+    }
+    
+    public static TryGet<T> TryGet<T>(this BaseToken token) where T : Value
+    {
+        if (token is not IValueToken valToken) return $"Value '{token.RawRep}' cannot represent a {typeof(T).FriendlyTypeName()}";
         
-        get = valToken.TryGet<T>;
-        return valToken.PossibleValueTypes.Any(type => typeof(T).IsAssignableFrom(type));
+        return valToken.Value().SuccessTryCast<Value, T>();
     }
 
     public static TryGet<T> TryGet<T>(this IValueToken valToken) where T : Value
diff --git a/Helpers/MustSet.cs b/Helpers/MustSet.cs
@@ -0,0 +1,26 @@
+﻿using System;
+
+namespace SER.Helpers;
+
+public struct MustSet<T>
+{
+    private bool _set;
+
+    public T Value
+    {
+        get
+        {
+            if (!_set)
+                throw new InvalidOperationException($"Attempted to get {typeof(T).Name} before it was set.");
+            return field;
+        }
+        set
+        {
+            field = value;
+            _set = true;
+        }
+    }
+
+    public static implicit operator T(MustSet<T> wrapper) => wrapper.Value;
+    public static implicit operator MustSet<T>(T value) => new MustSet<T> { Value = value };
+}
diff --git a/Plugin/MainPlugin.cs b/Plugin/MainPlugin.cs
@@ -73,7 +73,6 @@ public override void Enable()
 
     public override void Disable()
     {
-        ScriptExecutor.Disable();
         Script.StopAll();
         SetPlayerDataMethod.PlayerData.Clear();
     }
diff --git a/SER.csproj b/SER.csproj
@@ -108,6 +108,7 @@
         <Compile Include="ArgumentSystem\Arguments\ScriptArgument.cs" />
         <Compile Include="ArgumentSystem\Arguments\TextArgument.cs" />
         <Compile Include="ArgumentSystem\Arguments\TokenArgument.cs" />
+        <Compile Include="ArgumentSystem\Arguments\UnknownReferenceArgument.cs" />
         <Compile Include="ArgumentSystem\Arguments\ValueArgument.cs" />
         <Compile Include="ArgumentSystem\Arguments\VariableArgument.cs" />
         <Compile Include="ArgumentSystem\BaseArguments\Argument.cs" />
@@ -160,6 +161,7 @@
         <Compile Include="Helpers\Exceptions\AndrzejFuckedUpException.cs" />
         <Compile Include="Helpers\Exceptions\ScriptRuntimeError.cs" />
         <Compile Include="Helpers\Extensions\SerExtensions.cs" />
+        <Compile Include="Helpers\MustSet.cs" />
         <Compile Include="Helpers\NumericExpressionReslover.cs" />
         <Compile Include="Helpers\Extensions\CollectionExtensions.cs" />
         <Compile Include="Helpers\Extensions\DictionaryExtensions.cs" />
@@ -319,6 +321,7 @@
         <Compile Include="TokenSystem\Tokens\CommentToken.cs" />
         <Compile Include="TokenSystem\Tokens\DurationToken.cs" />
         <Compile Include="TokenSystem\Tokens\ExpressionTokens\ExpressionToken.cs" />
+        <Compile Include="TokenSystem\Tokens\ExpressionTokens\LiteralVariableExpressionToken.cs" />
         <Compile Include="TokenSystem\Tokens\ExpressionTokens\MethodExpressionToken.cs" />
         <Compile Include="TokenSystem\Tokens\ExpressionTokens\PlayerExpressionToken.cs" />
         <Compile Include="TokenSystem\Tokens\FlagArgumentToken.cs" />
diff --git a/TokenSystem/Slices/CollectionSlice.cs b/TokenSystem/Slices/CollectionSlice.cs
@@ -9,13 +9,12 @@ namespace SER.TokenSystem.Slices;
 
 public class CollectionSlice : Slice
 {
-    private uint _depth = 1;
     private bool _ignoreNext = false;
-    private readonly CollectionSliceInfo _info;
+    private readonly Stack<CollectionSliceInfo> _contexts = new();
     private readonly StringBuilder _value = new();
+    private readonly CollectionSliceInfo _rootInfo;
 
-    public CollectionBrackets Type => _info.Type;
-    
+    public CollectionBrackets Type => _rootInfo.Type;
     public override string Value => _value.ToString();
 
     public record CollectionSliceInfo(char Start, char End, CollectionBrackets Type);
@@ -27,59 +26,71 @@ public record CollectionSliceInfo(char Start, char End, CollectionBrackets Type)
         new('"', '"', CollectionBrackets.Quotes),
     ];
 
-    public static readonly HashSet<char> CollectionStarters = CollectionSliceInfos.Select(i => i.Start).ToHashSet();
+    public static readonly HashSet<char> CollectionStarters = CollectionSliceInfos
+        .Select(i => i.Start)
+        .ToHashSet();
 
     public CollectionSlice(char startChar) : base(startChar)
     {
-        if (!CollectionStarters.Contains(startChar)) 
+        if (!CollectionStarters.Contains(startChar))
             throw new AndrzejFuckedUpException();
-        
-        _info = CollectionSliceInfos.FirstOrDefault(i => i.Start == startChar) 
-                ?? throw new AndrzejFuckedUpException();
+
+        _rootInfo = CollectionSliceInfos.First(i => i.Start == startChar);
+        _contexts.Push(_rootInfo);
     }
 
     public override bool CanContinueAfterAdd(char c)
     {
         PrivateRawRepresentation.Append(c);
-        if (_ignoreNext)    
+        
+        if (_ignoreNext)
         {
             _ignoreNext = false;
             _value.Append(c);
             return true;
         }
-        
+
         if (c == '`')
         {
             _ignoreNext = true;
             return true;
         }
-
-        char[] startChars = [_info.Start];
-        char[] endChars = [_info.End];
-        if (_info.Type == CollectionBrackets.Quotes)
-        {
-            var curly = CollectionSliceInfos.First(i => i.Type == CollectionBrackets.Curly);
-            startChars = startChars.Append(curly.Start).ToArray();
-            endChars = endChars.Append(curly.End).ToArray();
-        }
         
-        if (endChars.Contains(c) && --_depth <= 0)
+        var current = _contexts.Peek();
+        
+        if (c == current.End)
         {
-            return false;
+            _contexts.Pop();
+            
+            if (_contexts.Count == 0)
+            {
+                return false;
+            }
+
+            _value.Append(c);
+            return true;
         }
         
-        _value.Append(c);
-
-        if (startChars.Contains(c))
+        var opener = CollectionSliceInfos.FirstOrDefault(i => i.Start == c);
+        if (opener != null)
         {
-            _depth++;
+            if (current.Type == CollectionBrackets.Quotes)
+            {
+                if (opener.Type == CollectionBrackets.Curly)
+                    _contexts.Push(opener);
+            }
+            else
+            {
+                _contexts.Push(opener);
+            }
         }
-        
+
+        _value.Append(c);
         return true;
     }
 
     public override Result VerifyState()
     {
-        return Result.Assert(_depth == 0, $"Collection '{RawRep}' was not closed.");
+        return Result.Assert(_contexts.Count == 0, $"Collection '{RawRep}' was not closed.");
     }
-}
+}
diff --git a/TokenSystem/Tokenizer.cs b/TokenSystem/Tokenizer.cs
@@ -36,6 +36,7 @@ public static class Tokenizer
     [
         typeof(PlayerExpressionToken),
         typeof(MethodExpressionToken),
+        typeof(LiteralVariableExpressionToken),
         
         typeof(ParenthesesToken),
         
diff --git a/TokenSystem/Tokens/ExpressionTokens/ExpressionToken.cs b/TokenSystem/Tokens/ExpressionTokens/ExpressionToken.cs
@@ -35,10 +35,14 @@ protected override IParseResult InternalParse(Script scr)
 
     public static TryGet<ExpressionToken> TryParse(CollectionSlice slice, Script script)
     {
-        if (!Tokenizer.GetTokenFromSlice(slice, script, null).WasSuccessful(out var val) 
-            || val is not ExpressionToken expToken)
+        if (Tokenizer.GetTokenFromSlice(slice, script, null).HasErrored(out var error, out var val))
         {
-            return $"Value '{slice.RawRep}' is not an expression.";
+            return error;
+        }
+
+        if (val is not ExpressionToken expToken)
+        {
+            return $"Token '{slice.RawRep}' is not an {typeof(ExpressionToken).FriendlyTypeName()}, but a {val.GetType().FriendlyTypeName()}";
         }
         
         return expToken;
diff --git a/TokenSystem/Tokens/ExpressionTokens/LiteralVariableExpressionToken.cs b/TokenSystem/Tokens/ExpressionTokens/LiteralVariableExpressionToken.cs
@@ -0,0 +1,28 @@
+﻿using System;
+using System.Linq;
+using SER.Helpers;
+using SER.Helpers.ResultSystem;
+using SER.TokenSystem.Tokens.VariableTokens;
+using SER.ValueSystem;
+
+namespace SER.TokenSystem.Tokens.ExpressionTokens;
+
+public class LiteralVariableExpressionToken : ExpressionToken
+{
+    private MustSet<LiteralVariableToken> _varToken = null!;
+    
+    protected override IParseResult InternalParse(BaseToken[] tokens)
+    {
+        if (tokens.Length != 1 || tokens.First() is not LiteralVariableToken literalVariableToken)
+        {
+            return new Ignore();
+        }
+        
+        _varToken = literalVariableToken;
+        return new Success();
+    }
+
+    public override TryGet<Value> Value() => _varToken.Value.Value();
+
+    public override Type[]? PossibleValueTypes => [typeof(LiteralValue)];
+}
diff --git a/TokenSystem/Tokens/ExpressionTokens/MethodExpressionToken.cs b/TokenSystem/Tokens/ExpressionTokens/MethodExpressionToken.cs
@@ -1,7 +1,9 @@
 ﻿using System;
 using System.Linq;
 using SER.ContextSystem;
+using SER.Helpers;
 using SER.Helpers.Exceptions;
+using SER.Helpers.Extensions;
 using SER.Helpers.ResultSystem;
 using SER.MethodSystem.BaseMethods;
 using SER.ValueSystem;
@@ -24,7 +26,7 @@ protected override IParseResult InternalParse(BaseToken[] tokens)
             return new Error($"Method '{methodToken.Method.Name}' does not return a value.");
         }
         
-        if (Contexter.ContextLine(tokens, null, Script).HasErrored(out var contextError, out var context))
+        if (Contexter.ContextLine(tokens, null, Script).HasErrored(out var contextError))
         {
             return new Error(contextError);
         }
@@ -33,7 +35,13 @@ protected override IParseResult InternalParse(BaseToken[] tokens)
         return new Success();
     }
 
-    public override TryGet<Value> Value() => _method?.ReturnValue ?? throw new AndrzejFuckedUpException();
+    public override TryGet<Value> Value()
+    {
+        if (_method is null) throw new AndrzejFuckedUpException();
+        
+        _method.Execute();
+        return _method.ReturnValue ?? throw new AndrzejFuckedUpException();
+    }
 
     public override Type[]? PossibleValueTypes => null;
 }
diff --git a/TokenSystem/Tokens/ParenthesesToken.cs b/TokenSystem/Tokens/ParenthesesToken.cs
diff --git a/TokenSystem/Tokens/TextToken.cs b/TokenSystem/Tokens/TextToken.cs

Original file line number	Diff line number	Diff line change
`@@ -16,7 +16,7 @@ public class DurationArgument(string name) : Argument(name)`
`16`	`16`	`[UsedImplicitly]`
`17`	`17`	`public DynamicTryGet<TimeSpan> GetConvertSolution(BaseToken token)`
`18`	`18`	`{`
`19`		`- if (token is not IValueToken valueToken \|\| valueToken.CanReturn<DurationValue>(out var get))`
	`19`	`+ if (token is not IValueToken valueToken \|\| !valueToken.CanReturn<DurationValue>(out var get))`
`20`	`20`	`{`
`21`	`21`	`return $"Value '{token.RawRep}' is not a duration.";`
`22`	`22`	`}`
Original file line number	Diff line number	Diff line change
`@@ -58,6 +58,7 @@ public DynamicTryGet<float> GetConvertSolution(BaseToken token)`
`58`	`58`	`{`
`59`	`59`	`return VerifyRange(number.Value.ExactValue);`
`60`	`60`	`}`
	`61`	`+`
`61`	`62`	`return new(() => token.TryGetLiteralValue<NumberValue>().OnSuccess(VerifyRange));`
`62`	`63`	`}`
`63`	`64`
Original file line number	Diff line number	Diff line change
`@@ -20,16 +20,16 @@ public DynamicTryGet<string> GetConvertSolution(BaseToken token)`
`20`	`20`	`return textToken.GetDynamicResolver();`
`21`	`21`	`}`
`22`	`22`
`23`		`- if (token is not IValueToken valToken \|\| valToken.CanReturn<TextValue>(out var get))`
	`23`	`+ if (token is not IValueToken valToken \|\| !valToken.CanReturn<LiteralValue>(out var get))`
`24`	`24`	`{`
`25`	`25`	`return DynamicTryGet.Error($"Value '{token.RawRep}' cannot represent text.");`
`26`	`26`	`}`
`27`	`27`
`28`	`28`	`if (valToken.IsConstant)`
`29`	`29`	`{`
`30`		`- return get().OnSuccess(v => v.ExactValue);`
	`30`	`+ return get().OnSuccess(v => v.StringRep);`
`31`	`31`	`}`
`32`	`32`
`33`		`- return new(() => get().OnSuccess(v => v.ExactValue));`
	`33`	`+ return new(() => get().OnSuccess(v => v.StringRep));`
`34`	`34`	`}`
`35`	`35`	`}`
Original file line number	Diff line number	Diff line change
`@@ -14,7 +14,7 @@ public class ValueArgument<T>(string name) : Argument(name) where T : Value`
`14`	`14`	`[UsedImplicitly]`
`15`	`15`	`public DynamicTryGet<T> GetConvertSolution(BaseToken token)`
`16`	`16`	`{`
`17`		`- if (token.CanReturn<T>(out var get))`
	`17`	`+ if (!token.CanReturn<T>(out var get))`
`18`	`18`	`{`
`19`	`19`	`return $"Value '{token.RawRep}' cannot represent {InputDescription}";`
`20`	`20`	`}`
Original file line number	Diff line number	Diff line change
`@@ -73,7 +73,6 @@ public override void Enable()`
`73`	`73`
`74`	`74`	`public override void Disable()`
`75`	`75`	`{`
`76`		`- ScriptExecutor.Disable();`
`77`	`76`	`Script.StopAll();`
`78`	`77`	`SetPlayerDataMethod.PlayerData.Clear();`
`79`	`78`	`}`