Merge branch 'main' into dev

Tosoks67 · Tosoks67 · commit e877b6cf999e · 2026-02-18T19:14:35.000+01:00
diff --git a/Code/ArgumentSystem/Arguments/BoolArgument.cs b/Code/ArgumentSystem/Arguments/BoolArgument.cs
@@ -18,7 +18,7 @@ public class BoolArgument(string name) : Argument(name)
     public DynamicTryGet<bool> GetConvertSolution(BaseToken token)
     {
         Result error = $"Value '{token.RawRep}' cannot be interpreted as a boolean value or condition.";
-        if (token is not IValueToken valueToken || !valueToken.CanReturn<BoolValue>(out var get))
+        if (token is not IValueToken valueToken || !valueToken.CapableOf<BoolValue>(out var get))
         {
             return error;
         }
diff --git a/Code/ArgumentSystem/Arguments/CollectionArgument.cs b/Code/ArgumentSystem/Arguments/CollectionArgument.cs
@@ -16,7 +16,7 @@ public class CollectionArgument(string name) : Argument(name)
     [UsedImplicitly]
     public DynamicTryGet<CollectionValue> GetConvertSolution(BaseToken token)
     {
-        if (token is not IValueToken valToken || !valToken.CanReturn<CollectionValue>(out var func))
+        if (!token.CanReturn<CollectionValue>(out var func))
         {
             return $"Value '{token.RawRep}' does not represent a collection";
         }
diff --git a/Code/ArgumentSystem/Arguments/DoorArgument.cs b/Code/ArgumentSystem/Arguments/DoorArgument.cs
@@ -49,7 +49,7 @@ public DynamicTryGet<Door> GetConvertSolution(BaseToken token)
             {
                 Result rs = $"Value '{token.RawRep}' cannot be interpreted as {InputDescription}.";
                 
-                if (token is not IValueToken val || !val.CanReturn<ReferenceValue>(out var func))
+                if (token is not IValueToken val || !val.CapableOf<ReferenceValue>(out var func))
                 {
                     return rs;
                 }
diff --git a/Code/ArgumentSystem/Arguments/DoorsArgument.cs b/Code/ArgumentSystem/Arguments/DoorsArgument.cs
@@ -47,7 +47,7 @@ public DynamicTryGet<Door[]> GetConvertSolution(BaseToken token)
                     return Door.List.Where(d => d is not ElevatorDoor).ToArray();
                 }
 
-                if (token is not IValueToken valToken || !valToken.CanReturn<ReferenceValue>(out var get))
+                if (!token.CanReturn<ReferenceValue>(out var get))
                 {
                     return rs;
                 }
diff --git a/Code/ArgumentSystem/Arguments/DurationArgument.cs b/Code/ArgumentSystem/Arguments/DurationArgument.cs
@@ -16,7 +16,7 @@ public class DurationArgument(string name) : Argument(name)
     public DynamicTryGet<TimeSpan> GetConvertSolution(BaseToken token)
     {
         Result rs = $"Value '{token.RawRep}' is not a duration.";
-        if (token is not IValueToken valueToken || !valueToken.CanReturn<DurationValue>(out var get))
+        if (token is not IValueToken valueToken || !valueToken.CapableOf<DurationValue>(out var get))
         {
             return rs;
         }
diff --git a/Code/ArgumentSystem/Arguments/ItemsArgument.cs b/Code/ArgumentSystem/Arguments/ItemsArgument.cs
@@ -31,7 +31,7 @@ public DynamicTryGet<Item[]> GetConvertSolution(BaseToken token)
                     return Item.List.ToArray();
                 }
 
-                if (token is not IValueToken valToken || !valToken.CanReturn<ReferenceValue>(out var get))
+                if (!token.CanReturn<ReferenceValue>(out var get))
                 {
                     return rs;
                 }
diff --git a/Code/ArgumentSystem/Arguments/PlayersArgument.cs b/Code/ArgumentSystem/Arguments/PlayersArgument.cs
@@ -22,7 +22,7 @@ public DynamicTryGet<Player[]> GetConvertSolution(BaseToken token)
             return new(() => Player.ReadyList.ToArray());
         }
 
-        if (token is not IValueToken valToken || !valToken.CanReturn<PlayerValue>(out var get))
+        if (!token.CanReturn<PlayerValue>(out var get))
         {
             return $"Value '{token.RawRep}' does not represent a valid player variable.";
         }
diff --git a/Code/ArgumentSystem/Arguments/RoomArgument.cs b/Code/ArgumentSystem/Arguments/RoomArgument.cs
@@ -26,7 +26,7 @@ public DynamicTryGet<Room> GetConvertSolution(BaseToken token)
             () =>
             {
                 Result rs = $"Value '{token.RawRep}' cannot be interpreted as {InputDescription}.";
-                if (token is not IValueToken valToken || valToken.CanReturn<ReferenceValue>(out var get))
+                if (!token.CanReturn<ReferenceValue>(out var get))
                 {
                     return rs;
                 }
diff --git a/Code/ArgumentSystem/Arguments/TextArgument.cs b/Code/ArgumentSystem/Arguments/TextArgument.cs
@@ -22,7 +22,7 @@ public DynamicTryGet<string> GetConvertSolution(BaseToken token)
             return new(() => textToken.GetDynamicResolver().Invoke().OnSuccess(SpaceCheck, null));
         }    
         
-        if (token is not IValueToken valToken || !valToken.CanReturn<LiteralValue>(out var get))
+        if (token is not IValueToken valToken || !valToken.CapableOf<LiteralValue>(out var get))
         {
             if (!needsQuotes)
             {
diff --git a/Code/ContextSystem/Contexts/Control/Loops/OverLoop.cs b/Code/ContextSystem/Contexts/Control/Loops/OverLoop.cs
@@ -82,7 +82,7 @@ public override TryAddTokenRes TryAddToken(BaseToken token)
             goto Error;
         }
 
-        if (valToken.CanReturn<PlayerValue>(out var getPlayer))
+        if (valToken.CapableOf<PlayerValue>(out var getPlayer))
         {
             _values = () =>
             {
@@ -97,7 +97,7 @@ public override TryAddTokenRes TryAddToken(BaseToken token)
             return TryAddTokenRes.End();
         }
 
-        if (valToken.CanReturn<CollectionValue>(out var getCollection))
+        if (valToken.CapableOf<CollectionValue>(out var getCollection))
         {
             _values = () =>
             {
diff --git a/Code/ContextSystem/Contexts/Control/Loops/RepeatLoop.cs b/Code/ContextSystem/Contexts/Control/Loops/RepeatLoop.cs
@@ -63,7 +63,7 @@ public override TryAddTokenRes TryAddToken(BaseToken token)
             
             case IValueToken valToken:
             {
-                if (!valToken.CanReturn<NumberValue>(out var getNumber))
+                if (!valToken.CapableOf<NumberValue>(out var getNumber))
                 {
                     return TryAddTokenRes.Error($"Value '{token.RawRep}' returns a value, but.");   
                 }
diff --git a/Code/ContextSystem/Contexts/GlobalVariableContext.cs b/Code/ContextSystem/Contexts/GlobalVariableContext.cs
@@ -47,8 +47,16 @@ public override Result VerifyCurrentState()
 
     protected override IEnumerator<float> Execute()
     {
+        _variableContext.CreateLocalVariable = false;
+        
         using var definitionEnumerator = _variableContext.Run();
         while (definitionEnumerator.MoveNext()) yield return definitionEnumerator.Current;
-        VariableIndex.AddGlobalVariable(_variableContext.DefinedVariable ?? throw new TosoksFuckedUpException());
+
+        if (_variableContext.DefinedVariable is null)
+        {
+            throw new TosoksFuckedUpException();
+        }
+        
+        VariableIndex.AddGlobalVariable(_variableContext.DefinedVariable);
     }
 }
diff --git a/Code/ContextSystem/Contexts/VariableDefinition/VariableDefinitionContext.cs b/Code/ContextSystem/Contexts/VariableDefinition/VariableDefinitionContext.cs
@@ -17,6 +17,7 @@ namespace SER.Code.ContextSystem.Contexts.VariableDefinition;
 public abstract class VariableDefinitionContext : YieldingContext
 {
     public Variable? DefinedVariable;
+    public bool CreateLocalVariable = true;
 }
 
 public abstract class VariableDefinitionContext<TVarToken, TValue, TVariable>(TVarToken varToken) : VariableDefinitionContext
@@ -134,16 +135,17 @@ protected override IEnumerator<float> Execute()
             }
 
             DefinedVariable = Variable.Create(varToken.Name, tValue);
-            Script.AddLocalVariable(DefinedVariable);
         }
         else if (_parser is not null)
         {
             DefinedVariable = Variable.Create(varToken.Name, Value.Parse(_parser(), Script));
-            Script.AddLocalVariable(DefinedVariable);
         }
         else
         {
             throw new AndrzejFuckedUpException();
         }
+        
+        if (CreateLocalVariable) 
+            Script.AddLocalVariable(DefinedVariable);
     }
 }
diff --git a/Code/Extensions/SerExtensions.cs b/Code/Extensions/SerExtensions.cs
@@ -44,10 +44,10 @@ 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(out get);
+        return valToken.CapableOf(out get);
     }
     
