generated ysls file now includes game object subclasses for instance commands.

Author: McJones

CHANGELOG.md

@@ -9,10 +9,13 @@ The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/).
 ### Added
 
 - When using the Unity Localization package Yarn Spinner can now sort the localisation tables based on a lines position in the file.
-    - This resolves an issue where lines added into the middle of a Yarn file however this does require sorting your localisation table every time you edit your Yarn files
-    - Defaults to off, can be changed in Yarn Spinners settings in `Edit -> Project Settings -> Yarn Spinner`
-    - Will log any values found in the localisation table that didn't come from your Yarn files and sort them to the top of the table
+  - This resolves an issue where lines added into the middle of a Yarn file however this does require sorting your localisation table every time you edit your Yarn files
+  - Defaults to off, can be changed in Yarn Spinners settings in `Edit -> Project Settings -> Yarn Spinner`
+  - Will log any values found in the localisation table that didn't come from your Yarn files and sort them to the top of the table
 - `YarnSpinnerAssemblyGeneratedYSLSPath` function to the `YarnSpinnerProjectSettings` so that each assembly can have a generated and consistent path.
+- Generated YSLS file now includes subtype information for instance commands
+  - This means a command like `<<move gary left>>` now knows that the `"gary"` is the name of a game object and the specific game object subclass
+  - Only works at a single level of monobehaviour depth, subclasses of a monobehaviour subclass will not be recognised
 
 ### Changed
 

Editor/Analysis/Action.cs

@@ -275,7 +275,20 @@ public string ToJSON()
                     paramObject["DefaultValue"] = p.DefaultValueString;
                 }
                 paramObject["IsParamsArray"] = p.IsParamsArray;
-                paramObject["Type"] = p.YarnTypeString;
+
+                // there are two special cases for parameters
+                // if it is a subclass of UnityEngine.Component or MonoBehaviour we additionally add the subtype
+                // this is used by the editor later on to let the writer know WHERE the command will be going
+                // otherwise we just add the Yarn type of the parameter
+                if (p.Type.BaseType?.Name == "MonoBehaviour" || p.Type.BaseType?.Name == "Component")
+                {
+                    paramObject["Type"] = "instance";
+                    paramObject["SubType"] = p.Type.Name;
+                }
+                else
+                {
+                    paramObject["Type"] = p.YarnTypeString;
+                }
 
                 return paramObject;
             }).ToArray());

Editor/Analysis/Analyser.cs

@@ -574,7 +574,7 @@ private static IEnumerable<Action> GetRuntimeDefinedActions(CompilationUnitSynta
                     MethodDeclarationSyntax = declaringSyntax,
                     Declaration = declaringSyntax,
                     Description = summary,
-                    Parameters = new List<Parameter>(GetParameters(targetSymbol, documentationXML)),
+                    Parameters = GetParams(targetSymbol, documentationXML, logger),
                     SourceFileName = root.SyntaxTree.FilePath,
                     DeclarationType = DeclarationType.DirectRegistration,
                 };
@@ -755,7 +755,7 @@ private static IEnumerable<Action> GetAttributeActions(CompilationUnitSyntax roo
                     MethodDeclarationSyntax = methodInfo.MethodDeclaration,
                     IsStatic = methodSymbol.IsStatic,
                     Declaration = methodInfo.MethodDeclaration,
-                    Parameters = new List<Parameter>(GetParameters(methodSymbol, documentationXML)),
+                    Parameters = GetParams(methodSymbol, documentationXML, logger),
                     AsyncType = GetAsyncType(methodSymbol),
                     SemanticModel = model,
                     Description = summary,
@@ -800,16 +800,46 @@ private static AsyncType GetAsyncType(IMethodSymbol symbol)
             {
                 case "global::Yarn.Unity.YarnTask":
                 case "global::System.Threading.Tasks.Task":
-                case "global::Cysharp.Threading.Tasks.UniTask": // double check this one
+                case "global::Cysharp.Threading.Tasks.UniTask":
                 case "global::UnityEngine.Awaitable":
                     return AsyncType.AsyncTask;
                 default:
                     return default;
             };
         }
 
-        private static IEnumerable<Parameter> GetParameters(IMethodSymbol symbol, XElement? documentationXML)
+        private static List<Parameter> GetParams(IMethodSymbol symbol, XElement? documentationXML, ILogger? logger)
         {
+            List<Parameter> parameters = new List<Parameter>();
+
+            // if this is an instance command registered via the yarn attribute we need to do an extra step
+            // we will need to create and add in a new parameter to the front of the parameters list
+            // to represent the game object that we will do a lookup for
+            var isAttributeRegistered = symbol.GetAttributes().Where(a => a.AttributeClass?.Name == "YarnCommandAttribute").Count() > 0;
+            if (isAttributeRegistered && !symbol.IsStatic)
+            {
+                logger?.WriteLine("Command has been registered via the attribute, will be adding a target parameter.");
+                var p = new Parameter
+                {
+                    Name = "target",
+                    IsOptional = false,
+                    Type = symbol.ContainingType,
+                    Description = "The name of the Game Object the runner will search for to run this command upon. This will be done through a normal GameObject.Find Unity call.",
+                    IsParamsArray = false,
+                };
+                parameters.Insert(0, p);
+            }
+
+            if (symbol.Parameters.Count() > 0)
+            {    
+                logger?.WriteLine($"Processing {symbol.Name} parameters");
+            }
+            else
+            {
+                logger?.WriteLine($"{symbol.Name} has no parameters");
+                return parameters;
+            }
+
             var parameterDocumentation = new Dictionary<string, string>();
 
             if (documentationXML != null)
@@ -833,8 +863,10 @@ private static IEnumerable<Parameter> GetParameters(IMethodSymbol symbol, XEleme
 
             foreach (var param in symbol.Parameters)
             {
+                logger?.WriteLine($"\t{param.Name} is a {param.Type.ToDisplayString()}");
+
                 parameterDocumentation.TryGetValue(param.Name, out var paramDoc);
-                yield return new Parameter
+                var p = new Parameter
                 {
                     Name = param.Name,
                     IsOptional = param.IsOptional,
@@ -843,7 +875,10 @@ private static IEnumerable<Parameter> GetParameters(IMethodSymbol symbol, XEleme
                     IsParamsArray = param.IsParams,
                     DefaultValueString = param.HasExplicitDefaultValue ? param.ExplicitDefaultValue?.ToString() : null,
                 };
+                parameters.Add(p);
             }
+
+            return parameters;
         }
 
         internal static bool IsAttributeYarnCommand(AttributeData attribute)