示例#1
0
        /// <summary>
        /// Updates the ink library. Executed whenever an ink file is changed by InkToJSONPostProcessor
        /// Can be called manually, but incurs a performance cost.
        /// </summary>
        public static void Rebuild()
        {
            // Remove any old file connections
            Clean();

            // Add any new file connections (if any are found it replaces the old library entirely)
            string[]       inkFilePaths      = GetAllInkFilePaths();
            bool           inkLibraryChanged = false;
            List <InkFile> newInkLibrary     = new List <InkFile>(inkFilePaths.Length);

            for (int i = 0; i < inkFilePaths.Length; i++)
            {
                InkFile inkFile = GetInkFileWithAbsolutePath(inkFilePaths [i]);
                // If the ink library doesn't have a representation for this file, then make one
                if (inkFile == null)
                {
                    inkLibraryChanged = true;
                    string       localAssetPath = InkEditorUtils.AbsoluteToUnityRelativePath(inkFilePaths [i]);
                    DefaultAsset inkFileAsset   = AssetDatabase.LoadAssetAtPath <DefaultAsset>(localAssetPath);
                    // If the ink file can't be found, it might not yet have been imported. We try to manually import it to fix this.
                    if (inkFileAsset == null)
                    {
                        AssetDatabase.ImportAsset(localAssetPath);
                        inkFileAsset = AssetDatabase.LoadAssetAtPath <DefaultAsset>(localAssetPath);
                        if (inkFileAsset == null)
                        {
                            Debug.LogWarning("Ink File Asset not found at " + localAssetPath + ". This can occur if the .meta file has not yet been created. This issue should resolve itself, but if unexpected errors occur, rebuild Ink Library using Assets > Recompile Ink");
                            continue;
                        }
                    }
                    inkFile = new InkFile(inkFileAsset);
                }
                newInkLibrary.Add(inkFile);
            }
            if (inkLibraryChanged)
            {
                Instance.inkLibrary = newInkLibrary;
            }
            CreateDictionary();

            // Validate the meta files
            var  metaFiles        = Instance.inkLibrary.Select(x => x.metaInfo);
            bool metaFilesChanged = !InkMetaLibrary.Instance.metaLibrary.SequenceEqual(metaFiles);

            if (metaFilesChanged)
            {
                InkMetaLibrary.Instance.metaLibrary = metaFiles.ToList();
            }

            InkMetaLibrary.RebuildInkFileConnections();

            foreach (InkFile inkFile in Instance.inkLibrary)
            {
                inkFile.FindCompiledJSONAsset();
            }
            Save();

            Debug.Log("Ink Library was rebuilt.");
        }
        private static void OnDeleteAssets(string[] deletedAssets)
        {
            bool deletedInk = false;

            foreach (var deletedAssetPath in deletedAssets)
            {
                if (InkEditorUtils.IsInkFile(deletedAssetPath))
                {
                    deletedInk = true;
                    break;
                }
            }
            if (!deletedInk)
            {
                return;
            }

//			bool alsoDeleteJSON = false;
//			alsoDeleteJSON = EditorUtility.DisplayDialog("Deleting .ink file", "Also delete the JSON file associated with the deleted .ink file?", "Yes", "No"));
            List <InkFile> masterFilesAffected = new List <InkFile>();

            for (int i = InkLibrary.instance.inkLibrary.Count - 1; i >= 0; i--)
            {
                if (InkLibrary.instance.inkLibrary [i].inkAsset == null)
                {
                    if (!InkLibrary.instance.inkLibrary[i].isMaster)
                    {
                        foreach (var masterInkFile in InkLibrary.instance.inkLibrary[i].masterInkFiles)
                        {
                            if (!masterFilesAffected.Contains(masterInkFile))
                            {
                                masterFilesAffected.Add(masterInkFile);
                            }
                        }
                    }
                    if (InkSettings.instance.handleJSONFilesAutomatically)
                    {
                        var assetPath = AssetDatabase.GetAssetPath(InkLibrary.instance.inkLibrary[i].jsonAsset);
                        if (assetPath != null && assetPath != string.Empty)
                        {
                            AssetDatabase.DeleteAsset(assetPath);
                        }
                    }
                    InkLibrary.RemoveAt(i);
                }
            }
            // After deleting files, we might have broken some include references, so we rebuild them. There's probably a faster way to do this, or we could probably just remove any null references, but this is a bit more robust.
            foreach (InkFile inkFile in InkLibrary.instance.inkLibrary)
            {
                inkFile.FindIncludedFiles();
            }
            foreach (InkFile masterFile in masterFilesAffected)
            {
                if (InkSettings.instance.compileAutomatically || masterFile.compileAutomatically)
                {
                    InkCompiler.CompileInk(masterFile);
                }
            }
        }