-    public static bool CanReturn<T>(this IValueToken valToken, out Func<TryGet<T>> get) where T : Value
+    public static bool CapableOf<T>(this IValueToken valToken, out Func<TryGet<T>> get) where T : Value
     {
         get = valToken.TryGet<T>;
         
diff --git a/Code/FlagSystem/Flags/CustomCommandFlag.cs b/Code/FlagSystem/Flags/CustomCommandFlag.cs
@@ -163,7 +163,7 @@ public override Result OnScriptRunning(Script scr)
             return true;
         }
 
-        return $"A script using '{Name}' flag cannot be ran by any other mean than a custom command.";
+        return $"Tried to run script by other mean than the '{Command.Command}' command, which is not allowed.";
     }
 
     public class CustomCommand : ICommand, IUsageProvider, IHelpProvider
diff --git a/Code/FlagSystem/Flags/OnEventFlag.cs b/Code/FlagSystem/Flags/OnEventFlag.cs
@@ -1,4 +1,5 @@
 ﻿using JetBrains.Annotations;
+using SER.Code.Helpers;
 using SER.Code.Helpers.ResultSystem;
 using SER.Code.ScriptSystem;
 using EventHandler = SER.Code.EventSystem.EventHandler;
@@ -8,6 +9,8 @@ namespace SER.Code.FlagSystem.Flags;
 [UsedImplicitly]
 public class OnEventFlag : Flag
 {
+    private Safe<string> _event;
+    
     public override string Description =>
         "Binds a script to an in-game event. When the event happens, the script will execute. " +
         "Events can sometimes also carry information of their own, ";
@@ -25,7 +28,8 @@ public class OnEventFlag : Flag
                     return "Too many arguments, only event name is allowed";
             }
 
