com.mavrodiev.playground 0.0.0-stage → 1.0.0

package/CHANGELOG.md

@@ -0,0 +1,4 @@
+# Changelog
+
+## 1.0.0 — 2026-11-03
+First version: the Tutorial Test sample (one station with its in-editor tutorial) and the tutorial editor tools. Needs Unity 6.5 or newer (the Tutorial Framework 6.0).

package/CHANGELOG.md.meta

@@ -0,0 +1,7 @@
+fileFormatVersion: 2
+guid: cfb9ee7d6ab91ef44876cdcdc5ad3250
+TextScriptImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

package/Editor/Tutorials/ColourRangeCheck.cs

@@ -0,0 +1,47 @@
+using System.Collections.Generic;
+using UnityEngine;
+
+namespace Mavrodiev.Tutorials.Editor
+{
+    /// <summary>
+    /// Done when a colour property of every listed material has all three channels between Min and Max,
+    /// in sRGB values from 0 to 255 (as the colour picker shows them).
+    /// </summary>
+    public class ColourRangeCheck : TutorialCheck
+    {
+        public Material[] Materials = new Material[0];
+        [Tooltip("What to call each material in the status line (\"sphere 2\"); the material's name when empty.")]
+        public string[] Labels = new string[0];
+        public string Property = "_BaseColor";
+        public int Min = 32;
+        public int Max = 243;
+
+        bool InRange(float channel)
+        {
+            int value = Mathf.RoundToInt(channel * 255f);
+            return value >= Min && value <= Max;
+        }
+
+        public override bool Evaluate(out string status)
+        {
+            var outside = new List<string>();
+            for (int i = 0; i < Materials.Length; i++)
+            {
+                Material material = Materials[i];
+                string label = i < Labels.Length && !string.IsNullOrEmpty(Labels[i]) ? Labels[i] : material != null ? material.name : "(missing material)";
+                if (material == null || !material.HasProperty(Property))
+                {
+                    outside.Add(label);
+                    continue;
+                }
+                Color c = material.GetColor(Property);
+                if (!InRange(c.r) || !InRange(c.g) || !InRange(c.b))
+                    outside.Add(label);
+            }
+            status = outside.Count == 0
+                ? $"All {Materials.Length} are between {Min} and {Max}."
+                : $"Still outside {Min} to {Max}: {string.Join(", ", outside)}.";
+            return outside.Count == 0;
+        }
+    }
+}

package/Editor/Tutorials/ColourRangeCheck.cs.meta

@@ -0,0 +1,2 @@
+fileFormatVersion: 2
+guid: 9db79303d16a16446960954df3b4ff9c

package/Editor/Tutorials/Mavrodiev.Tutorials.Editor.asmdef

@@ -0,0 +1,16 @@
+{
+    "name": "Mavrodiev.Tutorials.Editor",
+    "rootNamespace": "Mavrodiev.Tutorials.Editor",
+    "references": [ "Unity.Tutorials.Editor" ],
+    "includePlatforms": [ "Editor" ],
+    "excludePlatforms": [],
+    "allowUnsafeCode": false,
+    "overrideReferences": false,
+    "precompiledReferences": [],
+    "autoReferenced": true,
+    "defineConstraints": [],
+    "versionDefines": [
+        { "name": "com.unity.learn.iet-framework.authoring", "expression": "1.0.0", "define": "MAVRODIEV_TUTORIAL_AUTHORING" }
+    ],
+    "noEngineReferences": false
+}

package/Editor/Tutorials/Mavrodiev.Tutorials.Editor.asmdef.meta

@@ -0,0 +1,7 @@
+fileFormatVersion: 2
+guid: a317af76b3780ca4b9dc79f196d248aa
+AssemblyDefinitionImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

package/Editor/Tutorials/PredictionParagraph.cs