示例#3
0
        /// <summary>
        /// Updates the ink library. Executed whenever an ink file is changed by InkToJSONPostProcessor
        /// Can be called manually, but incurs a performance cost.
        /// </summary>
        public static void Rebuild()
        {
            // Disable the asset post processor in case any assetdatabase functions called as a result of this would cause further operations.
            InkPostProcessor.disabled = true;

            // Remove any old file connections
            Clean();

            // Reset the asset name
            Instance.name = "Ink Library " + versionCurrent.ToString();

            // Add any new file connections (if any are found it replaces the old library entirely)
            string[]       inkFilePaths      = GetAllInkFilePaths();
            bool           inkLibraryChanged = false;
            List <InkFile> newInkLibrary     = new List <InkFile>(inkFilePaths.Length);

            for (int i = 0; i < inkFilePaths.Length; i++)
            {
                InkFile inkFile = GetInkFileWithAbsolutePath(inkFilePaths [i]);
                // If the ink library doesn't have a representation for this file, then make one
                if (inkFile == null)
                {
                    inkLibraryChanged = true;
                    string       localAssetPath = InkEditorUtils.AbsoluteToUnityRelativePath(inkFilePaths [i]);
                    DefaultAsset inkFileAsset   = AssetDatabase.LoadAssetAtPath <DefaultAsset>(localAssetPath);
                    // If the ink file can't be found, it might not yet have been imported. We try to manually import it to fix this.
                    if (inkFileAsset == null)
                    {
                        AssetDatabase.ImportAsset(localAssetPath);
                        inkFileAsset = AssetDatabase.LoadAssetAtPath <DefaultAsset>(localAssetPath);
                        if (inkFileAsset == null)
                        {
                            Debug.LogWarning("Ink File Asset not found at " + localAssetPath + ". This can occur if the .meta file has not yet been created. This issue should resolve itself, but if unexpected errors occur, rebuild Ink Library using Assets > Recompile Ink");
                            continue;
                        }
                    }
                    inkFile = new InkFile(inkFileAsset);
                }
                newInkLibrary.Add(inkFile);
            }
            if (inkLibraryChanged)
            {
                Instance.inkLibrary = newInkLibrary;
                SortInkLibrary();
            }
            BuildLookupDictionary();

            RebuildInkFileConnections();

            foreach (InkFile inkFile in Instance.inkLibrary)
            {
                inkFile.FindCompiledJSONAsset();
            }
            SaveToFile();

            // Re-enable the ink asset post processor
            InkPostProcessor.disabled = false;
            Debug.Log("Ink Library was rebuilt.");
        }
示例#4
0
 private static string[] GetAllInkFilePaths()
 {
     string[] inkFilePaths = Directory.GetFiles(Application.dataPath, "*.ink", SearchOption.AllDirectories);
     for (int i = 0; i < inkFilePaths.Length; i++)
     {
         inkFilePaths [i] = InkEditorUtils.SanitizePathString(inkFilePaths [i]);
     }
     return(inkFilePaths);
 }
示例#5
0
 void Play(TextAsset storyJSONTextAsset)
 {
     if (!InkEditorUtils.CheckStoryIsValid(storyJSONTextAsset.text, out errors))
     {
         return;
     }
     this.storyJSONTextAsset = storyJSONTextAsset;
     storyJSON = this.storyJSONTextAsset.text;
     PlayInternal();
 }
        static void OnDrawProjectWindowItem(string guid, Rect rect)
        {
            string path = AssetDatabase.GUIDToAssetPath(guid);

            if (InkEditorUtils.IsInkFile(path))
            {
                DefaultAsset asset = AssetDatabase.LoadAssetAtPath <DefaultAsset>(path);
                DrawInkFile(InkLibrary.GetInkFileWithFile(asset), rect);
            }
        }
