ScriptedEvents
diff --git a/‎Code/ArgumentSystem/Arguments/VariableArgument.cs‎
Lines changed: 20 additions & 0 deletions b/‎Code/ArgumentSystem/Arguments/VariableArgument.cs‎
Lines changed: 20 additions & 0 deletions
diff --git a/‎Code/ArgumentSystem/ProvidedArguments.cs‎
Lines changed: 25 additions & 10 deletions b/‎Code/ArgumentSystem/ProvidedArguments.cs‎
Lines changed: 25 additions & 10 deletions
diff --git a/‎Code/ContextSystem/BaseContexts/Context.cs‎
Lines changed: 7 additions & 5 deletions b/‎Code/ContextSystem/BaseContexts/Context.cs‎
Lines changed: 7 additions & 5 deletions
diff --git a/‎Code/ContextSystem/BaseContexts/LoopContext.cs‎
Lines changed: 28 additions & 8 deletions b/‎Code/ContextSystem/BaseContexts/LoopContext.cs‎
Lines changed: 28 additions & 8 deletions
diff --git a/‎Code/ContextSystem/BaseContexts/LoopContextWithSingleIterationVariable.cs‎
Lines changed: 47 additions & 0 deletions b/‎Code/ContextSystem/BaseContexts/LoopContextWithSingleIterationVariable.cs‎
Lines changed: 47 additions & 0 deletions
diff --git a/‎Code/ContextSystem/BaseContexts/StatementContext.cs‎
Lines changed: 16 additions & 2 deletions b/‎Code/ContextSystem/BaseContexts/StatementContext.cs‎
Lines changed: 16 additions & 2 deletions
diff --git a/‎Code/ContextSystem/BaseContexts/YieldingContext.cs‎
Lines changed: 8 additions & 2 deletions b/‎Code/ContextSystem/BaseContexts/YieldingContext.cs‎
Lines changed: 8 additions & 2 deletions
diff --git a/‎Code/ContextSystem/CommunicationInterfaces/IAcceptOptionalVariableDefinitions.cs‎
Lines changed: 12 additions & 0 deletions b/‎Code/ContextSystem/CommunicationInterfaces/IAcceptOptionalVariableDefinitions.cs‎
Lines changed: 12 additions & 0 deletions
diff --git a/‎Code/ContextSystem/CommunicationInterfaces/IRequireCurrentStatement.cs‎
Lines changed: 12 additions & 0 deletions b/‎Code/ContextSystem/CommunicationInterfaces/IRequireCurrentStatement.cs‎
Lines changed: 12 additions & 0 deletions
@@ -1,5 +1,6 @@
 using JetBrains.Annotations;
 using SER.Code.ArgumentSystem.BaseArguments;
+using SER.Code.Helpers.Extensions;
 using SER.Code.Helpers.ResultSystem;
 using SER.Code.TokenSystem.Tokens;
 using SER.Code.TokenSystem.Tokens.VariableTokens;
@@ -24,4 +25,23 @@ public DynamicTryGet<Variable> GetConvertSolution(BaseToken token)
 
         return new(() => variableToken.TryGetVariable());
     }
+}
+
+public class VariableArgument<T>(string name) : Argument(name) where T : Variable
+{
+    public override string InputDescription => $"A {typeof(T).FriendlyTypeName()}";
+
+    [UsedImplicitly]
+    public DynamicTryGet<T> GetConvertSolution(BaseToken token)
+    {
+        if (token is not VariableToken variableToken)
+        {
+            return $"Value '{token.RawRep}' is not a variable.";
+        }
+
+        return new(() => variableToken
+                .TryGetVariable()
+                .SuccessTryCast<Variable, T>()
+        );
+    }
 }