@@ -0,0 +1,108 @@
+using System;
+using System.IO;
+using Unity.Tutorials.Editor;
+using Unity.Tutorials.Editor.Paragraphs;
+using UnityEditor;
+using UnityEngine;
+using UnityEngine.UIElements;
+
+namespace Mavrodiev.Tutorials.Editor
+{
+    /// <summary>
+    /// A tutorial paragraph with a text box: the student writes a prediction, and Save writes it to
+    /// Assets/Predictions/<File>.md, one "## <Key>" section per prediction. With ShowOnly it shows
+    /// the saved answer instead (for the page that gives the answer).
+    /// </summary>
+    public class PredictionParagraph : ParagraphBase
+    {
+        public const string Folder = "Assets/Predictions";
+
+        [Tooltip("The file under Assets/Predictions/, without .md (one file per tutorial).")]
+        public string File;
+        [Tooltip("The section in that file (one per prediction).")]
+        public string Key;
+        [Tooltip("The question, shown above the text box and written above the answer in the file.")]
+        public string Question;
+        [Tooltip("Next stays disabled until an answer is saved.")]
+        public bool RequireAnswer;
+        [Tooltip("Show the saved answer, read-only, instead of the text box.")]
+        public bool ShowOnly;
+        [Tooltip("The page this paragraph sits on (set by the generator), redrawn after Save when RequireAnswer is on.")]
+        public TutorialPage Page;
+
+        string Path => $"{Folder}/{File}.md";
+
+        public override bool IsCompleted() => ShowOnly || !RequireAnswer || !string.IsNullOrWhiteSpace(Load());
+
+        public override VisualElement GetDisplayRoot()
+        {
+            var root = new VisualElement();
+            root.style.marginTop = 6;
+            root.style.marginBottom = 6;
+
+            if (ShowOnly)
+            {
+                string saved = Load();
+                root.Add(Wrapped("<b>Your prediction:</b> " + (string.IsNullOrWhiteSpace(saved) ? "<i>(none saved)</i>" : saved)));
+                return root;
+            }
+
+            if (!string.IsNullOrEmpty(Question))
+                root.Add(Wrapped($"<b>Predict:</b> {Question}"));
+            var field = new TextField { multiline = true, value = Load() };
+            field.style.minHeight = 60;
+            field.style.whiteSpace = WhiteSpace.Normal;
+            var status = Wrapped(string.IsNullOrWhiteSpace(field.value) ? "" : $"Saved in {Path}");
+            var save = new Button(() =>
+            {
+                Save(field.value);
+                status.text = $"Saved in {Path}";
+                if (RequireAnswer && Page != null)
+                    Page.RaiseNonMaskingSettingsChanged(); // makes the window redraw, so Next unlocks
+            }) { text = "Save prediction" };
+
+            root.Add(field);
+            root.Add(save);
+            root.Add(status);
+            return root;
+        }
+
+        static Label Wrapped(string text)
+        {
+            var label = new Label(text);
+            label.style.whiteSpace = WhiteSpace.Normal;
+            return label;
+        }
+
+        string Load()
+        {
+            if (!System.IO.File.Exists(Path))
+                return "";
+            string[] lines = System.IO.File.ReadAllLines(Path);
+            int start = Array.IndexOf(lines, "## " + Key);
+            if (start < 0)
+                return "";
+            var answer = new System.Text.StringBuilder();
+            for (int i = start + 2; i < lines.Length && !lines[i].StartsWith("## "); i++)
+                answer.AppendLine(lines[i]);
+            return answer.ToString().Trim();
+        }
+
+        void Save(string answer)
+        {
+            Directory.CreateDirectory(Folder);
+            string section = $"## {Key}\n*{Question}*\n\n{answer.Trim()}\n\n";
+            string text = System.IO.File.Exists(Path) ? System.IO.File.ReadAllText(Path).Replace("\r\n", "\n") : $"# Predictions: {File}\n\n";
+            int start = text.IndexOf($"## {Key}\n", StringComparison.Ordinal);
+            if (start < 0)
+                text += section;
+            else
+            {
+                int end = text.IndexOf("\n## ", start + 1, StringComparison.Ordinal);
+                text = text.Substring(0, start) + section + (end < 0 ? "" : text.Substring(end + 1));
+            }
+            System.IO.File.WriteAllText(Path, text);
+            AssetDatabase.ImportAsset(Path);
+        }
+    }
+}

package/Editor/Tutorials/PredictionParagraph.cs.meta