示例#7
0
 void Play(string storyJSON)
 {
     if (!InkEditorUtils.CheckStoryIsValid(storyJSON, out errors))
     {
         return;
     }
     this.storyJSONTextAsset = null;
     this.storyJSON          = storyJSON;
     PlayInternal();
 }
        public static void CompileInk(InkFile inkFile)
        {
            if (inkFile == null)
            {
                Debug.LogError("Tried to compile ink file " + inkFile.filePath + ", but input was null.");
                return;
            }
            if (!inkFile.isMaster)
            {
                Debug.LogWarning("Compiling InkFile which is an include. Any file created is likely to be invalid. Did you mean to call CompileInk on inkFile.master?");
            }
            if (InkLibrary.GetCompilationStackItem(inkFile) != null)
            {
                UnityEngine.Debug.LogWarning("Tried compiling ink file, but file is already compiling. " + inkFile.filePath);
                return;
            }

            string inklecatePath = InkEditorUtils.GetInklecateFilePath();

            if (inklecatePath == null)
            {
                UnityEngine.Debug.LogWarning("Inklecate (the ink compiler) not found in assets. This will prevent automatic building of JSON TextAsset files from ink story files.");
                return;
            }
            if (Application.platform == RuntimePlatform.OSXEditor)
            {
                SetInklecateFilePermissions(inklecatePath);
            }

            string inputPath    = InkEditorUtils.CombinePaths(inkFile.absoluteFolderPath, Path.GetFileName(inkFile.filePath));
            string outputPath   = InkEditorUtils.CombinePaths(inkFile.absoluteFolderPath, Path.GetFileNameWithoutExtension(Path.GetFileName(inkFile.filePath))) + ".json";
            string inkArguments = "-c -o " + "\"" + outputPath + "\" \"" + inputPath + "\"";

            CompilationStackItem pendingFile = new CompilationStackItem();

            pendingFile.inkFile              = InkLibrary.GetInkFileWithAbsolutePath(inputPath);
            pendingFile.inkAbsoluteFilePath  = inputPath;
            pendingFile.jsonAbsoluteFilePath = outputPath;
            pendingFile.state = CompilationStackItem.State.Compiling;
            InkLibrary.Instance.compilationStack.Add(pendingFile);

            Process process = new Process();

            process.StartInfo.WorkingDirectory       = inkFile.absoluteFolderPath;
            process.StartInfo.FileName               = inklecatePath;
            process.StartInfo.Arguments              = inkArguments;
            process.StartInfo.RedirectStandardError  = true;
            process.StartInfo.RedirectStandardOutput = true;
            process.StartInfo.UseShellExecute        = false;
            process.EnableRaisingEvents              = true;
            process.StartInfo.EnvironmentVariables["inkAbsoluteFilePath"] = inputPath;
            process.ErrorDataReceived += OnProcessError;
            process.Exited            += OnCompileProcessComplete;
            process.Start();
        }
示例#9
0
 void Play(string storyJSON)
 {
     if (!InkEditorUtils.CheckStoryIsValid(storyJSON, out errors))
     {
         return;
     }
     this.storyJSONTextAsset = null;
     this.storyJSON          = storyJSON;
     InitStory();
     TryContinue();
 }
示例#10
0
 void Play(TextAsset storyJSONTextAsset)
 {
     if (!InkEditorUtils.CheckStoryIsValid(storyJSONTextAsset.text, out errors))
     {
         return;
     }
     this.storyJSONTextAsset = storyJSONTextAsset;
     storyJSON = this.storyJSONTextAsset.text;
     InitStory();
     TryContinue();
 }
        /// <summary>
        /// Starts a System.Process that compiles a master ink file, creating a playable JSON file that can be parsed by the Ink.Story class
        /// </summary>
        /// <param name="inkFile">Ink file.</param>
        private static void CompileInkInternal(InkFile inkFile, bool immediate)
        {
            // If we've not yet locked C# compilation do so now
            if (!hasLockedUnityCompilation)
            {
                hasLockedUnityCompilation = true;
                EditorApplication.LockReloadAssemblies();
            }

            RemoveFromPendingCompilationStack(inkFile);

            if (inkFile == null)
            {
                Debug.LogError("Tried to compile ink file but input was null.");
                return;
            }
            if (!inkFile.metaInfo.isMaster)
            {
                Debug.LogWarning("Compiling InkFile which is an include. Any file created is likely to be invalid. Did you mean to call CompileInk on inkFile.master?");
            }
            if (InkLibrary.GetCompilationStackItem(inkFile) != null)
            {
                UnityEngine.Debug.LogWarning("Tried compiling ink file, but file is already compiling. " + inkFile.filePath);
                return;
            }

            string inputPath = InkEditorUtils.CombinePaths(inkFile.absoluteFolderPath, Path.GetFileName(inkFile.filePath));

            Debug.Assert(inkFile.absoluteFilePath == inputPath);

            CompilationStackItem pendingFile = new CompilationStackItem
            {
                inkFile              = InkLibrary.GetInkFileWithAbsolutePath(inputPath),
                inkAbsoluteFilePath  = inputPath,
                jsonAbsoluteFilePath = inkFile.jsonPath,
                state = CompilationStackItem.State.Compiling
            };

            InkLibrary.Instance.compilationStack.Add(pendingFile);
            //InkLibrary.Save();
            if (immediate)
            {
                CompileInkThreaded(pendingFile);
                Update();
            }
            else
            {
                if (EditorApplication.isCompiling)
                {
                    Debug.LogWarning("Was compiling scripts when ink compilation started! This seems to cause the thread to cancel and complete, but the work isn't done. It may cause a timeout.");
                }
                ThreadPool.QueueUserWorkItem(CompileInkThreaded, pendingFile);
            }
        }