@@ -20,8 +20,13 @@ namespace SER.Code.ArgumentSystem;
 
 public class ProvidedArguments(Method method)
 {
-    private Dictionary<(string name, Type type), List<DynamicTryGet>> Arguments { get; } = [];
+    private Dictionary<(string name, Type type), List<DynamicTryGet>> ArgumentValues { get; } = [];
 
+    public T GetVariable<T>(string argName) where T : Variable
+    {
+        return GetValue<T, VariableArgument<T>>(argName);
+    }
+    
     public Database GetDatabase(string argName)
     {
         return GetValue<Database, DatabaseArgument>(argName);
@@ -211,7 +216,7 @@ private List<DynamicTryGet<TValue>> GetEvaluators<TValue, TArg>(string argName)
         {
             if (evaluator.Result.HasErrored(out var error))
             {
-                throw new ScriptRuntimeError(mainErr + error);
+                throw new CustomScriptRuntimeError(mainErr + error);
             }
 
             if (evaluator is not DynamicTryGet<TValue> argEvalRes)
@@ -226,7 +231,7 @@ private List<DynamicTryGet<TValue>> GetEvaluators<TValue, TArg>(string argName)
 
     private List<DynamicTryGet> GetValueInternal<TValue, TArg>(string argName)
     {
-        if (Arguments.TryGetValue((argName, typeof(TArg)), out var value))
+        if (ArgumentValues.TryGetValue((argName, typeof(TArg)), out var value))
         {
             return value;
         }
@@ -239,18 +244,28 @@ private List<DynamicTryGet> GetValueInternal<TValue, TArg>(string argName)
 
         if (foundArg.DefaultValue is null)
         {
-            throw new ScriptRuntimeError($"Method '{method.Name}' is missing required argument '{argName}'.");
+            throw new CustomScriptRuntimeError($"{method} is missing a required argument '{argName}'.");
         }
 
         return foundArg.DefaultValue.Value switch
         {
-            TValue argValue => [new DynamicTryGet<TValue>(argValue)],
-            IEnumerable<TValue> listValue => listValue.Select(DynamicTryGet (v) => new DynamicTryGet<TValue>(v)).ToList(),
-            null => [new DynamicTryGet<TValue>((TValue)(object)null!)], // magik
+            TValue argValue => [
+                new DynamicTryGet<TValue>(argValue)
+            ],
+            
+            IEnumerable<TValue> listValue => listValue
+                .Select(DynamicTryGet (v) => new DynamicTryGet<TValue>(v))
+                .ToList(),
+            
+            null => [
+                new DynamicTryGet<TValue>((TValue)(object)null!)
+            ], // magik
+            
             _ => throw new AndrzejFuckedUpException(
                 $"Argument {argName} for method {method.Name} has its default value set to type " +
                 $"{foundArg.DefaultValue?.GetType().AccurateName ?? "null"}, expected of type {typeof(TValue).Name} or a list of " +
-                $"{typeof(TValue).Name}s.")
+                $"{typeof(TValue).Name}s."
+            )
         };
     }
 
@@ -259,10 +274,10 @@ public void Add(ArgumentValueInfo valueInfo)
         Log.Debug($"adding {valueInfo.Name} for method {method.Name} ({method.GetHashCode()})");
         if (!valueInfo.IsPartOfCollection)
         {
-            Arguments.Add((valueInfo.Name, valueInfo.ArgumentType), [valueInfo.Evaluator]);
+            ArgumentValues.Add((valueInfo.Name, valueInfo.ArgumentType), [valueInfo.Evaluator]);
             return;
         }
 
-        Arguments.AddOrInitListWithKey((valueInfo.Name, valueInfo.ArgumentType), valueInfo.Evaluator);
+        ArgumentValues.AddOrInitListWithKey((valueInfo.Name, valueInfo.ArgumentType), valueInfo.Evaluator);
     }
 }
@@ -1,5 +1,4 @@
 using SER.Code.ContextSystem.Structures;
-using SER.Code.Helpers.Extensions;
 using SER.Code.Helpers.ResultSystem;
 using SER.Code.ScriptSystem;
 using SER.Code.TokenSystem.Tokens;