-            if (EventHandler.ConnectEvent(inlineArgs.First(), ScriptName).HasErrored(out var error))
+            _event = inlineArgs.First();
+            if (EventHandler.ConnectEvent(_event, ScriptName).HasErrored(out var error))
             {
                 return error;
             }
@@ -42,7 +46,7 @@ public override Result OnScriptRunning(Script scr)
             return true;
         }
         
-        return $"A script using '{Name}' flag cannot be ran by any other mean than an event.";
+        return $"Tried to run script by other mean than the '{_event}' event, which is not allowed.";
     }
 
     public override Argument[] Arguments => [];
diff --git a/Code/FlagSystem/ScriptFlagHandler.cs b/Code/FlagSystem/ScriptFlagHandler.cs
@@ -70,7 +70,7 @@ public static Result DoFlagsApproveExecution(Script scr)
         {
             if (flag.OnScriptRunning(scr).HasErrored(out var error))
             {
-                Result rs = $"Script '{scr.Name}' cannot run due to flag '{flag.Name}'.";
+                Result rs = $"Flag '{flag.Name}' disallows script execution.";
                 return rs + error;
             }
         }
diff --git a/Code/Helpers/NumericExpressionReslover.cs b/Code/Helpers/NumericExpressionReslover.cs
@@ -109,7 +109,7 @@ uint tempId
     {
         switch (token)
         {
-            case IValueToken valueToken when valueToken.CanReturn<LiteralValue>(out var get):
+            case IValueToken valueToken when valueToken.CapableOf<LiteralValue>(out var get):
             {
                 var tmp = MakeTempName();
                 
diff --git a/Code/Helpers/Safe.cs b/Code/Helpers/Safe.cs
@@ -21,4 +21,6 @@ private init
 
     public static implicit operator T(Safe<T> wrapper) => wrapper.Value;
     public static implicit operator Safe<T>(T value) => new() { Value = value };
+    
+    public override string ToString() => Value?.ToString() ?? "null";
 }
diff --git a/Code/MethodSystem/Methods/DoorMethods/BreakDoorMethod.cs b/Code/MethodSystem/Methods/DoorMethods/BreakDoorMethod.cs
@@ -10,7 +10,7 @@ namespace SER.Code.MethodSystem.Methods.DoorMethods;
 [UsedImplicitly]
 public class BreakDoorMethod : SynchronousMethod
 {
-    public override string Description => "Breaks specified doors if possible (for example, you can't destroy Gate B, but you can destroy normal HCZ doors)";
+    public override string Description => "Breaks specified doors if possible.";
 
     public override Argument[] ExpectedArguments { get; } = 
     [
diff --git a/Code/MethodSystem/Methods/NumberMethods/ChanceMethod.cs b/Code/MethodSystem/Methods/NumberMethods/ChanceMethod.cs
@@ -2,21 +2,23 @@
 using SER.Code.ArgumentSystem.Arguments;
 using SER.Code.ArgumentSystem.BaseArguments;
 using SER.Code.MethodSystem.BaseMethods.Synchronous;
+using SER.Code.MethodSystem.MethodDescriptors;
 using SER.Code.ValueSystem;
 
 namespace SER.Code.MethodSystem.Methods.NumberMethods;
 
 [UsedImplicitly]
-public class ChanceMethod : ReturningMethod<BoolValue>
+public class ChanceMethod : ReturningMethod<BoolValue>, IAdditionalDescription
 {
-    public override string Description => 
-        "Returns true with the specified chance, e.g. if set to 20%, true will be returned 20% of the time.";
+    public override string Description => "Returns true with the specified chance.";
+
+    public string AdditionalDescription => "e.g. if set to 20%, true will be returned 20% of the time.";
 
     public override Argument[] ExpectedArguments { get; } =
     [
         new FloatArgument("chance", 0, 1)
     ];
-    
+
     public override void Execute()
     {
         ReturnValue = Args.GetFloat("chance") < UnityEngine.Random.Range(0f, 1f);
diff --git a/Code/MethodSystem/Methods/OutputMethods/ReplyMethod.cs b/Code/MethodSystem/Methods/OutputMethods/ReplyMethod.cs
@@ -9,7 +9,7 @@ namespace SER.Code.MethodSystem.Methods.OutputMethods;
 public class ReplyMethod : SynchronousMethod
 {
     public override string Description => 
-        "Sends a message to the place where the script was run from. Usually used for replying to the command sender.";
+        "Sends a message to the place where the script was run from.";
 
     public override Argument[] ExpectedArguments { get; } =
     [
diff --git a/Code/ScriptSystem/Script.cs b/Code/ScriptSystem/Script.cs
@@ -180,6 +180,10 @@ public void Run(RunContext context = RunContext.Unknown, Script? caller = null)
             return null;
         }
         
+        StartTime = DateTime.Now;
+        Context = context;
+        Caller = caller;
+        
         if (ScriptFlagHandler.DoFlagsApproveExecution(this).HasErrored(out var error))
         {
             Executor.Error(error, this);
@@ -188,9 +192,6 @@ public void Run(RunContext context = RunContext.Unknown, Script? caller = null)
         
         RunningScriptsList.Add(this);
         //Profile = new Profile(this);
-        StartTime = DateTime.Now;
-        Context = context;
-        Caller = caller;
         _scriptCoroutine = InternalExecute().Run(
             this, 
             _ => _scriptCoroutine.Kill()
diff --git a/Code/TokenSystem/Tokens/BaseToken.cs b/Code/TokenSystem/Tokens/BaseToken.cs
@@ -55,7 +55,7 @@ public string GetBestTextRepresentation(Script? script)
             return textToken.Value;
         }
         
-        if (this is IValueToken valueToken && valueToken.CanReturn<LiteralValue>(out var func) && script is not null)
+        if (this is IValueToken valueToken && valueToken.CapableOf<LiteralValue>(out var func) && script is not null)
         {
             if (func().WasSuccessful(out var result))
             {
@@ -80,7 +80,7 @@ public TryGet<T> TryGetLiteralValue<T>() where T : LiteralValue
             return literalValueToken.Value;
         }
 
-        if (this is IValueToken valueToken && valueToken.CanReturn<LiteralValue>(out var get))
+        if (this is IValueToken valueToken && valueToken.CapableOf<LiteralValue>(out var get))
         {
             if (get().HasErrored(out var err, out var value))
             {
diff --git a/Code/VariableSystem/VariableIndex.cs b/Code/VariableSystem/VariableIndex.cs
@@ -77,7 +77,6 @@ public static void Initialize()
 
     public static void AddGlobalVariable(Variable variable)
     {
-        Script.CheckForVariableNameCollisions(variable, GlobalVariables);
         foreach (var runningScript in Script.RunningScripts)
         {
             Script.CheckForVariableNameCollisions(variable, runningScript.LocalVariables);
@@ -89,8 +88,8 @@ public static void AddGlobalVariable(Variable variable)
 
     public static void RemoveGlobalVariable(Variable variable)
     {
-        GlobalVariables.RemoveAll(existingVar => 
-            existingVar.Name == variable.Name &&
-            existingVar.GetType() == variable.GetType());
+        GlobalVariables.RemoveAll(
+            existingVar => Variable.AreSyntacticallySame(existingVar, variable)
+        );
     }
 }

Original file line number	Diff line number	Diff line change
`@@ -18,7 +18,7 @@ public class BoolArgument(string name) : Argument(name)`
`18`	`18`	`public DynamicTryGet<bool> GetConvertSolution(BaseToken token)`
`19`	`19`	`{`
`20`	`20`	`Result error = $"Value '{token.RawRep}' cannot be interpreted as a boolean value or condition.";`
`21`		`- if (token is not IValueToken valueToken \|\| !valueToken.CanReturn<BoolValue>(out var get))`
	`21`	`+ if (token is not IValueToken valueToken \|\| !valueToken.CapableOf<BoolValue>(out var get))`
`22`	`22`	`{`
`23`	`23`	`return error;`
`24`	`24`	`}`
Original file line number	Diff line number	Diff line change
`@@ -16,7 +16,7 @@ public class CollectionArgument(string name) : Argument(name)`
`16`	`16`	`[UsedImplicitly]`
`17`	`17`	`public DynamicTryGet<CollectionValue> GetConvertSolution(BaseToken token)`
`18`	`18`	`{`
`19`		`- if (token is not IValueToken valToken \|\| !valToken.CanReturn<CollectionValue>(out var func))`
	`19`	`+ if (!token.CanReturn<CollectionValue>(out var func))`
`20`	`20`	`{`
`21`	`21`	`return $"Value '{token.RawRep}' does not represent a collection";`
`22`	`22`	`}`
Original file line number	Diff line number	Diff line change
`@@ -49,7 +49,7 @@ public DynamicTryGet<Door> GetConvertSolution(BaseToken token)`
`49`	`49`	`{`
`50`	`50`	`Result rs = $"Value '{token.RawRep}' cannot be interpreted as {InputDescription}.";`
`51`	`51`
`52`		`- if (token is not IValueToken val \|\| !val.CanReturn<ReferenceValue>(out var func))`
	`52`	`+ if (token is not IValueToken val \|\| !val.CapableOf<ReferenceValue>(out var func))`
`53`	`53`	`{`
`54`	`54`	`return rs;`
`55`	`55`	`}`
Original file line number	Diff line number	Diff line change
`@@ -47,7 +47,7 @@ public DynamicTryGet<Door[]> GetConvertSolution(BaseToken token)`
`47`	`47`	`return Door.List.Where(d => d is not ElevatorDoor).ToArray();`
`48`	`48`	`}`
`49`	`49`
`50`		`- if (token is not IValueToken valToken \|\| !valToken.CanReturn<ReferenceValue>(out var get))`
	`50`	`+ if (!token.CanReturn<ReferenceValue>(out var get))`
`51`	`51`	`{`
`52`	`52`	`return rs;`
`53`	`53`	`}`
Original file line number	Diff line number	Diff line change
`@@ -16,7 +16,7 @@ public class DurationArgument(string name) : Argument(name)`
`16`	`16`	`public DynamicTryGet<TimeSpan> GetConvertSolution(BaseToken token)`
`17`	`17`	`{`
`18`	`18`	`Result rs = $"Value '{token.RawRep}' is not a duration.";`
`19`		`- if (token is not IValueToken valueToken \|\| !valueToken.CanReturn<DurationValue>(out var get))`
	`19`	`+ if (token is not IValueToken valueToken \|\| !valueToken.CapableOf<DurationValue>(out var get))`
`20`	`20`	`{`
`21`	`21`	`return rs;`
`22`	`22`	`}`
Original file line number	Diff line number	Diff line change
`@@ -31,7 +31,7 @@ public DynamicTryGet<Item[]> GetConvertSolution(BaseToken token)`
`31`	`31`	`return Item.List.ToArray();`
`32`	`32`	`}`
`33`	`33`
`34`		`- if (token is not IValueToken valToken \|\| !valToken.CanReturn<ReferenceValue>(out var get))`
	`34`	`+ if (!token.CanReturn<ReferenceValue>(out var get))`
`35`	`35`	`{`
`36`	`36`	`return rs;`
`37`	`37`	`}`
Original file line number	Diff line number	Diff line change
`@@ -22,7 +22,7 @@ public DynamicTryGet<Player[]> GetConvertSolution(BaseToken token)`
`22`	`22`	`return new(() => Player.ReadyList.ToArray());`
`23`	`23`	`}`
`24`	`24`
`25`		`- if (token is not IValueToken valToken \|\| !valToken.CanReturn<PlayerValue>(out var get))`
	`25`	`+ if (!token.CanReturn<PlayerValue>(out var get))`
`26`	`26`	`{`
`27`	`27`	`return $"Value '{token.RawRep}' does not represent a valid player variable.";`
`28`	`28`	`}`
Original file line number	Diff line number	Diff line change
`@@ -26,7 +26,7 @@ public DynamicTryGet<Room> GetConvertSolution(BaseToken token)`
`26`	`26`	`() =>`
`27`	`27`	`{`
`28`	`28`	`Result rs = $"Value '{token.RawRep}' cannot be interpreted as {InputDescription}.";`
`29`		`- if (token is not IValueToken valToken \|\| valToken.CanReturn<ReferenceValue>(out var get))`
	`29`	`+ if (!token.CanReturn<ReferenceValue>(out var get))`
`30`	`30`	`{`
`31`	`31`	`return rs;`
`32`	`32`	`}`
Original file line number	Diff line number	Diff line change
`@@ -82,7 +82,7 @@ public override TryAddTokenRes TryAddToken(BaseToken token)`
`82`	`82`	`goto Error;`
`83`	`83`	`}`
`84`	`84`
`85`		`- if (valToken.CanReturn<PlayerValue>(out var getPlayer))`
	`85`	`+ if (valToken.CapableOf<PlayerValue>(out var getPlayer))`
`86`	`86`	`{`
`87`	`87`	`_values = () =>`
`88`	`88`	`{`
`@@ -97,7 +97,7 @@ public override TryAddTokenRes TryAddToken(BaseToken token)`
`97`	`97`	`return TryAddTokenRes.End();`
`98`	`98`	`}`
`99`	`99`
`100`		`- if (valToken.CanReturn<CollectionValue>(out var getCollection))`
	`100`	`+ if (valToken.CapableOf<CollectionValue>(out var getCollection))`
`101`	`101`	`{`
`102`	`102`	`_values = () =>`
`103`	`103`	`{`