示例#12
0
        public static void DrawLayoutInkLine(InkFile inkFile, int lineNumber, string label)
        {
            GUILayout.BeginHorizontal();
            GUILayout.Label(label);
            string openLabel = "Open" + (lineNumber == -1 ? "" : " (" + lineNumber + ")");

            if (GUILayout.Button(openLabel, GUILayout.Width(80)))
            {
                InkEditorUtils.OpenInEditor(inkFile.filePath, null, lineNumber);
            }
            GUILayout.EndHorizontal();
        }
示例#13
0
 void DrawVariables()
 {
     if (InkEditorUtils.StoryContainsVariables(story))
     {
         EditorGUILayout.BeginHorizontal(EditorStyles.toolbar);
         showingVariablesPanel = EditorGUILayout.Foldout(showingVariablesPanel, "Variables");
         EditorGUILayout.EndHorizontal();
         if (showingVariablesPanel)
         {
             DrawVariablesPanel();
         }
     }
 }
示例#14
0
        private static void ProcessError(Process process, string message)
        {
            message = message.Trim();
            if (InkEditorUtils.IsNullOrWhiteSpace(message) || message == "???")
            {
                return;
            }
            Debug.Log(message[0]);
            Debug.Log(char.IsWhiteSpace(message[0]));
            Debug.Log((int)(message[0]));
            CompilationStackItem compilingFile = InkLibrary.GetCompilationStackItem(process);

            compilingFile.errorOutput.Add(message);
        }
示例#15
0
        public override void OnInspectorGUI()
        {
            serializedObject.Update();

            if (InkCompiler.compiling)
            {
                Rect r = EditorGUILayout.BeginVertical();
                EditorGUI.ProgressBar(r, InkCompiler.GetEstimatedCompilationProgress(), "Compiling...");
                GUILayout.Space(EditorGUIUtility.singleLineHeight);
                EditorGUILayout.EndVertical();
                GUILayout.Space(EditorGUIUtility.standardVerticalSpacing);
            }
            else
            {
                var filesRequiringRecompile = InkLibrary.GetFilesRequiringRecompile();
                if (filesRequiringRecompile.Any())
                {
                    var files = string.Join("\n", filesRequiringRecompile.Select(x => x.filePath).ToArray());
                    EditorGUILayout.HelpBox("Some Ink files marked to compile automatically are not compiled! Check they don't have compile errors, or else try compiling now.\n" + files, MessageType.Warning);
                }
                else
                {
                    EditorGUILayout.HelpBox("All Ink files marked to compile automatically are compiled", MessageType.Info);
                }
            }
            EditorGUI.BeginDisabledGroup(InkCompiler.compiling);
            if (GUILayout.Button(new GUIContent("Rebuild Library", "Rebuilds the ink library. Do this if you're getting unusual errors")))
            {
                InkLibrary.Rebuild();
            }
            if (GUILayout.Button(new GUIContent("Recompile All", "Recompiles all files marked to compile automatically.")))
            {
                InkEditorUtils.RecompileAll();
            }
            EditorGUI.EndDisabledGroup();

            EditorGUI.BeginDisabledGroup(true);
            EditorGUILayout.PropertyField(serializedObject.FindProperty("inkLibrary"), true);
            EditorGUILayout.PropertyField(serializedObject.FindProperty("pendingCompilationStack"), true);
            EditorGUILayout.PropertyField(serializedObject.FindProperty("compilationStack"), true);
            EditorGUI.EndDisabledGroup();

            if (GUI.changed && target != null)
            {
                EditorUtility.SetDirty(target);
            }
            serializedObject.ApplyModifiedProperties();
        }
示例#16
0
        /// <summary>
        /// Updates the ink library. Executed whenever an ink file is changed by InkToJSONPostProcessor
        /// Can be called manually, but incurs a performance cost.
        /// </summary>
        public static void Rebuild()
        {
            Debug.Log("Rebuilding Ink Library...");

            string[] inkFilePaths = GetAllInkFilePaths();

            List <InkFile> newInkLibrary = new List <InkFile>(inkFilePaths.Length);

            for (int i = 0; i < inkFilePaths.Length; i++)
            {
                InkFile inkFile = GetInkFileWithAbsolutePath(inkFilePaths [i]);
                if (inkFile == null)
                {
                    string       localAssetPath = InkEditorUtils.AbsoluteToUnityRelativePath(inkFilePaths [i]);
                    DefaultAsset inkFileAsset   = AssetDatabase.LoadAssetAtPath <DefaultAsset>(localAssetPath);
                    // If the ink file can't be found, it might not yet have been imported. We try to manually import it to fix this.
                    if (inkFileAsset == null)
                    {
                        AssetDatabase.ImportAsset(localAssetPath);
                        inkFileAsset = AssetDatabase.LoadAssetAtPath <DefaultAsset>(localAssetPath);
                        if (inkFileAsset == null)
                        {
                            Debug.LogWarning("Ink File Asset not found at " + localAssetPath + ". This can occur if the .meta file has not yet been created. This issue should resolve itself, but if unexpected errors occur, rebuild Ink Library using Assets > Recompile Ink");
                            continue;
                        }
                    }
                    inkFile = new InkFile(inkFileAsset);
                }
                newInkLibrary.Add(inkFile);
            }

            Instance.inkLibrary = newInkLibrary;

            InkMetaLibrary.Instance.metaLibrary.Clear();
            foreach (InkFile inkFile in Instance.inkLibrary)
            {
                InkMetaLibrary.Instance.metaLibrary.Add(inkFile.metaInfo);
            }
            InkMetaLibrary.RebuildInkFileConnections();

            foreach (InkFile inkFile in Instance.inkLibrary)
            {
                inkFile.FindCompiledJSONAsset();
            }
            Save();
        }