@@ -8,14 +7,14 @@ namespace SER.Code.ContextSystem.BaseContexts;
 
 public abstract class Context
 {
-    public string Name => GetType().FriendlyTypeName();
-    
     public required Script Script { get; set; } = null!;
-    
+
     public required uint? LineNum { get; set; }
 
     public StatementContext? ParentContext { get; set; } = null;
 
+    protected abstract string FriendlyName { get; }
+
     public abstract TryAddTokenRes TryAddToken(BaseToken token);
 
     public abstract Result VerifyCurrentState();
@@ -30,6 +29,9 @@ public static Context Create(Type contextType, (Script scr, uint? lineNum) info)
 
     public override string ToString()
     {
-        return Name;
+        if (LineNum.HasValue) 
+            return $"{FriendlyName} at line {LineNum}";
+        
+        return FriendlyName;
     }
 }
@@ -1,4 +1,6 @@
-using SER.Code.ContextSystem.Structures;
+using SER.Code.ContextSystem.Extensions;
+using SER.Code.ContextSystem.Interfaces;
+using SER.Code.ContextSystem.Structures;
 
 namespace SER.Code.ContextSystem.BaseContexts;
 
@@ -10,23 +12,41 @@ public abstract class LoopContext : StatementContext, IExtendableStatement, IKey
     public abstract string KeywordName { get; }
     public abstract string Description { get; }
     public abstract string[] Arguments { get; }
-    
-    public bool SkipThisIteration { get; protected set; }
-    public bool ExitLoop { get; protected set; }
 
+    protected bool ReceivedContinue;
+    protected bool ReceivedBreak;
     protected override void OnReceivedControlMessageFromChild(ParentContextControlMessage msg)
     {
         switch (msg)
         {
-            case ParentContextControlMessage.LoopContinue:
-                SkipThisIteration = true;
+            case Continue:
+                ReceivedContinue = true;
                 return;
-            case ParentContextControlMessage.LoopBreak:
-                ExitLoop = true;
+            case Break:
+                ReceivedBreak = true;
                 return;
             default:
                 ParentContext?.SendControlMessage(msg);
                 break;
         }
     }
+
+    protected override IEnumerator<float> RunChildren()
+    {
+        foreach (var coro in Children
+                     .TakeWhile(_ => !ReceivedBreak)
+                     .TakeWhile(_ => Script.IsRunning)
+                     .Select(child => child.ExecuteBaseContext()))
+        {
+            while (coro.MoveNext())
+            {
+                yield return coro.Current;
+            }
+
+            if (!ReceivedContinue) continue;
+
+            ReceivedContinue = false;
+            break;
+        }
+    }
 }
@@ -0,0 +1,47 @@
+using SER.Code.ContextSystem.CommunicationInterfaces;
+using SER.Code.Helpers.Extensions;
+using SER.Code.Helpers.ResultSystem;
+using SER.Code.TokenSystem.Tokens.VariableTokens;
+using SER.Code.ValueSystem;
+using SER.Code.VariableSystem.Bases;
+
+namespace SER.Code.ContextSystem.BaseContexts;
+
+public abstract class LoopContextWithSingleIterationVariable<TVal> : 
+    LoopContext, 
+    IAcceptOptionalVariableDefinitions 
+    where TVal : Value
+{
+    private VariableToken? _iterationVariableToken;
+    private Variable? _iterationVariable;
+    
+    public Result SetOptionalVariables(params VariableToken[] variableTokens)
+    {
+        if (variableTokens.FirstOrDefault() is not {} varToken) return true;
+
+        if (!varToken.ValueType.IsAssignableFrom(typeof(TVal)))
+        {
+            return $"Provided variable '{varToken.RawRepr}' cannot be used for this loop, " +
+                   $"as it cannot hold a {typeof(TVal).FriendlyTypeName()}";
+        }
+        
+        _iterationVariableToken = varToken;
+        return true;
+    }
+    
+    protected void SetVariable(TVal value)
+    {
+        if (_iterationVariableToken is null) return;
+        
+        _iterationVariable = Variable.Create(_iterationVariableToken.Name, value);
+        Script.AddVariable(_iterationVariable);
+    }
+
+    protected void RemoveVariable()
+    {
+        if (_iterationVariable is null) return;
+        
+        Script.RemoveVariable(_iterationVariable);
+        _iterationVariable = null;
+    }
+}
@@ -1,4 +1,5 @@
-using SER.Code.ContextSystem.Structures;
+using SER.Code.ContextSystem.Extensions;
+using SER.Code.ContextSystem.Structures;
 using SER.Code.Helpers;
 
 namespace SER.Code.ContextSystem.BaseContexts;