@@ -0,0 +1,2 @@
+fileFormatVersion: 2
+guid: a06b22c6ff07fca49832cf1ff940470b

package/Editor/Tutorials/TryParagraph.cs

@@ -0,0 +1,79 @@
+using Unity.Tutorials.Editor;
+using Unity.Tutorials.Editor.Paragraphs;
+using UnityEngine;
+using UnityEngine.UIElements;
+
+namespace Mavrodiev.Tutorials.Editor
+{
+    /// <summary>
+    /// A Try step: a title, the steps, and a status line that a TutorialCheck updates twice a second.
+    /// By default it never blocks Next (the student may move on before the step is done);
+    /// with Blocking on, Next stays disabled until the check passes.
+    /// </summary>
+    public class TryParagraph : ParagraphBase
+    {
+        public string Title = "Try";
+        [TextArea(3, 15)] public string Text;
+        [Tooltip("Optional. Without a check, the step shows no status line.")]
+        public TutorialCheck Check;
+        [Tooltip("Next stays disabled until the check passes.")]
+        public bool Blocking;
+        [Tooltip("The page this paragraph sits on (set by the generator), redrawn when a blocking check changes.")]
+        public TutorialPage Page;
+
+        static readonly Color Done = new Color(0.35f, 0.8f, 0.4f);
+        static readonly Color NotYet = new Color(0.65f, 0.65f, 0.65f);
+
+        bool m_LastDone;
+
+        public override bool IsCompleted()
+        {
+            if (!Blocking || Check == null)
+                return true;
+            return Check.Evaluate(out _);
+        }
+
+        public override VisualElement GetDisplayRoot()
+        {
+            var root = new VisualElement();
+            root.style.marginTop = 6;
+            root.style.marginBottom = 6;
+            root.style.paddingLeft = 8;
+            root.style.borderLeftWidth = 3;
+            root.style.borderLeftColor = NotYet;
+
+            root.Add(Wrapped($"<b>{Title}</b>"));
+            root.Add(Wrapped(Text));
+            if (Check == null)
+                return root;
+
+            var status = Wrapped("");
+            status.style.marginTop = 4;
+            root.Add(status);
+
+            void Update()
+            {
+                bool done = Check.Evaluate(out string text);
+                status.text = (done ? "✔ " : "○ ") + text;
+                status.style.color = done ? Done : NotYet;
+                root.style.borderLeftColor = done ? Done : NotYet;
+                bool changed = done != m_LastDone;
+                m_LastDone = done;
+                if (Blocking && changed && Page != null)
+                    Page.RaiseNonMaskingSettingsChanged(); // makes the window redraw, so Next follows the check
+            }
+
+            m_LastDone = Check.Evaluate(out _);
+            Update();
+            root.schedule.Execute(Update).Every(500);
+            return root;
+        }
+
+        static Label Wrapped(string text)
+        {
+            var label = new Label(text);
+            label.style.whiteSpace = WhiteSpace.Normal;
+            return label;
+        }
+    }
+}

package/Editor/Tutorials/TryParagraph.cs.meta

@@ -0,0 +1,2 @@
+fileFormatVersion: 2
+guid: a8abd1cbb83a66041a53effcda8e4c96

package/Editor/Tutorials/TutorialActions.cs

@@ -0,0 +1,36 @@
+using UnityEditor;
+using UnityEngine;
+
+namespace Mavrodiev.Tutorials.Editor
+{
+    /// <summary>
+    /// Methods a tutorial page calls when it opens (its Showing event). The generator writes one
+    /// asset of this type next to each sample's tutorials, because an event needs an object to call.
+    /// </summary>
+    public class TutorialActions : ScriptableObject
+    {
+        /// <summary>
+        /// Turns on the camera with this name and turns off every other camera, so the Game view shows
+        /// the station; selects it and aligns the Scene view to it.
+        /// </summary>
+        public void ShowCamera(string cameraName)
+        {
+            Camera target = null;
+            foreach (Camera camera in Object.FindObjectsByType<Camera>(FindObjectsInactive.Include))
+            {
+                bool on = camera.name == cameraName;
+                camera.enabled = on;
+                if (on)
+                    target = camera;
+            }
+            if (target == null)
+            {
+                Debug.LogWarning($"Tutorial: no camera named '{cameraName}' in the open scene.");
+                return;
+            }
+            Selection.activeGameObject = target.gameObject;
+            if (SceneView.lastActiveSceneView != null)
+                SceneView.lastActiveSceneView.AlignViewToObject(target.transform);
+        }
+    }
+}