示例#17
0
        /// <summary>
        /// Starts a System.Process that compiles a master ink file, creating a playable JSON file that can be parsed by the Ink.Story class
        /// </summary>
        /// <param name="inkFile">Ink file.</param>
        private static void CompileInkInternal(InkFile inkFile, bool immediate)
        {
            if (inkFile == null)
            {
                Debug.LogError("Tried to compile ink file but input was null.");
                return;
            }
            if (!inkFile.metaInfo.isMaster)
            {
                Debug.LogWarning("Compiling InkFile which is an include. Any file created is likely to be invalid. Did you mean to call CompileInk on inkFile.master?");
            }

            // If we've not yet locked C# compilation do so now
            if (!hasLockedUnityCompilation)
            {
                hasLockedUnityCompilation = true;
                EditorApplication.LockReloadAssemblies();
            }

            RemoveFromPendingCompilationStack(inkFile);
            if (InkLibrary.GetCompilationStackItem(inkFile) != null)
            {
                UnityEngine.Debug.LogWarning("Tried compiling ink file, but file is already compiling. " + inkFile.filePath);
                return;
            }

            string inputPath = InkEditorUtils.CombinePaths(inkFile.absoluteFolderPath, Path.GetFileName(inkFile.filePath));

            Debug.Assert(inkFile.absoluteFilePath == inputPath);

            CompilationStackItem pendingFile = new CompilationStackItem
            {
                inkFile              = InkLibrary.GetInkFileWithAbsolutePath(inputPath),
                inkAbsoluteFilePath  = inputPath,
                jsonAbsoluteFilePath = inkFile.absoluteJSONPath,
                state     = CompilationStackItem.State.Queued,
                immediate = immediate
            };

            InkLibrary.Instance.compilationStack.Add(pendingFile);
            InkLibrary.SaveToFile();

            TryCompileNextFileInStack();
        }
示例#18
0
 void DisplayHeader()
 {
     if (attached)
     {
         EditorGUILayout.BeginHorizontal(EditorStyles.toolbar);
         GUILayout.Label(new GUIContent("Attached", "This story reference has been attached from elsewhere"));
         if (GUILayout.Button(new GUIContent("Detach", "Detach from the loaded external story"), EditorStyles.toolbarButton))
         {
             Detach();
         }
         EditorGUILayout.EndHorizontal();
     }
     else
     {
         EditorGUILayout.BeginVertical();
         EditorGUI.BeginChangeCheck();
         storyJSONTextAsset = EditorGUILayout.ObjectField("Story JSON", storyJSONTextAsset, typeof(TextAsset), false) as TextAsset;
         if (EditorGUI.EndChangeCheck())
         {
             if (storyJSONTextAsset == null)
             {
                 story  = null;
                 errors = null;
             }
             else
             {
                 Stop();
                 Play(storyJSONTextAsset);
             }
         }
         if (storyJSONTextAsset != null && storyJSON != null)
         {
             string fullJSONFilePath = InkEditorUtils.UnityRelativeToAbsolutePath(AssetDatabase.GetAssetPath(storyJSONTextAsset));
             var    updatedStoryJSONLastEditDateTime = File.GetLastWriteTime(fullJSONFilePath);
             if (currentStoryJSONLastEditDateTime != updatedStoryJSONLastEditDateTime)
             {
                 EditorGUILayout.HelpBox("Story JSON file has changed. Restart to play updated story.", MessageType.Warning);
             }
         }
         EditorGUILayout.EndVertical();
     }
 }