@@ -9,12 +10,25 @@ public abstract class StatementContext : YieldingContext
 
     public void SendControlMessage(ParentContextControlMessage msg)
     {
-        Log.Debug($"{Name} context has received control message: {msg}");
+        Log.Debug($"{this} has received control message: {msg}");
         OnReceivedControlMessageFromChild(msg);
     }
 
     protected virtual void OnReceivedControlMessageFromChild(ParentContextControlMessage msg)
     {
         ParentContext?.SendControlMessage(msg);
     }
+    
+    protected virtual IEnumerator<float> RunChildren()
+    {
+        foreach (var coro in Children
+                     .TakeWhile(_ => Script.IsRunning)
+                     .Select(child => child.ExecuteBaseContext()))
+        {
+            while (coro.MoveNext())
+            {
+                yield return coro.Current;
+            }
+        }
+    }
 }
@@ -1,13 +1,19 @@
-using SER.Code.Helpers;
+using SER.Code.ContextSystem.Interfaces;
+using SER.Code.Helpers;
 
 namespace SER.Code.ContextSystem.BaseContexts;
 
 public abstract class YieldingContext : Context
 {
     public IEnumerator<float> Run()
     {
+        if (this is INotRunningContext)
+        {
+            yield break;
+        }
+        
         var prof = Script.Profile is not null 
-            ? new Profile(Script.Profile, $"running YieldingContext {Name}")
+            ? new Profile(Script.Profile, $"running YieldingContext {this}")
             : null;
 
         if (LineNum.HasValue)
 
@@ -0,0 +1,12 @@
+using SER.Code.Helpers.ResultSystem;
+using SER.Code.TokenSystem.Tokens.VariableTokens;
+
+namespace SER.Code.ContextSystem.CommunicationInterfaces;
+
+/// <summary>
+/// Marks that the context before is a statement that accepts optional variable definitions.
+/// </summary>
+public interface IAcceptOptionalVariableDefinitions
+{
+    public Result SetOptionalVariables(params VariableToken[] variableTokens);
+}
@@ -0,0 +1,12 @@
+using SER.Code.ContextSystem.BaseContexts;
+using SER.Code.Helpers.ResultSystem;
+
+namespace SER.Code.ContextSystem.CommunicationInterfaces;
+
+/// <summary>
+/// Requests the previous statement context to be provided
+/// </summary>
+public interface IRequireCurrentStatement
+{
+    public Result AcceptStatement(StatementContext context);
+}
Original file line number	Diff line number	Diff line change
`@@ -20,8 +20,13 @@ namespace SER.Code.ArgumentSystem;`
`20`	`20`
`21`	`21`	`public class ProvidedArguments(Method method)`
`22`	`22`	`{`
`23`		`- private Dictionary<(string name, Type type), List<DynamicTryGet>> Arguments { get; } = [];`
	`23`	`+ private Dictionary<(string name, Type type), List<DynamicTryGet>> ArgumentValues { get; } = [];`
`24`	`24`
	`25`	`+ public T GetVariable<T>(string argName) where T : Variable`
	`26`	`+ {`
	`27`	`+ return GetValue<T, VariableArgument<T>>(argName);`
	`28`	`+ }`
	`29`	`+`
`25`	`30`	`public Database GetDatabase(string argName)`
`26`	`31`	`{`
`27`	`32`	`return GetValue<Database, DatabaseArgument>(argName);`
`@@ -211,7 +216,7 @@ private List<DynamicTryGet<TValue>> GetEvaluators<TValue, TArg>(string argName)`
`211`	`216`	`{`
`212`	`217`	`if (evaluator.Result.HasErrored(out var error))`
`213`	`218`	`{`
`214`		`- throw new ScriptRuntimeError(mainErr + error);`
	`219`	`+ throw new CustomScriptRuntimeError(mainErr + error);`
`215`	`220`	`}`
`216`	`221`
`217`	`222`	`if (evaluator is not DynamicTryGet<TValue> argEvalRes)`
`@@ -226,7 +231,7 @@ private List<DynamicTryGet<TValue>> GetEvaluators<TValue, TArg>(string argName)`
`226`	`231`
`227`	`232`	`private List<DynamicTryGet> GetValueInternal<TValue, TArg>(string argName)`
`228`	`233`	`{`
`229`		`- if (Arguments.TryGetValue((argName, typeof(TArg)), out var value))`
	`234`	`+ if (ArgumentValues.TryGetValue((argName, typeof(TArg)), out var value))`
`230`	`235`	`{`
`231`	`236`	`return value;`
`232`	`237`	`}`
`@@ -239,18 +244,28 @@ private List<DynamicTryGet> GetValueInternal<TValue, TArg>(string argName)`
`239`	`244`
`240`	`245`	`if (foundArg.DefaultValue is null)`
`241`	`246`	`{`
`242`		`- throw new ScriptRuntimeError($"Method '{method.Name}' is missing required argument '{argName}'.");`
	`247`	`+ throw new CustomScriptRuntimeError($"{method} is missing a required argument '{argName}'.");`
`243`	`248`	`}`
`244`	`249`
`245`	`250`	`return foundArg.DefaultValue.Value switch`
`246`	`251`	`{`
`247`		`- TValue argValue => [new DynamicTryGet<TValue>(argValue)],`
`248`		`- IEnumerable<TValue> listValue => listValue.Select(DynamicTryGet (v) => new DynamicTryGet<TValue>(v)).ToList(),`
`249`		`- null => [new DynamicTryGet<TValue>((TValue)(object)null!)], // magik`
	`252`	`+ TValue argValue => [`
	`253`	`+ new DynamicTryGet<TValue>(argValue)`
	`254`	`+ ],`
	`255`	`+`
	`256`	`+ IEnumerable<TValue> listValue => listValue`
	`257`	`+ .Select(DynamicTryGet (v) => new DynamicTryGet<TValue>(v))`
	`258`	`+ .ToList(),`
	`259`	`+`
	`260`	`+ null => [`
	`261`	`+ new DynamicTryGet<TValue>((TValue)(object)null!)`
	`262`	`+ ], // magik`
	`263`	`+`
`250`	`264`	`_ => throw new AndrzejFuckedUpException(`
`251`	`265`	`$"Argument {argName} for method {method.Name} has its default value set to type " +`
`252`	`266`	`$"{foundArg.DefaultValue?.GetType().AccurateName ?? "null"}, expected of type {typeof(TValue).Name} or a list of " +`
`253`		`- $"{typeof(TValue).Name}s.")`
	`267`	`+ $"{typeof(TValue).Name}s."`
	`268`	`+ )`
`254`	`269`	`};`
`255`	`270`	`}`
`256`	`271`
`@@ -259,10 +274,10 @@ public void Add(ArgumentValueInfo valueInfo)`
`259`	`274`	`Log.Debug($"adding {valueInfo.Name} for method {method.Name} ({method.GetHashCode()})");`
`260`	`275`	`if (!valueInfo.IsPartOfCollection)`
`261`	`276`	`{`
`262`		`- Arguments.Add((valueInfo.Name, valueInfo.ArgumentType), [valueInfo.Evaluator]);`
	`277`	`+ ArgumentValues.Add((valueInfo.Name, valueInfo.ArgumentType), [valueInfo.Evaluator]);`
`263`	`278`	`return;`
`264`	`279`	`}`
`265`	`280`
`266`		`- Arguments.AddOrInitListWithKey((valueInfo.Name, valueInfo.ArgumentType), valueInfo.Evaluator);`
	`281`	`+ ArgumentValues.AddOrInitListWithKey((valueInfo.Name, valueInfo.ArgumentType), valueInfo.Evaluator);`
`267`	`282`	`}`
`268`	`283`	`}`