package/Editor/Tutorials/TutorialActions.cs.meta

@@ -0,0 +1,2 @@
+fileFormatVersion: 2
+guid: 987706d7848530d4cb673c0d2e2a08bd

package/Editor/Tutorials/TutorialCheck.cs

@@ -0,0 +1,14 @@
+using UnityEngine;
+
+namespace Mavrodiev.Tutorials.Editor
+{
+    /// <summary>
+    /// A check of the scene or its assets, shown live under a Try step (see TryParagraph).
+    /// Subclass it once per kind of check; the generator stores each one inside the tutorial asset.
+    /// </summary>
+    public abstract class TutorialCheck : ScriptableObject
+    {
+        /// <summary>True when the step is done. Status is one short line for the student, done or not.</summary>
+        public abstract bool Evaluate(out string status);
+    }
+}

package/Editor/Tutorials/TutorialCheck.cs.meta

@@ -0,0 +1,2 @@
+fileFormatVersion: 2
+guid: e6dab61ab1252cc4c93c0d81aa029969

package/Editor/Tutorials/TutorialDefinition.cs

@@ -0,0 +1,136 @@
+using System.Collections.Generic;
+using Unity.Tutorials.Editor;
+using Unity.Tutorials.Editor.Paragraphs;
+using UnityEditor;
+using UnityEngine;
+
+namespace Mavrodiev.Tutorials.Editor
+{
+    /// <summary>
+    /// One tutorial, written as C# data. Subclass it in a sample's Editor/ folder; TutorialGenerator
+    /// finds every subclass and writes its assets into the sample's Tutorial/ folder.
+    /// </summary>
+    public abstract class TutorialDefinition
+    {
+        /// <summary>Divider between sections of one page.</summary>
+        public const string LINE = "────────────────────────────────────";
+
+        /// <summary>File name: Tutorial/&lt;Id&gt;.asset, and the predictions file Assets/Predictions/&lt;Id&gt;.md.</summary>
+        public abstract string Id { get; }
+        /// <summary>The title in the tutorial window and on the contents card.</summary>
+        public abstract string Title { get; }
+        /// <summary>The text on the contents card.</summary>
+        public virtual string Description => "";
+        /// <summary>The scene the tutorial opens, as a path inside the sample folder ("Materials-Training.unity"); null: it opens none and stays in the active scene.</summary>
+        public virtual string Scene => null;
+        /// <summary>The card's place on the sample's contents page.</summary>
+        public virtual int Order => 0;
+        /// <summary>The sample's contents page; when a sample has several tutorials, the first by Order sets it.</summary>
+        public virtual string ContentsTitle => Title;
+        public virtual string ContentsSubtitle => "";
+
+        /// <summary>The pages, in order. Build them with the helpers below.</summary>
+        public abstract IEnumerable<Page> Pages();
+
+        /// <summary>The sample folder ("Assets/_Samples/playground/Materials"), set by the generator before Pages().</summary>
+        public string Folder { get; internal set; }
+
+        /// <summary>Loads an asset by its path inside the sample folder.</summary>
+        protected T Load<T>(string pathInSample) where T : Object => AssetDatabase.LoadAssetAtPath<T>($"{Folder}/{pathInSample}");
+
+        // ── building blocks ──────────────────────────────────────────────────
+
+        public class Page
+        {
+            public string Title;
+            public string Camera;   // camera switched to when the page opens, or null
+            public Block[] Blocks;
+
+            /// <summary>Switches to this camera (Game view, selection and Scene view) when the page opens.</summary>
+            public Page ShowCamera(string cameraName)
+            {
+                Camera = cameraName;
+                return this;
+            }
+        }
+
+        /// <summary>Makes one paragraph of a page. The generator calls it with the page being built.</summary>
+        public delegate ParagraphBase Block(Build build);
+
+        /// <summary>What a Block gets: the tutorial and page being written.</summary>
+        public class Build
+        {
+            public TutorialDefinition Definition;
+            public Tutorial Tutorial;
+            public TutorialPage Page;
+
+            /// <summary>Stores an object (a check, a criterion) inside the tutorial asset.</summary>
+            public T Store<T>(T obj) where T : Object
+            {
+                if (obj != null && !AssetDatabase.Contains(obj))
+                {
+                    obj.name = obj.GetType().Name;
+                    obj.hideFlags |= HideFlags.HideInHierarchy;
+                    AssetDatabase.AddObjectToAsset(obj, Tutorial);
+                }
+                return obj;
+            }
+        }
+
+        protected static Page NewPage(string title, params Block[] blocks) => new Page { Title = title, Blocks = blocks };
+
+        /// <summary>A block of text; rich text (&lt;b&gt;, &lt;i&gt;), \n and • work.</summary>
+        protected static Block Text(string text) => b =>
+        {
+            var paragraph = ScriptableObject.CreateInstance<NarrativeParagraph>();
+            paragraph.Text = text;
+            return paragraph;
+        };
+
+        /// <summary>The question and a text box; Save writes the answer to Assets/Predictions/&lt;Id&gt;.md under "## key".</summary>
+        protected static Block Predict(string key, string question, bool requireAnswer = false) => b =>
+        {
+            var paragraph = ScriptableObject.CreateInstance<PredictionParagraph>();
+            paragraph.File = b.Definition.Id;
+            paragraph.Key = key;
+            paragraph.Question = question;
+            paragraph.RequireAnswer = requireAnswer;
+            paragraph.Page = b.Page;
+            return paragraph;
+        };
+
+        /// <summary>Shows what the student saved for this key ("Your prediction: …").</summary>
+        protected static Block YourPrediction(string key) => b =>
+        {
+            var paragraph = ScriptableObject.CreateInstance<PredictionParagraph>();
+            paragraph.File = b.Definition.Id;
+            paragraph.Key = key;
+            paragraph.ShowOnly = true;
+            return paragraph;
+        };
+
+        /// <summary>A Try step: title, steps, and an optional live check. Never blocks Next unless blocking is true.</summary>
+        protected static Block Try(string title, string steps, TutorialCheck check = null, bool blocking = false) => b =>
+        {
+            var paragraph = ScriptableObject.CreateInstance<TryParagraph>();
+            paragraph.Title = title;
+            paragraph.Text = steps;
+            paragraph.Check = b.Store(check);
+            paragraph.Blocking = blocking;
+            paragraph.Page = b.Page;
+            return paragraph;
+        };
+
+        /// <summary>
+        /// The four pages of one station (Playground-Design § Presentation 2): the model with the camera switch,
+        /// Predict, Try, and the answer next to the student's own prediction.
+        /// </summary>
+        protected static IEnumerable<Page> Station(string key, string title, string camera, string model, string question, Block tryStep, string answer)
+        {
+            yield return NewPage($"{key} · {title}", Text($"<b>The model:</b> {model}")).ShowCamera(camera);
+            yield return NewPage($"{key} · Predict", Predict(key, question));
+            yield return NewPage($"{key} · Try", tryStep);
+            yield return NewPage($"{key} · Answer", YourPrediction(key), Text($"<b>Answer:</b> {answer}"));
+        }
+    }
+}