示例#19
0
 void CreateTodoList()
 {
     todosList = new ReorderableList(inkFile.todos, typeof(string), false, true, false, false);
     todosList.elementHeight      = 18;
     todosList.drawHeaderCallback = (Rect rect) => {
         EditorGUI.LabelField(rect, "To do");
     };
     todosList.drawElementCallback = (Rect rect, int index, bool isActive, bool isFocused) => {
         Rect           labelRect  = new Rect(rect.x, rect.y, rect.width - 80, rect.height);
         Rect           buttonRect = new Rect(labelRect.xMax, rect.y, 80, rect.height - 2);
         InkCompilerLog log        = ((List <InkCompilerLog>)todosList.list)[index];
         string         label      = log.content;
         GUI.Label(labelRect, label);
         string openLabel = "Open" + (log.lineNumber == -1 ? "" : " (" + log.lineNumber + ")");
         if (GUI.Button(buttonRect, openLabel))
         {
             InkEditorUtils.OpenInEditor(inkFile, log);
         }
     };
 }
示例#20
0
		public void FindIncludedFiles (bool addMissing = false) {
			includes.Clear();
			foreach(string includePath in includePaths) {
				string localIncludePath = InkEditorUtils.CombinePaths(Path.GetDirectoryName(filePath), includePath);
				// This enables parsing ..\ and the like. Can we use Path.GetFullPath instead?
				var fullIncludePath = new FileInfo(localIncludePath).FullName;
				localIncludePath = InkEditorUtils.AbsoluteToUnityRelativePath(fullIncludePath);
				DefaultAsset includedInkFileAsset = AssetDatabase.LoadAssetAtPath<DefaultAsset>(localIncludePath);
				if(includedInkFileAsset == null) {
					Debug.LogError(filePath+ " expected child .ink asset at '"+localIncludePath+"' but file was not found.", inkAsset);
				} else {
					InkFile includedInkFile = InkLibrary.GetInkFileWithFile(includedInkFileAsset, addMissing);
					if(includedInkFile == null) {
						Debug.LogError(filePath+ " expected child InkFile from .ink asset at '"+localIncludePath+"' but file was not found.", inkAsset);
					} else if (includedInkFile.includes.Contains(inkAsset)) {
						Debug.LogError("Circular INCLUDE reference between '"+filePath+"' and '"+includedInkFile.filePath+"'.", inkAsset);
					} else
						includes.Add(includedInkFileAsset);
				}
			}
		}
示例#21
0
 public void FindIncludedFiles()
 {
     includes.Clear();
     foreach (string includePath in includePaths)
     {
         string       localIncludePath     = InkEditorUtils.CombinePaths(Path.GetDirectoryName(inkFile.filePath), includePath);
         DefaultAsset includedInkFileAsset = AssetDatabase.LoadAssetAtPath <DefaultAsset>(localIncludePath);
         InkFile      includedInkFile      = InkLibrary.GetInkFileWithFile(includedInkFileAsset);
         if (includedInkFile == null)
         {
             Debug.LogError(inkFile.filePath + " expected child Ink file at " + localIncludePath + " but file was not found.");
         }
         else if (includedInkFile.metaInfo.includes.Contains(inkAsset))
         {
             Debug.LogError("Circular INCLUDE reference between " + inkFile.filePath + " and " + includedInkFile.metaInfo.inkFile.filePath + ".");
         }
         else
         {
             includes.Add(includedInkFileAsset);
         }
     }
 }
示例#22
0
        private static void OnImportAssets(string[] importedAssets)
        {
            List <string> importedInkAssets     = new List <string>();
            string        inklecateFileLocation = null;

            foreach (var importedAssetPath in importedAssets)
            {
                if (Path.GetExtension(importedAssetPath) == InkEditorUtils.inkFileExtension)
                {
                    importedInkAssets.Add(importedAssetPath);
                }
                else if (Path.GetFileName(importedAssetPath) == "inklecate" && Path.GetExtension(importedAssetPath) == "")
                {
                    inklecateFileLocation = importedAssetPath;
                }
                else if (Path.GetExtension(importedAssetPath) == ".asset")
                {
                    var obj = AssetDatabase.LoadAssetAtPath <ScriptableObject>(importedAssetPath);
                    if (obj is InkSettings)
                    {
                        InkEditorUtils.DeleteAllButOldestScriptableObjects(AssetDatabase.FindAssets("t:" + typeof(InkSettings).Name), typeof(InkSettings).Name);
                    }
                    else if (obj is InkLibrary)
                    {
                        InkEditorUtils.DeleteAllButOldestScriptableObjects(AssetDatabase.FindAssets("t:" + typeof(InkLibrary).Name), typeof(InkLibrary).Name);
                    }
                }
            }

            if (importedInkAssets.Count > 0)
            {
                PostprocessInkFiles(importedInkAssets);
            }
            if (inklecateFileLocation != null)
            {
                PostprocessInklecate(inklecateFileLocation);
            }
        }
示例#23
0
        public override void OnInspectorGUI()
        {
            serializedObject.Update();

            if (GUILayout.Button(new GUIContent("Rebuild Library", "Rebuilds the ink library. Do this if you're getting unusual errors")))
            {
                InkLibrary.Rebuild();
            }

            if (GUILayout.Button(new GUIContent("Recompile All", "Rebuilds the ink library and recompiles all files.")))
            {
                InkEditorUtils.RecompileAll();
            }

            EditorGUILayout.HelpBox("This file caches information about ink files in your project.", MessageType.Info);
            EditorGUILayout.PropertyField(serializedObject.FindProperty("inkLibrary"), true);
            EditorGUILayout.PropertyField(serializedObject.FindProperty("compilationStack"), true);
            if (GUI.changed && target != null)
            {
                EditorUtility.SetDirty(target);
            }
            serializedObject.ApplyModifiedProperties();
        }
示例#24
0
        private static void OnMoveAssets(string[] movedAssets)
        {
            if (!InkLibrary.Instance.handleJSONFilesAutomatically)
            {
                return;
            }
            for (var i = 0; i < movedAssets.Length; i++)
            {
                if (Path.GetExtension(movedAssets[i]) != InkEditorUtils.inkFileExtension)
                {
                    continue;
                }
                InkFile inkFile = InkLibrary.GetInkFileWithPath(movedAssets[i]);
                if (inkFile != null)
                {
                    string jsonAssetPath = AssetDatabase.GetAssetPath(inkFile.jsonAsset);

                    string movedAssetDir  = Path.GetDirectoryName(movedAssets[i]);
                    string movedAssetFile = Path.GetFileName(movedAssets[i]);
                    string newPath        = InkEditorUtils.CombinePaths(movedAssetDir, Path.GetFileNameWithoutExtension(movedAssetFile)) + ".json";
                    AssetDatabase.MoveAsset(jsonAssetPath, newPath);
                }
            }
        }
示例#25
0
        void DrawEditAndCompileDates(InkFile masterInkFile)
        {
            string   editAndCompileDateString = "";
            DateTime lastEditDate             = File.GetLastWriteTime(inkFile.absoluteFilePath);

            editAndCompileDateString += "Last edit date " + lastEditDate.ToString();
            if (masterInkFile.jsonAsset != null)
            {
                DateTime lastCompileDate = File.GetLastWriteTime(InkEditorUtils.CombinePaths(Application.dataPath, AssetDatabase.GetAssetPath(masterInkFile.jsonAsset).Substring(7)));
                editAndCompileDateString += "\nLast compile date " + lastCompileDate.ToString();
                if (lastEditDate > lastCompileDate)
                {
                    EditorGUILayout.HelpBox(editAndCompileDateString, MessageType.Warning);
                }
                else
                {
                    EditorGUILayout.HelpBox(editAndCompileDateString, MessageType.None);
                }
            }
            else
            {
                EditorGUILayout.HelpBox(editAndCompileDateString, MessageType.None);
            }
        }
示例#26
0
 public static string UnityRelativeToAbsolutePath(string filePath)
 {
     return(InkEditorUtils.CombinePaths(Application.dataPath, filePath.Substring(7)));
 }
        private static void OnMoveAssets(string[] movedAssets)
        {
            if (!InkSettings.Instance.handleJSONFilesAutomatically)
            {
                return;
            }

            List <string> validMovedAssets = new List <string>();

            for (var i = 0; i < movedAssets.Length; i++)
            {
                if (!InkEditorUtils.IsInkFile(movedAssets[i]))
                {
                    continue;
                }
                validMovedAssets.Add(movedAssets[i]);
                queuedMovedAssets.Add(movedAssets[i]);
            }
            // Move compiled JSON files.
            // This can cause Unity to postprocess assets again.
            bool assetMoved = false;

            foreach (var inkFilePath in validMovedAssets)
            {
                InkFile inkFile = InkLibrary.GetInkFileWithPath(inkFilePath);
                if (inkFile == null)
                {
                    continue;
                }
                if (inkFile.jsonAsset == null)
                {
                    continue;
                }

                string jsonAssetPath = AssetDatabase.GetAssetPath(inkFile.jsonAsset);

                string movedAssetDir  = Path.GetDirectoryName(inkFilePath);
                string movedAssetFile = Path.GetFileName(inkFilePath);
                string newPath        = InkEditorUtils.CombinePaths(movedAssetDir, Path.GetFileNameWithoutExtension(movedAssetFile)) + ".json";
                AssetDatabase.MoveAsset(jsonAssetPath, newPath);
                assetMoved = true;
            }

            // Check if no JSON assets were moved (as a result of none needing to move, or this function being called as a result of JSON files being moved)
            if (!assetMoved && queuedMovedAssets.Count > 0)
            {
                List <InkFile> filesToCompile = new List <InkFile>();

                // Add the old master file to the files to be recompiled
                foreach (var inkFilePath in queuedMovedAssets)
                {
                    InkFile inkFile = InkLibrary.GetInkFileWithPath(inkFilePath);
                    if (inkFile == null)
                    {
                        continue;
                    }
                    foreach (var masterInkFile in inkFile.masterInkFilesIncludingSelf)
                    {
                        if (!filesToCompile.Contains(inkFile))
                        {
                            filesToCompile.Add(inkFile);
                        }
                    }
                }

                InkLibrary.RebuildInkFileConnections();

                // Add the new file to be recompiled
                foreach (var inkFilePath in queuedMovedAssets)
                {
                    InkFile inkFile = InkLibrary.GetInkFileWithPath(inkFilePath);
                    if (inkFile == null)
                    {
                        continue;
                    }

                    foreach (var masterInkFile in inkFile.masterInkFilesIncludingSelf)
                    {
                        if (!filesToCompile.Contains(inkFile))
                        {
                            filesToCompile.Add(inkFile);
                        }
                    }
                }

                queuedMovedAssets.Clear();

                // Compile any ink files that are deemed master files a rebuild
                foreach (var inkFile in filesToCompile)
                {
                    if (inkFile.isMaster)
                    {
                        if (InkSettings.Instance.compileAutomatically || inkFile.compileAutomatically)
                        {
                            InkCompiler.CompileInk(inkFile);
                        }
                    }
                }
            }
        }