package/Editor/Tutorials/TutorialDefinition.cs.meta

@@ -0,0 +1,2 @@
+fileFormatVersion: 2
+guid: 8c276b766bf2f7e48aab866f2a2e5488

package/Editor/Tutorials/TutorialGenerator.cs

@@ -0,0 +1,176 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using Unity.Tutorials.Editor;
+using Unity.Tutorials.Editor.Paragraphs;
+using UnityEditor;
+using UnityEditor.Events;
+using UnityEngine;
+using UnityEngine.Events;
+using Object = UnityEngine.Object;
+
+namespace Mavrodiev.Tutorials.Editor
+{
+    /// <summary>
+    /// Writes the tutorial assets of every TutorialDefinition in the project, into its sample's Tutorial/ folder:
+    /// &lt;Id&gt;.asset (the tutorial, with its pages inside), Contents.asset (the sample's contents page) and
+    /// Tutorial-Actions.asset (what the pages call). Never edit these by hand: change the definition and regenerate.
+    /// The menu shows only where the authoring package is installed (the Workshop), not in students' projects.
+    /// </summary>
+    public static class TutorialGenerator
+    {
+        public const string OutputFolder = "Tutorial";
+
+#if MAVRODIEV_TUTORIAL_AUTHORING
+        [MenuItem("Tutorials/Authoring/Generate Mavrodiev Tutorials")]
+#endif
+        static void GenerateFromMenu() => Debug.Log(GenerateAll());
+
+        /// <summary>Regenerates every tutorial; returns one line per tutorial written.</summary>
+        public static string GenerateAll()
+        {
+            var report = new System.Text.StringBuilder();
+            var byFolder = new Dictionary<string, List<TutorialDefinition>>();
+            foreach (Type type in TypeCache.GetTypesDerivedFrom<TutorialDefinition>().Where(t => !t.IsAbstract))
+            {
+                string folder = SampleFolderOf(type);
+                if (folder == null)
+                {
+                    report.AppendLine($"Skipped {type.Name}: its script must be in a sample's Editor/ folder, in a file named {type.Name}.cs.");
+                    continue;
+                }
+                var definition = (TutorialDefinition)Activator.CreateInstance(type);
+                definition.Folder = folder;
+                if (!byFolder.TryGetValue(folder, out var list))
+                    byFolder[folder] = list = new List<TutorialDefinition>();
+                list.Add(definition);
+            }
+
+            foreach (var pair in byFolder)
+            {
+                string output = $"{pair.Key}/{OutputFolder}";
+                if (!AssetDatabase.IsValidFolder(output))
+                    AssetDatabase.CreateFolder(pair.Key, OutputFolder);
+                var actions = LoadOrCreate<TutorialActions>($"{output}/Tutorial-Actions.asset");
+                var ordered = pair.Value.OrderBy(d => d.Order).ToList();
+                var tutorials = ordered.Select(d => Write(d, output, actions, report)).ToList();
+                WriteContents(ordered, tutorials, output);
+            }
+            AssetDatabase.SaveAssets();
+            return report.Length > 0 ? report.ToString() : "No tutorial definitions found.";
+        }
+
+        static Tutorial Write(TutorialDefinition definition, string output, TutorialActions actions, System.Text.StringBuilder report)
+        {
+            var tutorial = LoadOrCreate<Tutorial>($"{output}/{definition.Id}.asset");
+            ClearSubAssets(tutorial);
+
+            tutorial.TutorialTitle = definition.Title;
+            if (string.IsNullOrEmpty(definition.Scene))
+            {
+                tutorial.SceneManagementBehavior = Tutorial.SceneManagementBehaviorType.UseActiveScene;
+                tutorial.Scenes = new SceneAsset[0];
+            }
+            else
+            {
+                var scene = AssetDatabase.LoadAssetAtPath<SceneAsset>($"{definition.Folder}/{definition.Scene}");
+                if (scene == null)
+                    report.AppendLine($"  {definition.Id}: scene '{definition.Scene}' not found in {definition.Folder}.");
+                tutorial.SceneManagementBehavior = Tutorial.SceneManagementBehaviorType.LoadScenes;
+                tutorial.Scenes = new[] { scene };
+            }
+            // Keep true: with false, Tutorial Framework 6.0.7 throws an ArgumentNullException when the tutorial ends.
+            tutorial.ReturnToPreviousScenes = true;
+            tutorial.ProgressTrackingEnabled = true;
+            if (string.IsNullOrEmpty(tutorial.LessonId))
+                tutorial.LessonId = Guid.NewGuid().ToString("N");
+
+            var pages = new List<TutorialPage>();
+            foreach (TutorialDefinition.Page def in definition.Pages())
+            {
+                int index = pages.Count;
+                var page = ScriptableObject.CreateInstance<TutorialPage>();
+                page.Title = def.Title;
+                page.name = $"{index}_{new string(def.Title.Where(c => char.IsLetterOrDigit(c) || c == ' ' || c == '-').ToArray())}";
+                AssetDatabase.AddObjectToAsset(page, tutorial);
+                var so = new SerializedObject(page);
+                so.FindProperty("<IndexInTutorial>k__BackingField").intValue = index;
+                so.ApplyModifiedPropertiesWithoutUndo();
+
+                var build = new TutorialDefinition.Build { Definition = definition, Tutorial = tutorial, Page = page };
+                foreach (TutorialDefinition.Block block in def.Blocks)
+                {
+                    ParagraphBase paragraph = block(build);
+                    paragraph.name = paragraph.GetType().Name;
+                    paragraph.hideFlags |= HideFlags.HideInHierarchy;
+                    AssetDatabase.AddObjectToAsset(paragraph, tutorial);
+                    page.Paragraphs.Add(paragraph);
+                }
+                if (!string.IsNullOrEmpty(def.Camera))
+                {
+                    UnityEventTools.AddStringPersistentListener(page.Showing, actions.ShowCamera, def.Camera);
+                    // Added listeners default to Runtime Only, which never fires in the Editor.
+                    page.Showing.SetPersistentListenerState(page.Showing.GetPersistentEventCount() - 1, UnityEventCallState.EditorAndRuntime);
+                }
+                EditorUtility.SetDirty(page);
+                pages.Add(page);
+            }
+            tutorial.PagesCollection.SetItems(pages);
+            EditorUtility.SetDirty(tutorial);
+            report.AppendLine($"{definition.Id}: {pages.Count} pages → {output}/{definition.Id}.asset");
+            return tutorial;
+        }
+
+        static void WriteContents(List<TutorialDefinition> definitions, List<Tutorial> tutorials, string output)
+        {
+            var contents = LoadOrCreate<TutorialContainer>($"{output}/Contents.asset");
+            contents.Title = definitions[0].ContentsTitle;
+            contents.Subtitle = definitions[0].ContentsSubtitle;
+            contents.Sections = definitions.Select((d, i) => new TutorialContainer.Section
+            {
+                Heading = d.Title,
+                Text = d.Description,
+                Type = TutorialContainer.SectionType.Tutorial,
+                Tutorial = tutorials[i],
+            }).ToArray();
+            EditorUtility.SetDirty(contents);
+        }
+
+        // The sample folder is the parent of the Editor/ folder that holds the definition's script.
+        static string SampleFolderOf(Type type)
+        {
+            foreach (string guid in AssetDatabase.FindAssets($"{type.Name} t:MonoScript", new[] { "Assets" }))
+            {
+                string path = AssetDatabase.GUIDToAssetPath(guid);
+                var script = AssetDatabase.LoadAssetAtPath<MonoScript>(path);
+                if (script == null || script.GetClass() != type)
+                    continue;
+                string folder = path.Substring(0, path.LastIndexOf('/'));
+                return folder.EndsWith("/Editor") ? folder.Substring(0, folder.Length - "/Editor".Length) : null;
+            }
+            return null;
+        }
+
+        // Reuses the asset if it exists, so its ID (and every reference to it) survives regeneration.
+        static T LoadOrCreate<T>(string path) where T : ScriptableObject
+        {
+            var asset = AssetDatabase.LoadAssetAtPath<T>(path);
+            if (asset != null)
+                return asset;
+            asset = ScriptableObject.CreateInstance<T>();
+            AssetDatabase.CreateAsset(asset, path);
+            return asset;
+        }
+
+        static void ClearSubAssets(Object main)
+        {
+            foreach (Object sub in AssetDatabase.LoadAllAssetsAtPath(AssetDatabase.GetAssetPath(main)))
+            {
+                if (sub == null || sub == main)
+                    continue;
+                AssetDatabase.RemoveObjectFromAsset(sub);
+                Object.DestroyImmediate(sub, true);
+            }
+        }
+    }
+}

package/Editor/Tutorials/TutorialGenerator.cs.meta

@@ -0,0 +1,2 @@
+fileFormatVersion: 2
+guid: f913802eb03fe214bbdc2ee4cb14760b