示例#28
0
 static InkLibrary FindOrCreateLibrary()
 {
     return(InkEditorUtils.FindOrCreateSingletonScriptableObjectOfType <InkLibrary>(defaultPath, pathPlayerPrefsKey));
 }
示例#29
0
 static InkLibrary FindLibrary()
 {
     return(InkEditorUtils.FastFindAndEnforceSingletonScriptableObjectOfType <InkLibrary>(pathPlayerPrefsKey));
 }
示例#30
0
        private static void SetOutputLog(CompilationStackItem pendingFile)
        {
            pendingFile.inkFile.metaInfo.errors.Clear();
            pendingFile.inkFile.metaInfo.warnings.Clear();
            pendingFile.inkFile.metaInfo.todos.Clear();

            foreach (var childInkFile in pendingFile.inkFile.metaInfo.inkFilesInIncludeHierarchy)
            {
                childInkFile.metaInfo.compileErrors.Clear();
                childInkFile.metaInfo.errors.Clear();
                childInkFile.metaInfo.warnings.Clear();
                childInkFile.metaInfo.todos.Clear();
            }

            foreach (string output in pendingFile.output)
            {
                var match = _errorRegex.Match(output);
                if (match.Success)
                {
                    string errorType = null;
                    string filename  = null;
                    int    lineNo    = -1;
                    string message   = null;

                    var errorTypeCapture = match.Groups["errorType"];
                    if (errorTypeCapture != null)
                    {
                        errorType = errorTypeCapture.Value;
                    }

                    var filenameCapture = match.Groups["filename"];
                    if (filenameCapture != null)
                    {
                        filename = filenameCapture.Value;
                    }

                    var lineNoCapture = match.Groups["lineNo"];
                    if (lineNoCapture != null)
                    {
                        lineNo = int.Parse(lineNoCapture.Value);
                    }

                    var messageCapture = match.Groups["message"];
                    if (messageCapture != null)
                    {
                        message = messageCapture.Value.Trim();
                    }


                    string  logFilePath = InkEditorUtils.CombinePaths(Path.GetDirectoryName(pendingFile.inkFile.filePath), filename);
                    InkFile inkFile     = InkLibrary.GetInkFileWithPath(logFilePath);
                    if (inkFile == null)
                    {
                        inkFile = pendingFile.inkFile;
                    }

                    string pathAndLineNumberString = "\n" + inkFile.filePath + ":" + lineNo;
                    if (errorType == "ERROR")
                    {
                        inkFile.metaInfo.errors.Add(new InkMetaFile.InkFileLog(message, lineNo));
                        Debug.LogError("INK " + errorType + ": " + message + pathAndLineNumberString);
                    }
                    else if (errorType == "WARNING")
                    {
                        inkFile.metaInfo.warnings.Add(new InkMetaFile.InkFileLog(message, lineNo));
                        Debug.LogWarning("INK " + errorType + ": " + message + pathAndLineNumberString);
                    }
                    else if (errorType == "TODO")
                    {
                        inkFile.metaInfo.todos.Add(new InkMetaFile.InkFileLog(message, lineNo));
                        Debug.Log("INK " + errorType + ": " + message + pathAndLineNumberString);
                    }
                }
            }
        }