diff --git a/Assets/Ink.meta b/Assets/Ink.meta new file mode 100644 index 000000000..7d8a1b767 --- /dev/null +++ b/Assets/Ink.meta @@ -0,0 +1,8 @@ +fileFormatVersion: 2 +guid: 4db0e7e1caca41440b5b14f966d1b38c +folderAsset: yes +DefaultImporter: + externalObjects: {} + userData: + assetBundleName: + assetBundleVariant: diff --git a/Assets/Ink/compiler.meta b/Assets/Ink/compiler.meta new file mode 100644 index 000000000..b008b0564 --- /dev/null +++ b/Assets/Ink/compiler.meta @@ -0,0 +1,8 @@ +fileFormatVersion: 2 +guid: a220efa8dba4e9d4c957cbc085eabed2 +folderAsset: yes +DefaultImporter: + externalObjects: {} + userData: + assetBundleName: + assetBundleVariant: diff --git a/Assets/Ink/compiler/CharacterRange.cs b/Assets/Ink/compiler/CharacterRange.cs new file mode 100644 index 000000000..40ae68930 --- /dev/null +++ b/Assets/Ink/compiler/CharacterRange.cs @@ -0,0 +1,54 @@ +using System.Collections.Generic; +using System.Linq; + +namespace Ink +{ + /// + /// A class representing a character range. Allows for lazy-loading a corresponding character set. + /// + public sealed class CharacterRange + { + public static CharacterRange Define(char start, char end, IEnumerable excludes = null) + { + return new CharacterRange (start, end, excludes); + } + + /// + /// Returns a character set instance corresponding to the character range + /// represented by the current instance. + /// + /// + /// The internal character set is created once and cached in memory. + /// + /// The char set. + public CharacterSet ToCharacterSet () + { + if (_correspondingCharSet.Count == 0) + { + for (char c = _start; c <= _end; c++) + { + if (!_excludes.Contains (c)) + { + _correspondingCharSet.Add (c); + } + } + } + return _correspondingCharSet; + } + + public char start { get { return _start; } } + public char end { get { return _end; } } + + CharacterRange (char start, char end, IEnumerable excludes) + { + _start = start; + _end = end; + _excludes = excludes == null ? new HashSet() : new HashSet (excludes); + } + + char _start; + char _end; + ICollection _excludes; + CharacterSet _correspondingCharSet = new CharacterSet(); + } +} diff --git a/Assets/Ink/compiler/CharacterRange.cs.meta b/Assets/Ink/compiler/CharacterRange.cs.meta new file mode 100644 index 000000000..ef8b75e13 --- /dev/null +++ b/Assets/Ink/compiler/CharacterRange.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: 72ae8a113e216e342af5643382c14802 +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/Assets/Ink/compiler/CharacterSet.cs b/Assets/Ink/compiler/CharacterSet.cs new file mode 100644 index 000000000..7e0eef2f6 --- /dev/null +++ b/Assets/Ink/compiler/CharacterSet.cs @@ -0,0 +1,53 @@ +using System.Collections.Generic; + +namespace Ink +{ + + public class CharacterSet : HashSet + { + public static CharacterSet FromRange(char start, char end) + { + return new CharacterSet ().AddRange (start, end); + } + + public CharacterSet () + { + } + + public CharacterSet(string str) + { + AddCharacters (str); + } + + public CharacterSet(CharacterSet charSetToCopy) + { + AddCharacters (charSetToCopy); + } + + public CharacterSet AddRange(char start, char end) + { + for(char c=start; c<=end; ++c) { + Add (c); + } + return this; + } + + public CharacterSet AddCharacters(IEnumerable chars) + { + foreach (char c in chars) { + Add (c); + } + return this; + } + + public CharacterSet AddCharacters (string chars) + { + foreach (char c in chars) { + Add (c); + } + return this; + } + + } +} + diff --git a/Assets/Ink/compiler/CharacterSet.cs.meta b/Assets/Ink/compiler/CharacterSet.cs.meta new file mode 100644 index 000000000..921012437 --- /dev/null +++ b/Assets/Ink/compiler/CharacterSet.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: 61e245e371a3dd848a15f35d6e9f43ed +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/Assets/Ink/compiler/CommandLineInput.cs b/Assets/Ink/compiler/CommandLineInput.cs new file mode 100644 index 000000000..88f1dfe57 --- /dev/null +++ b/Assets/Ink/compiler/CommandLineInput.cs @@ -0,0 +1,12 @@ +namespace Ink +{ + public class CommandLineInput + { + public bool isHelp; + public bool isExit; + public int? choiceInput; + public int? debugSource; + public string debugPathLookup; + public object userImmediateModeStatement; + } +} \ No newline at end of file diff --git a/Assets/Ink/compiler/CommandLineInput.cs.meta b/Assets/Ink/compiler/CommandLineInput.cs.meta new file mode 100644 index 000000000..9a9412567 --- /dev/null +++ b/Assets/Ink/compiler/CommandLineInput.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: 9ea826b6e6cf3c04cacb8f0967c91658 +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/Assets/Ink/compiler/Compiler.cs b/Assets/Ink/compiler/Compiler.cs new file mode 100644 index 000000000..f3e00321d --- /dev/null +++ b/Assets/Ink/compiler/Compiler.cs @@ -0,0 +1,209 @@ +using System; +using System.Collections.Generic; +using Ink; + +namespace Ink +{ + public class Compiler + { + public class Options + { + public string sourceFilename; + public List pluginNames; + public bool countAllVisits; + public Ink.ErrorHandler errorHandler; + public Ink.IFileHandler fileHandler; + } + + public Parsed.Story parsedStory { + get { + return _parsedStory; + } + } + + public Compiler (string inkSource, Options options = null) + { + _inputString = inkSource; + _options = options ?? new Options(); + if( _options.pluginNames != null ) + _pluginManager = new PluginManager (_options.pluginNames); + } + + public Parsed.Story Parse() + { + _parser = new InkParser(_inputString, _options.sourceFilename, OnParseError, _options.fileHandler); + _parsedStory = _parser.Parse(); + return _parsedStory; + } + + public Runtime.Story Compile () + { + Parse(); + + if( _pluginManager != null ) + _pluginManager.PostParse(_parsedStory); + + if (_parsedStory != null && !_hadParseError) { + + _parsedStory.countAllVisits = _options.countAllVisits; + + _runtimeStory = _parsedStory.ExportRuntime (_options.errorHandler); + + if( _pluginManager != null ) + _pluginManager.PostExport (_parsedStory, _runtimeStory); + } else { + _runtimeStory = null; + } + + return _runtimeStory; + } + + public class CommandLineInputResult { + public bool requestsExit; + public int choiceIdx = -1; + public string divertedPath; + public string output; + } + public CommandLineInputResult HandleInput (CommandLineInput inputResult) + { + var result = new CommandLineInputResult (); + + // Request for debug source line number + if (inputResult.debugSource != null) { + var offset = (int)inputResult.debugSource; + var dm = DebugMetadataForContentAtOffset (offset); + if (dm != null) + result.output = "DebugSource: " + dm.ToString (); + else + result.output = "DebugSource: Unknown source"; + } + + // Request for runtime path lookup (to line number) + else if (inputResult.debugPathLookup != null) { + var pathStr = inputResult.debugPathLookup; + var contentResult = _runtimeStory.ContentAtPath (new Runtime.Path (pathStr)); + var dm = contentResult.obj.debugMetadata; + if( dm != null ) + result.output = "DebugSource: " + dm.ToString (); + else + result.output = "DebugSource: Unknown source"; + } + + // User entered some ink + else if (inputResult.userImmediateModeStatement != null) { + var parsedObj = inputResult.userImmediateModeStatement as Parsed.Object; + return ExecuteImmediateStatement(parsedObj); + + } else { + return null; + } + + return result; + } + + CommandLineInputResult ExecuteImmediateStatement(Parsed.Object parsedObj) { + var result = new CommandLineInputResult (); + + // Variable assignment: create in Parsed.Story as well as the Runtime.Story + // so that we don't get an error message during reference resolution + if (parsedObj is Parsed.VariableAssignment) { + var varAssign = (Parsed.VariableAssignment)parsedObj; + if (varAssign.isNewTemporaryDeclaration) { + _parsedStory.TryAddNewVariableDeclaration (varAssign); + } + } + + parsedObj.parent = _parsedStory; + var runtimeObj = parsedObj.runtimeObject; + + parsedObj.ResolveReferences (_parsedStory); + + if (!_parsedStory.hadError) { + + // Divert + if (parsedObj is Parsed.Divert) { + var parsedDivert = parsedObj as Parsed.Divert; + result.divertedPath = parsedDivert.runtimeDivert.targetPath.ToString(); + } + + // Expression or variable assignment + else if (parsedObj is Parsed.Expression || parsedObj is Parsed.VariableAssignment) { + var evalResult = _runtimeStory.EvaluateExpression ((Runtime.Container)runtimeObj); + if (evalResult != null) { + result.output = evalResult.ToString (); + } + } + } else { + _parsedStory.ResetError (); + } + + return result; + } + + public void RetrieveDebugSourceForLatestContent () + { + foreach (var outputObj in _runtimeStory.state.outputStream) { + var textContent = outputObj as Runtime.StringValue; + if (textContent != null) { + var range = new DebugSourceRange (); + range.length = textContent.value.Length; + range.debugMetadata = textContent.debugMetadata; + range.text = textContent.value; + _debugSourceRanges.Add (range); + } + } + } + + Runtime.DebugMetadata DebugMetadataForContentAtOffset (int offset) + { + int currOffset = 0; + + Runtime.DebugMetadata lastValidMetadata = null; + foreach (var range in _debugSourceRanges) { + if (range.debugMetadata != null) + lastValidMetadata = range.debugMetadata; + + if (offset >= currOffset && offset < currOffset + range.length) + return lastValidMetadata; + + currOffset += range.length; + } + + return null; + } + + public struct DebugSourceRange + { + public int length; + public Runtime.DebugMetadata debugMetadata; + public string text; + } + + // Need to wrap the error handler so that we know + // when there was a critical error between parse and codegen stages + void OnParseError (string message, ErrorType errorType) + { + if( errorType == ErrorType.Error ) + _hadParseError = true; + + if (_options.errorHandler != null) + _options.errorHandler (message, errorType); + else + throw new System.Exception(message); + } + + string _inputString; + Options _options; + + + InkParser _parser; + Parsed.Story _parsedStory; + Runtime.Story _runtimeStory; + + PluginManager _pluginManager; + + bool _hadParseError; + + List _debugSourceRanges = new List (); + } +} diff --git a/Assets/Ink/compiler/Compiler.cs.meta b/Assets/Ink/compiler/Compiler.cs.meta new file mode 100644 index 000000000..8406769a6 --- /dev/null +++ b/Assets/Ink/compiler/Compiler.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: 02566d14814a1194ea64f24ac13aabbb +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/Assets/Ink/compiler/FileHandler.cs b/Assets/Ink/compiler/FileHandler.cs new file mode 100644 index 000000000..51a60bb47 --- /dev/null +++ b/Assets/Ink/compiler/FileHandler.cs @@ -0,0 +1,24 @@ +using System.IO; + +namespace Ink +{ + public interface IFileHandler + { + string ResolveInkFilename (string includeName); + string LoadInkFileContents (string fullFilename); + } + + public class DefaultFileHandler : Ink.IFileHandler { + public string ResolveInkFilename (string includeName) + { + var workingDir = Directory.GetCurrentDirectory (); + var fullRootInkPath = Path.Combine (workingDir, includeName); + return fullRootInkPath; + } + + public string LoadInkFileContents (string fullFilename) + { + return File.ReadAllText (fullFilename); + } + } +} diff --git a/Assets/Ink/compiler/FileHandler.cs.meta b/Assets/Ink/compiler/FileHandler.cs.meta new file mode 100644 index 000000000..98d42bf29 --- /dev/null +++ b/Assets/Ink/compiler/FileHandler.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: a4bc77a489a8348498429161a93a337a +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/Assets/Ink/compiler/InkParser.meta b/Assets/Ink/compiler/InkParser.meta new file mode 100644 index 000000000..5e4a0549d --- /dev/null +++ b/Assets/Ink/compiler/InkParser.meta @@ -0,0 +1,8 @@ +fileFormatVersion: 2 +guid: 2ac8c073d5990034aa0cc05037439d4f +folderAsset: yes +DefaultImporter: + externalObjects: {} + userData: + assetBundleName: + assetBundleVariant: diff --git a/Assets/Ink/compiler/InkParser/CommentEliminator.cs b/Assets/Ink/compiler/InkParser/CommentEliminator.cs new file mode 100644 index 000000000..9d0cfee59 --- /dev/null +++ b/Assets/Ink/compiler/InkParser/CommentEliminator.cs @@ -0,0 +1,93 @@ + +namespace Ink +{ + /// + /// Pre-pass before main ink parser runs. It actually performs two main tasks: + /// - comment elimination to simplify the parse rules in the main parser + /// - Conversion of Windows line endings (\r\n) to the simpler Unix style (\n), so + /// we don't have to worry about them later. + /// + public class CommentEliminator : StringParser + { + public CommentEliminator (string input) : base(input) + { + } + + public string Process() + { + // Make both comments and non-comments optional to handle trivial empty file case (or *only* comments) + var stringList = Interleave(Optional (CommentsAndNewlines), Optional(MainInk)); + + if (stringList != null) { + return string.Join("", stringList.ToArray()); + } else { + return null; + } + } + + string MainInk() + { + return ParseUntil (CommentsAndNewlines, _commentOrNewlineStartCharacter, null); + } + + string CommentsAndNewlines() + { + var newlines = Interleave (Optional (ParseNewline), Optional (ParseSingleComment)); + + if (newlines != null) { + return string.Join ("", newlines.ToArray()); + } else { + return null; + } + } + + // Valid comments always return either an empty string or pure newlines, + // which we want to keep so that line numbers stay the same + string ParseSingleComment() + { + return (string) OneOf (EndOfLineComment, BlockComment); + } + + string EndOfLineComment() + { + if (ParseString ("//") == null) { + return null; + } + + ParseUntilCharactersFromCharSet (_newlineCharacters); + + return ""; + } + + string BlockComment() + { + if (ParseString ("/*") == null) { + return null; + } + + int startLineIndex = lineIndex; + + var commentResult = ParseUntil (String("*/"), _commentBlockEndCharacter, null); + + if (!endOfInput) { + ParseString ("*/"); + } + + // Count the number of lines that were inside the block, and replicate them as newlines + // so that the line indexing still works from the original source + if (commentResult != null) { + return new string ('\n', lineIndex - startLineIndex); + } + + // No comment at all + else { + return null; + } + } + + CharacterSet _commentOrNewlineStartCharacter = new CharacterSet ("/\r\n"); + CharacterSet _commentBlockEndCharacter = new CharacterSet("*"); + CharacterSet _newlineCharacters = new CharacterSet ("\n\r"); + } +} + diff --git a/Assets/Ink/compiler/InkParser/CommentEliminator.cs.meta b/Assets/Ink/compiler/InkParser/CommentEliminator.cs.meta new file mode 100644 index 000000000..3e3f04a54 --- /dev/null +++ b/Assets/Ink/compiler/InkParser/CommentEliminator.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: e650e9d0adfa13d40a23175367324716 +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/Assets/Ink/compiler/InkParser/InkParser.cs b/Assets/Ink/compiler/InkParser/InkParser.cs new file mode 100644 index 000000000..4068edbcf --- /dev/null +++ b/Assets/Ink/compiler/InkParser/InkParser.cs @@ -0,0 +1,171 @@ +using System; +using System.Collections.Generic; +using System.IO; + +namespace Ink +{ + public partial class InkParser : StringParser + { + public InkParser(string str, string filenameForMetadata = null, Ink.ErrorHandler externalErrorHandler = null, IFileHandler fileHandler = null) + : this(str, filenameForMetadata, externalErrorHandler, null, fileHandler) + { } + + InkParser(string str, string inkFilename = null, Ink.ErrorHandler externalErrorHandler = null, InkParser rootParser = null, IFileHandler fileHandler = null) : base(str) { + _filename = inkFilename; + RegisterExpressionOperators (); + GenerateStatementLevelRules (); + + // Built in handler for all standard parse errors and warnings + this.errorHandler = OnStringParserError; + + // The above parse errors are then formatted as strings and passed + // to the Ink.ErrorHandler, or it throws an exception + _externalErrorHandler = externalErrorHandler; + + _fileHandler = fileHandler ?? new DefaultFileHandler(); + + if (rootParser == null) { + _rootParser = this; + + _openFilenames = new HashSet (); + + if (inkFilename != null) { + var fullRootInkPath = _fileHandler.ResolveInkFilename (inkFilename); + _openFilenames.Add (fullRootInkPath); + } + + } else { + _rootParser = rootParser; + } + + } + + // Main entry point + public Parsed.Story Parse() + { + List topLevelContent = StatementsAtLevel (StatementLevel.Top); + + // Note we used to return null if there were any errors, but this would mean + // that include files would return completely empty rather than attempting to + // continue with errors. Returning an empty include files meant that anything + // that *did* compile successfully would otherwise be ignored, generating way + // more errors than necessary. + return new Parsed.Story (topLevelContent, isInclude:_rootParser != this); + } + + protected List SeparatedList (SpecificParseRule mainRule, ParseRule separatorRule) where T : class + { + T firstElement = Parse (mainRule); + if (firstElement == null) return null; + + var allElements = new List (); + allElements.Add (firstElement); + + do { + + int nextElementRuleId = BeginRule (); + + var sep = separatorRule (); + if (sep == null) { + FailRule (nextElementRuleId); + break; + } + + var nextElement = Parse (mainRule); + if (nextElement == null) { + FailRule (nextElementRuleId); + break; + } + + SucceedRule (nextElementRuleId); + + allElements.Add (nextElement); + + } while (true); + + return allElements; + } + + protected override string PreProcessInputString(string str) + { + var inputWithCommentsRemoved = (new CommentEliminator (str)).Process(); + return inputWithCommentsRemoved; + } + + protected Runtime.DebugMetadata CreateDebugMetadata(StringParserState.Element stateAtStart, StringParserState.Element stateAtEnd) + { + var md = new Runtime.DebugMetadata (); + md.startLineNumber = stateAtStart.lineIndex + 1; + md.endLineNumber = stateAtEnd.lineIndex + 1; + md.startCharacterNumber = stateAtStart.characterInLineIndex + 1; + md.endCharacterNumber = stateAtEnd.characterInLineIndex + 1; + md.fileName = _filename; + return md; + } + + protected override void RuleDidSucceed(object result, StringParserState.Element stateAtStart, StringParserState.Element stateAtEnd) + { + // Apply DebugMetadata based on the state at the start of the rule + // (i.e. use line number as it was at the start of the rule) + var parsedObj = result as Parsed.Object; + if ( parsedObj) { + parsedObj.debugMetadata = CreateDebugMetadata(stateAtStart, stateAtEnd); + return; + } + + // A list of objects that doesn't already have metadata? + var parsedListObjs = result as List; + if (parsedListObjs != null) { + foreach (var parsedListObj in parsedListObjs) { + if (!parsedListObj.hasOwnDebugMetadata) { + parsedListObj.debugMetadata = CreateDebugMetadata(stateAtStart, stateAtEnd); + } + } + } + + var id = result as Parsed.Identifier; + if (id != null) { + id.debugMetadata = CreateDebugMetadata(stateAtStart, stateAtEnd); + } + } + + protected bool parsingStringExpression + { + get { + return GetFlag ((uint)CustomFlags.ParsingString); + } + set { + SetFlag ((uint)CustomFlags.ParsingString, value); + } + } + + protected enum CustomFlags { + ParsingString = 0x1 + } + + void OnStringParserError(string message, int index, int lineIndex, bool isWarning) + { + var warningType = isWarning ? "WARNING:" : "ERROR:"; + string fullMessage; + + if (_filename != null) { + fullMessage = string.Format(warningType+" '{0}' line {1}: {2}", _filename, (lineIndex+1), message); + } else { + fullMessage = string.Format(warningType+" line {0}: {1}", (lineIndex+1), message); + } + + if (_externalErrorHandler != null) { + _externalErrorHandler (fullMessage, isWarning ? ErrorType.Warning : ErrorType.Error); + } else { + throw new System.Exception (fullMessage); + } + } + + IFileHandler _fileHandler; + + Ink.ErrorHandler _externalErrorHandler; + + string _filename; + } +} + diff --git a/Assets/Ink/compiler/InkParser/InkParser.cs.meta b/Assets/Ink/compiler/InkParser/InkParser.cs.meta new file mode 100644 index 000000000..a02351aea --- /dev/null +++ b/Assets/Ink/compiler/InkParser/InkParser.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: 57456b83f66dcfb4dbdc06ae75d41958 +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/Assets/Ink/compiler/InkParser/InkParser_AuthorWarning.cs b/Assets/Ink/compiler/InkParser/InkParser_AuthorWarning.cs new file mode 100644 index 000000000..6e73e5972 --- /dev/null +++ b/Assets/Ink/compiler/InkParser/InkParser_AuthorWarning.cs @@ -0,0 +1,28 @@ +using Ink.Parsed; + +namespace Ink +{ + public partial class InkParser + { + protected AuthorWarning AuthorWarning() + { + Whitespace (); + + var identifier = Parse (IdentifierWithMetadata); + if (identifier == null || identifier.name != "TODO") + return null; + + Whitespace (); + + ParseString (":"); + + Whitespace (); + + var message = ParseUntilCharactersFromString ("\n\r"); + + return new AuthorWarning (message); + } + + } +} + diff --git a/Assets/Ink/compiler/InkParser/InkParser_AuthorWarning.cs.meta b/Assets/Ink/compiler/InkParser/InkParser_AuthorWarning.cs.meta new file mode 100644 index 000000000..6a6c386ca --- /dev/null +++ b/Assets/Ink/compiler/InkParser/InkParser_AuthorWarning.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: 0c9f8990d12640c40b17fdb3552c08f6 +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/Assets/Ink/compiler/InkParser/InkParser_CharacterRanges.cs b/Assets/Ink/compiler/InkParser/InkParser_CharacterRanges.cs new file mode 100644 index 000000000..3ac3962b6 --- /dev/null +++ b/Assets/Ink/compiler/InkParser/InkParser_CharacterRanges.cs @@ -0,0 +1,64 @@ +using Ink.Parsed; +using System; +using System.Text; +using System.Collections.Generic; +using System.Linq; + +namespace Ink +{ + public partial class InkParser + { + public static readonly CharacterRange LatinBasic = + CharacterRange.Define ('\u0041', '\u007A', excludes: new CharacterSet().AddRange('\u005B', '\u0060')); + public static readonly CharacterRange LatinExtendedA = CharacterRange.Define('\u0100', '\u017F'); // no excludes here + public static readonly CharacterRange LatinExtendedB = CharacterRange.Define('\u0180', '\u024F'); // no excludes here + public static readonly CharacterRange Greek = + CharacterRange.Define('\u0370', '\u03FF', excludes: new CharacterSet().AddRange('\u0378','\u0385').AddCharacters("\u0374\u0375\u0378\u0387\u038B\u038D\u03A2")); + public static readonly CharacterRange Cyrillic = + CharacterRange.Define('\u0400', '\u04FF', excludes: new CharacterSet().AddRange('\u0482', '\u0489')); + public static readonly CharacterRange Armenian = + CharacterRange.Define('\u0530', '\u058F', excludes: new CharacterSet().AddCharacters("\u0530").AddRange('\u0557', '\u0560').AddRange('\u0588', '\u058E')); + public static readonly CharacterRange Hebrew = + CharacterRange.Define('\u0590', '\u05FF', excludes: new CharacterSet()); + public static readonly CharacterRange Arabic = + CharacterRange.Define('\u0600', '\u06FF', excludes: new CharacterSet()); + public static readonly CharacterRange Korean = + CharacterRange.Define('\uAC00', '\uD7AF', excludes: new CharacterSet()); + public static readonly CharacterRange Latin1Supplement = + CharacterRange.Define('\u0080', '\u00FF', excludes: new CharacterSet()); + + private void ExtendIdentifierCharacterRanges(CharacterSet identifierCharSet) + { + var characterRanges = ListAllCharacterRanges(); + + foreach (var charRange in characterRanges) + { + identifierCharSet.AddCharacters(charRange.ToCharacterSet()); + } + } + + /// + /// Gets an array of representing all of the currently supported + /// non-ASCII character ranges that can be used in identifier names. + /// + /// + /// An array of representing all of the currently supported + /// non-ASCII character ranges that can be used in identifier names. + /// + public static CharacterRange[] ListAllCharacterRanges() { + return new CharacterRange[] { + LatinBasic, + LatinExtendedA, + LatinExtendedB, + Arabic, + Armenian, + Cyrillic, + Greek, + Hebrew, + Korean, + Latin1Supplement, + }; + } + } +} + diff --git a/Assets/Ink/compiler/InkParser/InkParser_CharacterRanges.cs.meta b/Assets/Ink/compiler/InkParser/InkParser_CharacterRanges.cs.meta new file mode 100644 index 000000000..9925778f2 --- /dev/null +++ b/Assets/Ink/compiler/InkParser/InkParser_CharacterRanges.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: e1cc3ab7c74670a40936f5c282a505e7 +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/Assets/Ink/compiler/InkParser/InkParser_Choices.cs b/Assets/Ink/compiler/InkParser/InkParser_Choices.cs new file mode 100644 index 000000000..39c148af7 --- /dev/null +++ b/Assets/Ink/compiler/InkParser/InkParser_Choices.cs @@ -0,0 +1,225 @@ +using Ink.Parsed; +using System.Diagnostics; + +namespace Ink +{ + public partial class InkParser + { + protected Choice Choice() + { + bool onceOnlyChoice = true; + var bullets = Interleave (OptionalExclude(Whitespace), String("*") ); + if (bullets == null) { + + bullets = Interleave (OptionalExclude(Whitespace), String("+") ); + if (bullets == null) { + return null; + } + + onceOnlyChoice = false; + } + + // Optional name for the choice + Identifier optionalName = Parse(BracketedName); + + Whitespace (); + + // Optional condition for whether the choice should be shown to the player + Expression conditionExpr = Parse(ChoiceCondition); + + Whitespace (); + + // Ordinarily we avoid parser state variables like these, since + // nesting would require us to store them in a stack. But since you should + // never be able to nest choices within choice content, it's fine here. + Debug.Assert(_parsingChoice == false, "Already parsing a choice - shouldn't have nested choices"); + _parsingChoice = true; + + ContentList startContent = null; + var startTextAndLogic = Parse (MixedTextAndLogic); + if (startTextAndLogic != null) + startContent = new ContentList (startTextAndLogic); + + + ContentList optionOnlyContent = null; + ContentList innerContent = null; + + // Check for a the weave style format: + // * "Hello[."]," he said. + bool hasWeaveStyleInlineBrackets = ParseString("[") != null; + if (hasWeaveStyleInlineBrackets) { + + var optionOnlyTextAndLogic = Parse (MixedTextAndLogic); + if (optionOnlyTextAndLogic != null) + optionOnlyContent = new ContentList (optionOnlyTextAndLogic); + + + Expect (String("]"), "closing ']' for weave-style option"); + + var innerTextAndLogic = Parse (MixedTextAndLogic); + if( innerTextAndLogic != null ) + innerContent = new ContentList (innerTextAndLogic); + } + + Whitespace (); + + // Finally, now we know we're at the end of the main choice body, parse + // any diverts separately. + var diverts = Parse(MultiDivert); + + _parsingChoice = false; + + Whitespace (); + + // Completely empty choice without even an empty divert? + bool emptyContent = !startContent && !innerContent && !optionOnlyContent; + if (emptyContent && diverts == null) + Warning ("Choice is completely empty. Interpretting as a default fallback choice. Add a divert arrow to remove this warning: * ->"); + + // * [] some text + else if (!startContent && hasWeaveStyleInlineBrackets && !optionOnlyContent) + Warning ("Blank choice - if you intended a default fallback choice, use the `* ->` syntax"); + + if (!innerContent) innerContent = new ContentList (); + + var tags = Parse (Tags); + if (tags != null) { + innerContent.AddContent(tags); + } + + // Normal diverts on the end of a choice - simply add to the normal content + if (diverts != null) { + foreach (var divObj in diverts) { + // may be TunnelOnwards + var div = divObj as Divert; + + // Empty divert serves no purpose other than to say + // "this choice is intentionally left blank" + // (as an invisible default choice) + if (div && div.isEmpty) continue; + + innerContent.AddContent (divObj); + } + } + + // Terminate main content with a newline since this is the end of the line + // Note that this will be redundant if the diverts above definitely take + // the flow away permanently. + innerContent.AddContent (new Text ("\n")); + + var choice = new Choice (startContent, optionOnlyContent, innerContent); + choice.identifier = optionalName; + choice.indentationDepth = bullets.Count; + choice.hasWeaveStyleInlineBrackets = hasWeaveStyleInlineBrackets; + choice.condition = conditionExpr; + choice.onceOnly = onceOnlyChoice; + choice.isInvisibleDefault = emptyContent; + + return choice; + + } + + protected Expression ChoiceCondition() + { + var conditions = Interleave (ChoiceSingleCondition, ChoiceConditionsSpace); + if (conditions == null) + return null; + else if (conditions.Count == 1) + return conditions [0]; + else { + return new MultipleConditionExpression (conditions); + } + } + + protected object ChoiceConditionsSpace() + { + // Both optional + // Newline includes initial end of line whitespace + Newline (); + Whitespace (); + return ParseSuccess; + } + + protected Expression ChoiceSingleCondition() + { + if (ParseString ("{") == null) + return null; + + var condExpr = Expect(Expression, "choice condition inside { }") as Expression; + DisallowIncrement (condExpr); + + Expect (String ("}"), "closing '}' for choice condition"); + + return condExpr; + } + + protected Gather Gather() + { + object gatherDashCountObj = Parse(GatherDashes); + if (gatherDashCountObj == null) { + return null; + } + + int gatherDashCount = (int)gatherDashCountObj; + + // Optional name for the gather + Identifier optionalName = Parse(BracketedName); + + var gather = new Gather (optionalName, gatherDashCount); + + // Optional newline before gather's content begins + Newline (); + + return gather; + } + + protected object GatherDashes() + { + Whitespace (); + + int gatherDashCount = 0; + + while (ParseDashNotArrow () != null) { + gatherDashCount++; + Whitespace (); + } + + if (gatherDashCount == 0) + return null; + + return gatherDashCount; + } + + protected object ParseDashNotArrow() + { + var ruleId = BeginRule (); + + if (ParseString ("->") == null && ParseSingleCharacter () == '-') { + return SucceedRule (ruleId); + } else { + return FailRule (ruleId); + } + } + + protected Identifier BracketedName() + { + if (ParseString ("(") == null) + return null; + + Whitespace (); + + Identifier name = Parse(IdentifierWithMetadata); + if (name == null) + return null; + + Whitespace (); + + Expect (String (")"), "closing ')' for bracketed name"); + + return name; + } + + bool _parsingChoice; + } +} + diff --git a/Assets/Ink/compiler/InkParser/InkParser_Choices.cs.meta b/Assets/Ink/compiler/InkParser/InkParser_Choices.cs.meta new file mode 100644 index 000000000..698cee60f --- /dev/null +++ b/Assets/Ink/compiler/InkParser/InkParser_Choices.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: a2d978613bf868c48b75265740aad51e +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/Assets/Ink/compiler/InkParser/InkParser_CommandLineInput.cs b/Assets/Ink/compiler/InkParser/InkParser_CommandLineInput.cs new file mode 100644 index 000000000..a04ef1766 --- /dev/null +++ b/Assets/Ink/compiler/InkParser/InkParser_CommandLineInput.cs @@ -0,0 +1,129 @@ + +namespace Ink +{ + public partial class InkParser + { + // Valid returned objects: + // - "help" + // - int: for choice number + // - Parsed.Divert + // - Variable declaration/assignment + // - Epression + // - Lookup debug source for character offset + // - Lookup debug source for runtime path + public CommandLineInput CommandLineUserInput() + { + CommandLineInput result = new CommandLineInput (); + + Whitespace (); + + if (ParseString ("help") != null) { + result.isHelp = true; + return result; + } + + if (ParseString ("exit") != null || ParseString ("quit") != null) { + result.isExit = true; + return result; + } + + return (CommandLineInput) OneOf ( + DebugSource, + DebugPathLookup, + UserChoiceNumber, + UserImmediateModeStatement + ); + } + + CommandLineInput DebugSource () + { + Whitespace (); + + if (ParseString ("DebugSource") == null) + return null; + + Whitespace (); + + var expectMsg = "character offset in parentheses, e.g. DebugSource(5)"; + if (Expect (String ("("), expectMsg) == null) + return null; + + Whitespace (); + + int? characterOffset = ParseInt (); + if (characterOffset == null) { + Error (expectMsg); + return null; + } + + Whitespace (); + + Expect (String (")"), "closing parenthesis"); + + var inputStruct = new CommandLineInput (); + inputStruct.debugSource = characterOffset; + return inputStruct; + } + + CommandLineInput DebugPathLookup () + { + Whitespace (); + + if (ParseString ("DebugPath") == null) + return null; + + if (Whitespace () == null) + return null; + + var pathStr = Expect (RuntimePath, "path") as string; + + var inputStruct = new CommandLineInput (); + inputStruct.debugPathLookup = pathStr; + return inputStruct; + } + + string RuntimePath () + { + if (_runtimePathCharacterSet == null) { + _runtimePathCharacterSet = new CharacterSet (identifierCharSet); + _runtimePathCharacterSet.Add ('-'); // for c-0, g-0 etc + _runtimePathCharacterSet.Add ('.'); + + } + + return ParseCharactersFromCharSet (_runtimePathCharacterSet); + } + + CommandLineInput UserChoiceNumber() + { + Whitespace (); + + int? number = ParseInt (); + if (number == null) { + return null; + } + + Whitespace (); + + if (Parse(EndOfLine) == null) { + return null; + } + + var inputStruct = new CommandLineInput (); + inputStruct.choiceInput = number; + return inputStruct; + } + + CommandLineInput UserImmediateModeStatement() + { + var statement = OneOf (SingleDivert, TempDeclarationOrAssignment, Expression); + + var inputStruct = new CommandLineInput (); + inputStruct.userImmediateModeStatement = statement; + return inputStruct; + } + + CharacterSet _runtimePathCharacterSet; + } +} + diff --git a/Assets/Ink/compiler/InkParser/InkParser_CommandLineInput.cs.meta b/Assets/Ink/compiler/InkParser/InkParser_CommandLineInput.cs.meta new file mode 100644 index 000000000..0bf765fcb --- /dev/null +++ b/Assets/Ink/compiler/InkParser/InkParser_CommandLineInput.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: 69954d17756084b4bb0c82e2238d36bd +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/Assets/Ink/compiler/InkParser/InkParser_Conditional.cs b/Assets/Ink/compiler/InkParser/InkParser_Conditional.cs new file mode 100644 index 000000000..c1f60ec50 --- /dev/null +++ b/Assets/Ink/compiler/InkParser/InkParser_Conditional.cs @@ -0,0 +1,288 @@ +using System.Collections.Generic; +using System.Linq; +using Ink.Parsed; + +namespace Ink +{ + public partial class InkParser + { + protected Conditional InnerConditionalContent() + { + var initialQueryExpression = Parse(ConditionExpression); + var conditional = Parse(() => InnerConditionalContent (initialQueryExpression)); + if (conditional == null) + return null; + + return conditional; + } + + protected Conditional InnerConditionalContent(Expression initialQueryExpression) + { + List alternatives; + + bool canBeInline = initialQueryExpression != null; + bool isInline = Parse(Newline) == null; + + if (isInline && !canBeInline) { + return null; + } + + // Inline innards + if (isInline) { + alternatives = InlineConditionalBranches (); + } + + // Multiline innards + else { + alternatives = MultilineConditionalBranches (); + if (alternatives == null) { + + // Allow single piece of content within multi-line expression, e.g.: + // { true: + // Some content that isn't preceded by '-' + // } + if (initialQueryExpression) { + List soleContent = StatementsAtLevel (StatementLevel.InnerBlock); + if (soleContent != null) { + var soleBranch = new ConditionalSingleBranch (soleContent); + alternatives = new List (); + alternatives.Add (soleBranch); + + // Also allow a final "- else:" clause + var elseBranch = Parse (SingleMultilineCondition); + if (elseBranch) { + if (!elseBranch.isElse) { + ErrorWithParsedObject ("Expected an '- else:' clause here rather than an extra condition", elseBranch); + elseBranch.isElse = true; + } + alternatives.Add (elseBranch); + } + } + } + + // Still null? + if (alternatives == null) { + return null; + } + } + + // Empty true branch - didn't get parsed, but should insert one for semantic correctness, + // and to make sure that any evaluation stack values get tidied up correctly. + else if (alternatives.Count == 1 && alternatives [0].isElse && initialQueryExpression) { + var emptyTrueBranch = new ConditionalSingleBranch (null); + emptyTrueBranch.isTrueBranch = true; + alternatives.Insert (0, emptyTrueBranch); + } + + // Like a switch statement + // { initialQueryExpression: + // ... match the expression + // } + if (initialQueryExpression) { + + bool earlierBranchesHaveOwnExpression = false; + for (int i = 0; i < alternatives.Count; ++i) { + var branch = alternatives [i]; + bool isLast = (i == alternatives.Count - 1); + + // Matching equality with initial query expression + // We set this flag even for the "else" clause so that + // it knows to tidy up the evaluation stack at the end + + // Match query + if (branch.ownExpression) { + branch.matchingEquality = true; + earlierBranchesHaveOwnExpression = true; + } + + // Else (final branch) + else if (earlierBranchesHaveOwnExpression && isLast) { + branch.matchingEquality = true; + branch.isElse = true; + } + + // Binary condition: + // { trueOrFalse: + // - when true + // - when false + // } + else { + + if (!isLast && alternatives.Count > 2) { + ErrorWithParsedObject ("Only final branch can be an 'else'. Did you miss a ':'?", branch); + } else { + if (i == 0) + branch.isTrueBranch = true; + else + branch.isElse = true; + } + } + } + } + + // No initial query, so just a multi-line conditional. e.g.: + // { + // - x > 3: greater than three + // - x == 3: equal to three + // - x < 3: less than three + // } + else { + + for (int i = 0; i < alternatives.Count; ++i) { + var alt = alternatives [i]; + bool isLast = (i == alternatives.Count - 1); + if (alt.ownExpression == null) { + if (isLast) { + alt.isElse = true; + } else { + if (alt.isElse) { + // Do we ALSO have a valid "else" at the end? Let's report the error there. + var finalClause = alternatives [alternatives.Count - 1]; + if (finalClause.isElse) { + ErrorWithParsedObject ("Multiple 'else' cases. Can have a maximum of one, at the end.", finalClause); + } else { + ErrorWithParsedObject ("'else' case in conditional should always be the final one", alt); + } + } else { + ErrorWithParsedObject ("Branch doesn't have condition. Are you missing a ':'? ", alt); + } + + } + } + } + + if (alternatives.Count == 1 && alternatives [0].ownExpression == null) { + ErrorWithParsedObject ("Condition block with no conditions", alternatives [0]); + } + } + } + + // TODO: Come up with water-tight error conditions... it's quite a flexible system! + // e.g. + // - inline conditionals must have exactly 1 or 2 alternatives + // - multiline expression shouldn't have mixed existence of branch-conditions? + if (alternatives == null) + return null; + + foreach (var branch in alternatives) { + branch.isInline = isInline; + } + + var cond = new Conditional (initialQueryExpression, alternatives); + return cond; + } + + protected List InlineConditionalBranches() + { + var listOfLists = Interleave> (MixedTextAndLogic, Exclude (String ("|")), flatten: false); + if (listOfLists == null || listOfLists.Count == 0) { + return null; + } + + var result = new List (); + + if (listOfLists.Count > 2) { + Error ("Expected one or two alternatives separated by '|' in inline conditional"); + } else { + + var trueBranch = new ConditionalSingleBranch (listOfLists[0]); + trueBranch.isTrueBranch = true; + result.Add (trueBranch); + + if (listOfLists.Count > 1) { + var elseBranch = new ConditionalSingleBranch (listOfLists[1]); + elseBranch.isElse = true; + result.Add (elseBranch); + } + } + + return result; + } + + protected List MultilineConditionalBranches() + { + MultilineWhitespace (); + + List multipleConditions = OneOrMore (SingleMultilineCondition); + if (multipleConditions == null) + return null; + + MultilineWhitespace (); + + return multipleConditions.Cast().ToList(); + } + + protected ConditionalSingleBranch SingleMultilineCondition() + { + Whitespace (); + + // Make sure we're not accidentally parsing a divert + if (ParseString ("->") != null) + return null; + + if (ParseString ("-") == null) + return null; + + Whitespace (); + + Expression expr = null; + bool isElse = Parse(ElseExpression) != null; + + if( !isElse ) + expr = Parse(ConditionExpression); + + List content = StatementsAtLevel (StatementLevel.InnerBlock); + if (expr == null && content == null) { + Error ("expected content for the conditional branch following '-'"); + + // Recover + content = new List (); + content.Add (new Text ("")); + } + + // Allow additional multiline whitespace, if the statements were empty (valid) + // then their surrounding multiline whitespacce needs to be handled manually. + // e.g. + // { x: + // - 1: // intentionally left blank, but newline needs to be parsed + // - 2: etc + // } + MultilineWhitespace (); + + var branch = new ConditionalSingleBranch (content); + branch.ownExpression = expr; + branch.isElse = isElse; + return branch; + } + + protected Expression ConditionExpression() + { + var expr = Parse(Expression); + if (expr == null) + return null; + + DisallowIncrement (expr); + + Whitespace (); + + if (ParseString (":") == null) + return null; + + return expr; + } + + protected object ElseExpression() + { + if (ParseString ("else") == null) + return null; + + Whitespace (); + + if (ParseString (":") == null) + return null; + + return ParseSuccess; + } + } +} + diff --git a/Assets/Ink/compiler/InkParser/InkParser_Conditional.cs.meta b/Assets/Ink/compiler/InkParser/InkParser_Conditional.cs.meta new file mode 100644 index 000000000..5d71e5ca3 --- /dev/null +++ b/Assets/Ink/compiler/InkParser/InkParser_Conditional.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: 6a295014ccaa92c41bd194e4eecc1bd7 +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/Assets/Ink/compiler/InkParser/InkParser_Content.cs b/Assets/Ink/compiler/InkParser/InkParser_Content.cs new file mode 100644 index 000000000..e1bc7abd0 --- /dev/null +++ b/Assets/Ink/compiler/InkParser/InkParser_Content.cs @@ -0,0 +1,217 @@ +using Ink.Parsed; +using System.Text; +using System.Collections.Generic; +using System.Linq; + +namespace Ink +{ + public partial class InkParser + { + void TrimEndWhitespace(List mixedTextAndLogicResults, bool terminateWithSpace) + { + // Trim whitespace from end + if (mixedTextAndLogicResults.Count > 0) { + var lastObjIdx = mixedTextAndLogicResults.Count - 1; + var lastObj = mixedTextAndLogicResults[lastObjIdx]; + if (lastObj is Text) { + var text = (Text)lastObj; + text.text = text.text.TrimEnd (' ', '\t'); + + if (terminateWithSpace) + text.text += " "; + + // No content left at all? trim the whole object + else if( text.text.Length == 0 ) { + mixedTextAndLogicResults.RemoveAt(lastObjIdx); + + // Recurse in case there's more whitespace + TrimEndWhitespace(mixedTextAndLogicResults, terminateWithSpace:false); + } + } + } + } + + protected List LineOfMixedTextAndLogic() + { + // Consume any whitespace at the start of the line + // (Except for escaped whitespace) + Parse (Whitespace); + + var result = Parse(MixedTextAndLogic); + + // Terminating tag + bool onlyTags = false; + var tags = Parse (Tags); + if (tags != null) { + if (result == null) { + result = tags.Cast ().ToList (); + onlyTags = true; + } else { + foreach (var tag in tags) { + result.Add(tag); + } + } + } + + if (result == null || result.Count == 0) + return null; + + // Warn about accidentally writing "return" without "~" + var firstText = result[0] as Text; + if (firstText) { + if (firstText.text.StartsWith ("return")) { + Warning ("Do you need a '~' before 'return'? If not, perhaps use a glue: <> (since it's lowercase) or rewrite somehow?"); + } + } + if (result.Count == 0) + return null; + + var lastObj = result [result.Count - 1]; + if (!(lastObj is Divert)) { + TrimEndWhitespace (result, terminateWithSpace:false); + } + + // Add newline since it's the end of the line + // (so long as it's a line with only tags) + if( !onlyTags ) + result.Add (new Text ("\n")); + + Expect(EndOfLine, "end of line", recoveryRule: SkipToNextLine); + + return result; + } + + protected List MixedTextAndLogic() + { + // Check for disallowed "~" within this context + var disallowedTilda = ParseObject(Spaced(String("~"))); + if (disallowedTilda != null) + Error ("You shouldn't use a '~' here - tildas are for logic that's on its own line. To do inline logic, use { curly braces } instead"); + + // Either, or both interleaved + var results = Interleave(Optional (ContentText), Optional (InlineLogicOrGlue)); + + // Terminating divert? + // (When parsing content for the text of a choice, diverts aren't allowed. + // The divert on the end of the body of a choice is handled specially.) + if (!_parsingChoice) { + + var diverts = Parse (MultiDivert); + if (diverts != null) { + + // May not have had any results at all if there's *only* a divert! + if (results == null) + results = new List (); + + TrimEndWhitespace (results, terminateWithSpace:true); + + results.AddRange (diverts); + } + + } + + if (results == null) + return null; + + return results; + } + + protected Parsed.Text ContentText() + { + return ContentTextAllowingEcapeChar (); + } + + protected Parsed.Text ContentTextAllowingEcapeChar() + { + StringBuilder sb = null; + + do { + var str = Parse(ContentTextNoEscape); + bool gotEscapeChar = ParseString(@"\") != null; + + if( gotEscapeChar || str != null ) { + if( sb == null ) { + sb = new StringBuilder(); + } + + if( str != null ) { + sb.Append(str); + } + + if( gotEscapeChar ) { + char c = ParseSingleCharacter(); + sb.Append(c); + } + + } else { + break; + } + + } while(true); + + if (sb != null ) { + return new Parsed.Text (sb.ToString ()); + + } else { + return null; + } + } + + // Content text is an unusual parse rule compared with most since it's + // less about saying "this is is the small selection of stuff that we parse" + // and more "we parse ANYTHING except this small selection of stuff". + protected string ContentTextNoEscape() + { + // Eat through text, pausing at the following characters, and + // attempt to parse the nonTextRule. + // "-": possible start of divert or start of gather + // "<": possible start of glue + if (_nonTextPauseCharacters == null) { + _nonTextPauseCharacters = new CharacterSet ("-<"); + } + + // If we hit any of these characters, we stop *immediately* without bothering to even check the nonTextRule + // "{" for start of logic + // "|" for mid logic branch + if (_nonTextEndCharacters == null) { + _nonTextEndCharacters = new CharacterSet ("{}|\n\r\\#"); + _notTextEndCharactersChoice = new CharacterSet (_nonTextEndCharacters); + _notTextEndCharactersChoice.AddCharacters ("[]"); + _notTextEndCharactersString = new CharacterSet (_nonTextEndCharacters); + _notTextEndCharactersString.AddCharacters ("\""); + } + + // When the ParseUntil pauses, check these rules in case they evaluate successfully + ParseRule nonTextRule = () => OneOf (ParseDivertArrow, ParseThreadArrow, EndOfLine, Glue); + + CharacterSet endChars = null; + if (parsingStringExpression) { + endChars = _notTextEndCharactersString; + } + else if (_parsingChoice) { + endChars = _notTextEndCharactersChoice; + } + else { + endChars = _nonTextEndCharacters; + } + + string pureTextContent = ParseUntil (nonTextRule, _nonTextPauseCharacters, endChars); + if (pureTextContent != null ) { + return pureTextContent; + + } else { + return null; + } + + } + + CharacterSet _nonTextPauseCharacters; + CharacterSet _nonTextEndCharacters; + CharacterSet _notTextEndCharactersChoice; + CharacterSet _notTextEndCharactersString; + + + + } +} + diff --git a/Assets/Ink/compiler/InkParser/InkParser_Content.cs.meta b/Assets/Ink/compiler/InkParser/InkParser_Content.cs.meta new file mode 100644 index 000000000..2c401a8e4 --- /dev/null +++ b/Assets/Ink/compiler/InkParser/InkParser_Content.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: 8c355c8ca4318ff4fa96da22c908f550 +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/Assets/Ink/compiler/InkParser/InkParser_Divert.cs b/Assets/Ink/compiler/InkParser/InkParser_Divert.cs new file mode 100644 index 000000000..079d85a78 --- /dev/null +++ b/Assets/Ink/compiler/InkParser/InkParser_Divert.cs @@ -0,0 +1,206 @@ +using System.Collections.Generic; +using Ink.Parsed; + + +namespace Ink +{ + public partial class InkParser + { + protected List MultiDivert() + { + Whitespace (); + + List diverts = null; + + // Try single thread first + var threadDivert = Parse(StartThread); + if (threadDivert) { + diverts = new List (); + diverts.Add (threadDivert); + return diverts; + } + + // Normal diverts and tunnels + var arrowsAndDiverts = Interleave ( + ParseDivertArrowOrTunnelOnwards, + DivertIdentifierWithArguments); + + if (arrowsAndDiverts == null) + return null; + + diverts = new List (); + + // Possible patterns: + // -> -- explicit gather + // ->-> -- tunnel onwards + // -> div -- normal divert + // ->-> div -- tunnel onwards, followed by override divert + // -> div -> -- normal tunnel + // -> div ->-> -- tunnel then tunnel continue + // -> div -> div -- tunnel then divert + // -> div -> div -> -- tunnel then tunnel + // -> div -> div ->-> + // -> div -> div ->-> div (etc) + + // Look at the arrows and diverts + for (int i = 0; i < arrowsAndDiverts.Count; ++i) { + bool isArrow = (i % 2) == 0; + + // Arrow string + if (isArrow) { + + // Tunnel onwards + if ((string)arrowsAndDiverts [i] == "->->") { + + bool tunnelOnwardsPlacementValid = (i == 0 || i == arrowsAndDiverts.Count - 1 || i == arrowsAndDiverts.Count - 2); + if (!tunnelOnwardsPlacementValid) + Error ("Tunnel onwards '->->' must only come at the begining or the start of a divert"); + + var tunnelOnwards = new TunnelOnwards (); + if (i < arrowsAndDiverts.Count - 1) { + var tunnelOnwardDivert = arrowsAndDiverts [i+1] as Parsed.Divert; + tunnelOnwards.divertAfter = tunnelOnwardDivert; + } + + diverts.Add (tunnelOnwards); + + // Not allowed to do anything after a tunnel onwards. + // If we had anything left it would be caused in the above Error for + // the positioning of a ->-> + break; + } + } + + // Divert + else { + + var divert = arrowsAndDiverts [i] as Divert; + + // More to come? (further arrows) Must be tunnelling. + if (i < arrowsAndDiverts.Count - 1) { + divert.isTunnel = true; + } + + diverts.Add (divert); + } + } + + // Single -> (used for default choices) + if (diverts.Count == 0 && arrowsAndDiverts.Count == 1) { + var gatherDivert = new Divert ((Parsed.Object)null); + gatherDivert.isEmpty = true; + diverts.Add (gatherDivert); + + if (!_parsingChoice) + Error ("Empty diverts (->) are only valid on choices"); + } + + return diverts; + } + + protected Divert StartThread() + { + Whitespace (); + + if (ParseThreadArrow() == null) + return null; + + Whitespace (); + + var divert = Expect(DivertIdentifierWithArguments, "target for new thread", () => new Divert(null)) as Divert; + divert.isThread = true; + + return divert; + } + + protected Divert DivertIdentifierWithArguments() + { + Whitespace (); + + List targetComponents = Parse (DotSeparatedDivertPathComponents); + if (targetComponents == null) + return null; + + Whitespace (); + + var optionalArguments = Parse(ExpressionFunctionCallArguments); + + Whitespace (); + + var targetPath = new Path (targetComponents); + return new Divert (targetPath, optionalArguments); + } + + protected Divert SingleDivert() + { + var diverts = Parse (MultiDivert); + if (diverts == null) + return null; + + // Ideally we'd report errors if we get the + // wrong kind of divert, but unfortunately we + // have to hack around the fact that sequences use + // a very similar syntax. + // i.e. if you have a multi-divert at the start + // of a sequence, it initially tries to parse it + // as a divert target (part of an expression of + // a conditional) and gives errors. So instead + // we just have to blindly reject it as a single + // divert, and give a slightly less nice error + // when you DO use a multi divert as a divert taret. + + if (diverts.Count != 1) { + return null; + } + + var singleDivert = diverts [0]; + if (singleDivert is TunnelOnwards) { + return null; + } + + var divert = diverts [0] as Divert; + if (divert.isTunnel) { + return null; + } + + return divert; + } + + List DotSeparatedDivertPathComponents() + { + return Interleave (Spaced (IdentifierWithMetadata), Exclude (String ("."))); + } + + protected string ParseDivertArrowOrTunnelOnwards() + { + int numArrows = 0; + while (ParseString ("->") != null) + numArrows++; + + if (numArrows == 0) + return null; + + else if (numArrows == 1) + return "->"; + + else if (numArrows == 2) + return "->->"; + + else { + Error ("Unexpected number of arrows in divert. Should only have '->' or '->->'"); + return "->->"; + } + } + + protected string ParseDivertArrow() + { + return ParseString ("->"); + } + + protected string ParseThreadArrow() + { + return ParseString ("<-"); + } + } +} + diff --git a/Assets/Ink/compiler/InkParser/InkParser_Divert.cs.meta b/Assets/Ink/compiler/InkParser/InkParser_Divert.cs.meta new file mode 100644 index 000000000..6b9b733a7 --- /dev/null +++ b/Assets/Ink/compiler/InkParser/InkParser_Divert.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: f10858a666e02754ca88946ef07d2cff +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/Assets/Ink/compiler/InkParser/InkParser_Expressions.cs b/Assets/Ink/compiler/InkParser/InkParser_Expressions.cs new file mode 100644 index 000000000..106f8953e --- /dev/null +++ b/Assets/Ink/compiler/InkParser/InkParser_Expressions.cs @@ -0,0 +1,512 @@ +using System; +using Ink.Parsed; +using System.Collections.Generic; + +namespace Ink +{ + public partial class InkParser + { + protected class InfixOperator + { + public string type; + public int precedence; + public bool requireWhitespace; + + public InfixOperator(string type, int precedence, bool requireWhitespace) { + this.type = type; + this.precedence = precedence; + this.requireWhitespace = requireWhitespace; + } + + public override string ToString () + { + return type; + } + } + + protected Parsed.Object TempDeclarationOrAssignment() + { + Whitespace (); + + bool isNewDeclaration = ParseTempKeyword(); + + Whitespace (); + + Identifier varIdentifier = null; + if (isNewDeclaration) { + varIdentifier = (Identifier)Expect (IdentifierWithMetadata, "variable name"); + } else { + varIdentifier = Parse(IdentifierWithMetadata); + } + + if (varIdentifier == null) { + return null; + } + + Whitespace(); + + // += -= + bool isIncrement = ParseString ("+") != null; + bool isDecrement = ParseString ("-") != null; + if (isIncrement && isDecrement) Error ("Unexpected sequence '+-'"); + + if (ParseString ("=") == null) { + // Definitely in an assignment expression? + if (isNewDeclaration) Error ("Expected '='"); + return null; + } + + Expression assignedExpression = (Expression)Expect (Expression, "value expression to be assigned"); + + if (isIncrement || isDecrement) { + var result = new IncDecExpression (varIdentifier, assignedExpression, isIncrement); + return result; + } else { + var result = new VariableAssignment (varIdentifier, assignedExpression); + result.isNewTemporaryDeclaration = isNewDeclaration; + return result; + } + } + + protected void DisallowIncrement (Parsed.Object expr) + { + if (expr is Parsed.IncDecExpression) + Error ("Can't use increment/decrement here. It can only be used on a ~ line"); + } + + protected bool ParseTempKeyword() + { + var ruleId = BeginRule (); + + if (Parse (Identifier) == "temp") { + SucceedRule (ruleId); + return true; + } else { + FailRule (ruleId); + return false; + } + } + + protected Parsed.Return ReturnStatement() + { + Whitespace (); + + var returnOrDone = Parse(Identifier); + if (returnOrDone != "return") { + return null; + } + + Whitespace (); + + var expr = Parse(Expression); + + var returnObj = new Return (expr); + return returnObj; + } + + protected Expression Expression() { + return Expression(minimumPrecedence:0); + } + + // Pratt Parser + // aka "Top down operator precedence parser" + // http://journal.stuffwithstuff.com/2011/03/19/pratt-parsers-expression-parsing-made-easy/ + // Algorithm overview: + // The two types of precedence are handled in two different ways: + // ((((a . b) . c) . d) . e) #1 + // (a . (b . (c . (d . e)))) #2 + // Where #1 is automatically handled by successive loops within the main 'while' in this function, + // so long as continuing operators have lower (or equal) precedence (e.g. imagine some series of "*"s then "+" above. + // ...and #2 is handled by recursion of the right hand term in the binary expression parser. + // (see link for advice on how to extend for postfix and mixfix operators) + protected Expression Expression(int minimumPrecedence) + { + Whitespace (); + + // First parse a unary expression e.g. "-a" or parethensised "(1 + 2)" + var expr = ExpressionUnary (); + if (expr == null) { + return null; + } + + Whitespace (); + + // Attempt to parse (possibly multiple) continuing infix expressions (e.g. 1 + 2 + 3) + while(true) { + var ruleId = BeginRule (); + + // Operator + var infixOp = ParseInfixOperator (); + if (infixOp != null && infixOp.precedence > minimumPrecedence) { + + // Expect right hand side of operator + var expectationMessage = string.Format("right side of '{0}' expression", infixOp.type); + var multiaryExpr = Expect (() => ExpressionInfixRight (left: expr, op: infixOp), expectationMessage); + if (multiaryExpr == null) { + + // Fail for operator and right-hand side of multiary expression + FailRule (ruleId); + + return null; + } + + expr = SucceedRule(ruleId, multiaryExpr) as Parsed.Expression; + + continue; + } + + FailRule (ruleId); + break; + } + + Whitespace (); + + return expr; + } + + protected Expression ExpressionUnary() + { + // Divert target is a special case - it can't have any other operators + // applied to it, and we also want to check for it first so that we don't + // confuse "->" for subtraction. + var divertTarget = Parse (ExpressionDivertTarget); + if (divertTarget != null) { + return divertTarget; + } + + var prefixOp = (string) OneOf (String ("-"), String ("!")); + + // Don't parse like the string rules above, in case its actually + // a variable that simply starts with "not", e.g. "notable". + // This rule uses the Identifier rule, which will scan as much text + // as possible before returning. + if (prefixOp == null) { + prefixOp = Parse(ExpressionNot); + } + + Whitespace (); + + // - Since we allow numbers at the start of variable names, variable names are checked before literals + // - Function calls before variable names in case we see parentheses + var expr = OneOf (ExpressionList, ExpressionParen, ExpressionFunctionCall, ExpressionVariableName, ExpressionLiteral) as Expression; + + // Only recurse immediately if we have one of the (usually optional) unary ops + if (expr == null && prefixOp != null) { + expr = ExpressionUnary (); + } + + if (expr == null) + return null; + + if (prefixOp != null) { + expr = UnaryExpression.WithInner(expr, prefixOp); + } + + Whitespace (); + + var postfixOp = (string) OneOf (String ("++"), String ("--")); + if (postfixOp != null) { + bool isInc = postfixOp == "++"; + + if (!(expr is VariableReference)) { + Error ("can only increment and decrement variables, but saw '" + expr + "'"); + + // Drop down and succeed without the increment after reporting error + } else { + // TODO: Language Server - (Identifier combined into one vs. list of Identifiers) + var varRef = (VariableReference)expr; + expr = new IncDecExpression(varRef.identifier, isInc); + } + + } + + return expr; + } + + protected string ExpressionNot() + { + var id = Identifier (); + if (id == "not") { + return id; + } + + return null; + } + + protected Expression ExpressionLiteral() + { + return (Expression) OneOf (ExpressionFloat, ExpressionInt, ExpressionBool, ExpressionString); + } + + protected Expression ExpressionDivertTarget() + { + Whitespace (); + + var divert = Parse(SingleDivert); + if (divert == null) + return null; + + if (divert.isThread) + return null; + + Whitespace (); + + return new DivertTarget (divert); + } + + protected Number ExpressionInt() + { + int? intOrNull = ParseInt (); + if (intOrNull == null) { + return null; + } else { + return new Number (intOrNull.Value); + } + } + + protected Number ExpressionFloat() + { + float? floatOrNull = ParseFloat (); + if (floatOrNull == null) { + return null; + } else { + return new Number (floatOrNull.Value); + } + } + + protected StringExpression ExpressionString() + { + var openQuote = ParseString ("\""); + if (openQuote == null) + return null; + + // Set custom parser state flag so that within the text parser, + // it knows to treat the quote character (") as an end character + parsingStringExpression = true; + + List textAndLogic = Parse (MixedTextAndLogic); + + Expect (String ("\""), "close quote for string expression"); + + parsingStringExpression = false; + + if (textAndLogic == null) { + textAndLogic = new List (); + textAndLogic.Add (new Parsed.Text ("")); + } + + else if (textAndLogic.Exists (c => c is Divert)) + Error ("String expressions cannot contain diverts (->)"); + + return new StringExpression (textAndLogic); + } + + protected Number ExpressionBool() + { + var id = Parse(Identifier); + if (id == "true") { + return new Number (true); + } else if (id == "false") { + return new Number (false); + } + + return null; + } + + protected Expression ExpressionFunctionCall() + { + var iden = Parse(IdentifierWithMetadata); + if (iden == null) + return null; + + Whitespace (); + + var arguments = Parse(ExpressionFunctionCallArguments); + if (arguments == null) { + return null; + } + + return new FunctionCall(iden, arguments); + } + + protected List ExpressionFunctionCallArguments() + { + if (ParseString ("(") == null) + return null; + + // "Exclude" requires the rule to succeed, but causes actual comma string to be excluded from the list of results + ParseRule commas = Exclude (String (",")); + var arguments = Interleave(Expression, commas); + if (arguments == null) { + arguments = new List (); + } + + Whitespace (); + + Expect (String (")"), "closing ')' for function call"); + + return arguments; + } + + protected Expression ExpressionVariableName() + { + List path = Interleave (IdentifierWithMetadata, Exclude (Spaced (String (".")))); + + if (path == null || Story.IsReservedKeyword (path[0].name) ) + return null; + + return new VariableReference (path); + } + + protected Expression ExpressionParen() + { + if (ParseString ("(") == null) + return null; + + var innerExpr = Parse(Expression); + if (innerExpr == null) + return null; + + Whitespace (); + + Expect (String(")"), "closing parenthesis ')' for expression"); + + return innerExpr; + } + + protected Expression ExpressionInfixRight(Parsed.Expression left, InfixOperator op) + { + Whitespace (); + + var right = Parse(() => Expression (op.precedence)); + if (right) { + + // We assume that the character we use for the operator's type is the same + // as that used internally by e.g. Runtime.Expression.Add, Runtime.Expression.Multiply etc + var expr = new BinaryExpression (left, right, op.type); + return expr; + } + + return null; + + } + + private InfixOperator ParseInfixOperator() + { + foreach (var op in _binaryOperators) { + + int ruleId = BeginRule (); + + if (ParseString (op.type) != null) { + + if (op.requireWhitespace) { + if (Whitespace () == null) { + FailRule (ruleId); + continue; + } + } + + return (InfixOperator) SucceedRule(ruleId, op); + } + + FailRule (ruleId); + } + + return null; + } + + protected Parsed.List ExpressionList () + { + Whitespace (); + + if (ParseString ("(") == null) + return null; + + Whitespace (); + + // When list has: + // - 0 elements (null list) - this is okay, it's an empty list: "()" + // - 1 element - it could be confused for a single non-list related + // identifier expression in brackets, but this is a useless thing + // to do, so we reserve that syntax for a list with one item. + // - 2 or more elements - normal! + List memberNames = SeparatedList (ListMember, Spaced (String (","))); + + Whitespace (); + + // May have failed to parse the inner list - the parentheses may + // be for a normal expression + if (ParseString (")") == null) + return null; + + return new List (memberNames); + } + + protected Identifier ListMember () + { + Whitespace (); + + Identifier identifier = Parse (IdentifierWithMetadata); + if (identifier == null) + return null; + + var dot = ParseString ("."); + if (dot != null) { + Identifier identifier2 = Expect (IdentifierWithMetadata, "element name within the set " + identifier) as Identifier; + identifier.name = identifier.name + "." + identifier2?.name; + } + + Whitespace (); + + return identifier; + } + + void RegisterExpressionOperators() + { + _maxBinaryOpLength = 0; + _binaryOperators = new List (); + + // These will be tried in order, so we need "<=" before "<" + // for correctness + + RegisterBinaryOperator ("&&", precedence:1); + RegisterBinaryOperator ("||", precedence:1); + RegisterBinaryOperator ("and", precedence:1, requireWhitespace: true); + RegisterBinaryOperator ("or", precedence:1, requireWhitespace: true); + + RegisterBinaryOperator ("==", precedence:2); + RegisterBinaryOperator (">=", precedence:2); + RegisterBinaryOperator ("<=", precedence:2); + RegisterBinaryOperator ("<", precedence:2); + RegisterBinaryOperator (">", precedence:2); + RegisterBinaryOperator ("!=", precedence:2); + + // (apples, oranges) + cabbages has (oranges, cabbages) == true + RegisterBinaryOperator ("?", precedence: 3); + RegisterBinaryOperator ("has", precedence: 3, requireWhitespace:true); + RegisterBinaryOperator ("!?", precedence: 3); + RegisterBinaryOperator ("hasnt", precedence: 3, requireWhitespace: true); + RegisterBinaryOperator ("^", precedence: 3); + + RegisterBinaryOperator ("+", precedence:4); + RegisterBinaryOperator ("-", precedence:5); + RegisterBinaryOperator ("*", precedence:6); + RegisterBinaryOperator ("/", precedence:7); + + RegisterBinaryOperator ("%", precedence:8); + RegisterBinaryOperator ("mod", precedence:8, requireWhitespace:true); + + + } + + void RegisterBinaryOperator(string op, int precedence, bool requireWhitespace = false) + { + _binaryOperators.Add(new InfixOperator (op, precedence, requireWhitespace)); + _maxBinaryOpLength = Math.Max (_maxBinaryOpLength, op.Length); + } + + List _binaryOperators; + int _maxBinaryOpLength; + } +} + diff --git a/Assets/Ink/compiler/InkParser/InkParser_Expressions.cs.meta b/Assets/Ink/compiler/InkParser/InkParser_Expressions.cs.meta new file mode 100644 index 000000000..9c89b659b --- /dev/null +++ b/Assets/Ink/compiler/InkParser/InkParser_Expressions.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: 57a5e7edd2434bf45ae5f950d471bf1f +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/Assets/Ink/compiler/InkParser/InkParser_Include.cs b/Assets/Ink/compiler/InkParser/InkParser_Include.cs new file mode 100644 index 000000000..9490c2fca --- /dev/null +++ b/Assets/Ink/compiler/InkParser/InkParser_Include.cs @@ -0,0 +1,76 @@ +using Ink.Parsed; +using System.Collections.Generic; +using System.IO; + + +namespace Ink +{ + public partial class InkParser + { + protected object IncludeStatement() + { + Whitespace (); + + if (ParseString ("INCLUDE") == null) + return null; + + Whitespace (); + + var filename = (string) Expect(() => ParseUntilCharactersFromString ("\n\r"), "filename for include statement"); + filename = filename.TrimEnd (' ', '\t'); + + // Working directory should already have been set up relative to the root ink file. + var fullFilename = _rootParser._fileHandler.ResolveInkFilename (filename); + + if (FilenameIsAlreadyOpen (fullFilename)) { + Error ("Recursive INCLUDE detected: '" + fullFilename + "' is already open."); + ParseUntilCharactersFromString("\r\n"); + return new IncludedFile(null); + } else { + AddOpenFilename (fullFilename); + } + + Parsed.Story includedStory = null; + string includedString = null; + try { + includedString = _rootParser._fileHandler.LoadInkFileContents(fullFilename); + } + catch { + Error ("Failed to load: '"+filename+"'"); + } + + + if (includedString != null ) { + InkParser parser = new InkParser(includedString, filename, _externalErrorHandler, _rootParser); + includedStory = parser.Parse(); + } + + RemoveOpenFilename (fullFilename); + + // Return valid IncludedFile object even if there were errors when parsing. + // We don't want to attempt to re-parse the include line as something else, + // and we want to include the bits that *are* valid, so we don't generate + // more errors than necessary. + return new IncludedFile (includedStory); + } + + bool FilenameIsAlreadyOpen(string fullFilename) + { + return _rootParser._openFilenames.Contains (fullFilename); + } + + void AddOpenFilename(string fullFilename) + { + _rootParser._openFilenames.Add (fullFilename); + } + + void RemoveOpenFilename(string fullFilename) + { + _rootParser._openFilenames.Remove (fullFilename); + } + + InkParser _rootParser; + HashSet _openFilenames; + } +} + diff --git a/Assets/Ink/compiler/InkParser/InkParser_Include.cs.meta b/Assets/Ink/compiler/InkParser/InkParser_Include.cs.meta new file mode 100644 index 000000000..8a922cec7 --- /dev/null +++ b/Assets/Ink/compiler/InkParser/InkParser_Include.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: 0dfaba88b95d3704da16224671e24fdf +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/Assets/Ink/compiler/InkParser/InkParser_Knot.cs b/Assets/Ink/compiler/InkParser/InkParser_Knot.cs new file mode 100644 index 000000000..d1242437a --- /dev/null +++ b/Assets/Ink/compiler/InkParser/InkParser_Knot.cs @@ -0,0 +1,239 @@ +using System.Collections.Generic; +using Ink.Parsed; +using System.Linq; + +namespace Ink +{ + public partial class InkParser + { + protected class NameWithMetadata { + public string name; + public Runtime.DebugMetadata metadata; + } + + protected class FlowDecl + { + public Identifier name; + public List arguments; + public bool isFunction; + } + + protected Knot KnotDefinition() + { + var knotDecl = Parse(KnotDeclaration); + if (knotDecl == null) + return null; + + Expect(EndOfLine, "end of line after knot name definition", recoveryRule: SkipToNextLine); + + ParseRule innerKnotStatements = () => StatementsAtLevel (StatementLevel.Knot); + + var content = Expect (innerKnotStatements, "at least one line within the knot", recoveryRule: KnotStitchNoContentRecoveryRule) as List; + + return new Knot (knotDecl.name, content, knotDecl.arguments, knotDecl.isFunction); + } + + protected FlowDecl KnotDeclaration() + { + Whitespace (); + + if (KnotTitleEquals () == null) + return null; + + Whitespace (); + + + Identifier identifier = Parse(IdentifierWithMetadata); + Identifier knotName; + + bool isFunc = identifier?.name == "function"; + if (isFunc) { + Expect (Whitespace, "whitespace after the 'function' keyword"); + knotName = Parse(IdentifierWithMetadata); + } else { + knotName = identifier; + } + + if (knotName == null) { + Error ("Expected the name of the " + (isFunc ? "function" : "knot")); + knotName = new Identifier { name = "" }; // prevent later null ref + } + + Whitespace (); + + List parameterNames = Parse (BracketedKnotDeclArguments); + + Whitespace (); + + // Optional equals after name + Parse(KnotTitleEquals); + + return new FlowDecl () { name = knotName, arguments = parameterNames, isFunction = isFunc }; + } + + protected string KnotTitleEquals() + { + // 2+ "=" starts a knot + var multiEquals = ParseCharactersFromString ("="); + if (multiEquals == null || multiEquals.Length <= 1) { + return null; + } else { + return multiEquals; + } + } + + protected object StitchDefinition() + { + var decl = Parse(StitchDeclaration); + if (decl == null) + return null; + + Expect(EndOfLine, "end of line after stitch name", recoveryRule: SkipToNextLine); + + ParseRule innerStitchStatements = () => StatementsAtLevel (StatementLevel.Stitch); + + var content = Expect(innerStitchStatements, "at least one line within the stitch", recoveryRule: KnotStitchNoContentRecoveryRule) as List; + + return new Stitch (decl.name, content, decl.arguments, decl.isFunction ); + } + + protected FlowDecl StitchDeclaration() + { + Whitespace (); + + // Single "=" to define a stitch + if (ParseString ("=") == null) + return null; + + // If there's more than one "=", that's actually a knot definition (or divert), so this rule should fail + if (ParseString ("=") != null) + return null; + + Whitespace (); + + // Stitches aren't allowed to be functions, but we parse it anyway and report the error later + bool isFunc = ParseString ("function") != null; + if ( isFunc ) { + Whitespace (); + } + + Identifier stitchName = Parse(IdentifierWithMetadata); + if (stitchName == null) + return null; + + Whitespace (); + + List flowArgs = Parse(BracketedKnotDeclArguments); + + Whitespace (); + + return new FlowDecl () { name = stitchName, arguments = flowArgs, isFunction = isFunc }; + } + + + protected object KnotStitchNoContentRecoveryRule() + { + // Jump ahead to the next knot or the end of the file + ParseUntil (KnotDeclaration, new CharacterSet ("="), null); + + var recoveredFlowContent = new List(); + recoveredFlowContent.Add( new Parsed.Text("" ) ); + return recoveredFlowContent; + } + + protected List BracketedKnotDeclArguments() + { + if (ParseString ("(") == null) + return null; + + var flowArguments = Interleave(Spaced(FlowDeclArgument), Exclude (String(","))); + + Expect (String (")"), "closing ')' for parameter list"); + + // If no parameters, create an empty list so that this method is type safe and + // doesn't attempt to return the ParseSuccess object + if (flowArguments == null) { + flowArguments = new List (); + } + + return flowArguments; + } + + protected FlowBase.Argument FlowDeclArgument() + { + // Possible forms: + // name + // -> name (variable divert target argument + // ref name + // ref -> name (variable divert target by reference) + var firstIden = Parse(IdentifierWithMetadata); + Whitespace (); + var divertArrow = ParseDivertArrow (); + Whitespace (); + var secondIden = Parse(IdentifierWithMetadata); + + if (firstIden == null && secondIden == null) + return null; + + + var flowArg = new FlowBase.Argument (); + if (divertArrow != null) { + flowArg.isDivertTarget = true; + } + + // Passing by reference + if (firstIden != null && firstIden.name == "ref") { + + if (secondIden == null) { + Error ("Expected an parameter name after 'ref'"); + } + + flowArg.identifier = secondIden; + flowArg.isByReference = true; + } + + // Simple argument name + else { + + if (flowArg.isDivertTarget) { + flowArg.identifier = secondIden; + } else { + flowArg.identifier = firstIden; + } + + if (flowArg.identifier == null) { + Error ("Expected an parameter name"); + } + + flowArg.isByReference = false; + } + + return flowArg; + } + + protected ExternalDeclaration ExternalDeclaration() + { + Whitespace (); + + Identifier external = Parse(IdentifierWithMetadata); + if (external == null || external.name != "EXTERNAL") + return null; + + Whitespace (); + + var funcIdentifier = Expect(IdentifierWithMetadata, "name of external function") as Identifier ?? new Identifier(); + + Whitespace (); + + var parameterNames = Expect (BracketedKnotDeclArguments, "declaration of arguments for EXTERNAL, even if empty, i.e. 'EXTERNAL "+funcIdentifier+"()'") as List; + if (parameterNames == null) + parameterNames = new List (); + + var argNames = parameterNames.Select (arg => arg.identifier?.name).ToList(); + + return new ExternalDeclaration (funcIdentifier, argNames); + } + + } +} + diff --git a/Assets/Ink/compiler/InkParser/InkParser_Knot.cs.meta b/Assets/Ink/compiler/InkParser/InkParser_Knot.cs.meta new file mode 100644 index 000000000..00d0856bf --- /dev/null +++ b/Assets/Ink/compiler/InkParser/InkParser_Knot.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: f1cd2f87ba9fb344abd4140557a6b551 +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/Assets/Ink/compiler/InkParser/InkParser_Logic.cs b/Assets/Ink/compiler/InkParser/InkParser_Logic.cs new file mode 100644 index 000000000..44e8e0334 --- /dev/null +++ b/Assets/Ink/compiler/InkParser/InkParser_Logic.cs @@ -0,0 +1,421 @@ +using System.Collections.Generic; +using System.Linq; +using Ink.Parsed; + +namespace Ink +{ + public partial class InkParser + { + + protected Parsed.Object LogicLine() + { + Whitespace (); + + if (ParseString ("~") == null) { + return null; + } + + Whitespace (); + + // Some example lines we need to be able to distinguish between: + // ~ temp x = 5 -- var decl + assign + // ~ temp x -- var decl + // ~ x = 5 -- var assign + // ~ x -- expr (not var decl or assign) + // ~ f() -- expr + // We don't treat variable decl/assign as an expression since we don't want an assignment + // to have a return value, or to be used in compound expressions. + ParseRule afterTilda = () => OneOf (ReturnStatement, TempDeclarationOrAssignment, Expression); + + var result = Expect(afterTilda, "expression after '~'", recoveryRule: SkipToNextLine) as Parsed.Object; + + // Prevent further errors, already reported expected expression and have skipped to next line. + if (result == null) return new ContentList(); + + // Parse all expressions, but tell the writer off if they did something useless like: + // ~ 5 + 4 + // And even: + // ~ false && myFunction() + // ...since it's bad practice, and won't do what they expect if + // they're expecting C's lazy evaluation. + if (result is Expression && !(result is FunctionCall || result is IncDecExpression) ) { + + // TODO: Remove this specific error message when it has expired in usefulness + var varRef = result as VariableReference; + if (varRef && varRef.name == "include") { + Error ("'~ include' is no longer the correct syntax - please use 'INCLUDE your_filename.ink', without the tilda, and in block capitals."); + } + + else { + Error ("Logic following a '~' can't be that type of expression. It can only be something like:\n\t~ return\n\t~ var x = blah\n\t~ x++\n\t~ myFunction()"); + } + } + + // Line is pure function call? e.g. + // ~ f() + // Add extra pop to make sure we tidy up after ourselves. + // We no longer need anything on the evaluation stack. + var funCall = result as FunctionCall; + if (funCall) funCall.shouldPopReturnedValue = true; + + // If the expression contains a function call, then it could produce a text side effect, + // in which case it needs a newline on the end. e.g. + // ~ printMyName() + // ~ x = 1 + returnAValueAndAlsoPrintStuff() + // If no text gets printed, then the extra newline will have to be culled later. + // Multiple newlines on the output will be removed, so there will be no "leak" for + // long running calculations. It's disappointingly messy though :-/ + if (result.Find() != null ) { + result = new ContentList (result, new Parsed.Text ("\n")); + } + + Expect(EndOfLine, "end of line", recoveryRule: SkipToNextLine); + + return result as Parsed.Object; + } + + protected Parsed.Object VariableDeclaration() + { + Whitespace (); + + var id = Parse (Identifier); + if (id != "VAR") + return null; + + Whitespace (); + + var varName = Expect (IdentifierWithMetadata, "variable name") as Identifier; + + Whitespace (); + + Expect (String ("="), "the '=' for an assignment of a value, e.g. '= 5' (initial values are mandatory)"); + + Whitespace (); + + var definition = Expect (Expression, "initial value for "); + + var expr = definition as Parsed.Expression; + + if (expr) { + if (!(expr is Number || expr is StringExpression || expr is DivertTarget || expr is VariableReference || expr is List)) { + Error ("initial value for a variable must be a number, constant, list or divert target"); + } + + if (Parse (ListElementDefinitionSeparator) != null) + Error ("Unexpected ','. If you're trying to declare a new list, use the LIST keyword, not VAR"); + + // Ensure string expressions are simple + else if (expr is StringExpression) { + var strExpr = expr as StringExpression; + if (!strExpr.isSingleString) + Error ("Constant strings cannot contain any logic."); + } + + var result = new VariableAssignment (varName, expr); + result.isGlobalDeclaration = true; + return result; + } + + return null; + } + + protected Parsed.VariableAssignment ListDeclaration () + { + Whitespace (); + + var id = Parse (Identifier); + if (id != "LIST") + return null; + + Whitespace (); + + var varName = Expect (IdentifierWithMetadata, "list name") as Identifier; + + Whitespace (); + + Expect (String ("="), "the '=' for an assignment of the list definition"); + + Whitespace (); + + var definition = Expect (ListDefinition, "list item names") as ListDefinition; + + if (definition) { + + definition.identifier = varName; + + return new VariableAssignment (varName, definition); + } + + return null; + } + + protected Parsed.ListDefinition ListDefinition () + { + AnyWhitespace (); + + var allElements = SeparatedList (ListElementDefinition, ListElementDefinitionSeparator); + if (allElements == null) + return null; + + return new ListDefinition (allElements); + } + + protected string ListElementDefinitionSeparator () + { + AnyWhitespace (); + + if (ParseString (",") == null) return null; + + AnyWhitespace (); + + return ","; + } + + protected Parsed.ListElementDefinition ListElementDefinition () + { + var inInitialList = ParseString ("(") != null; + var needsToCloseParen = inInitialList; + + Whitespace (); + + var name = Parse (IdentifierWithMetadata); + if (name == null) + return null; + + Whitespace (); + + if (inInitialList) { + if (ParseString (")") != null) { + needsToCloseParen = false; + Whitespace (); + } + } + + int? elementValue = null; + if (ParseString ("=") != null) { + + Whitespace (); + + var elementValueNum = Expect (ExpressionInt, "value to be assigned to list item") as Number; + if (elementValueNum != null) { + elementValue = (int) elementValueNum.value; + } + + if (needsToCloseParen) { + Whitespace (); + + if (ParseString (")") != null) + needsToCloseParen = false; + } + } + + if (needsToCloseParen) + Error("Expected closing ')'"); + + return new ListElementDefinition (name, inInitialList, elementValue); + } + + protected Parsed.Object ConstDeclaration() + { + Whitespace (); + + var id = Parse (Identifier); + if (id != "CONST") + return null; + + Whitespace (); + + var varName = Expect (IdentifierWithMetadata, "constant name") as Identifier; + + Whitespace (); + + Expect (String ("="), "the '=' for an assignment of a value, e.g. '= 5' (initial values are mandatory)"); + + Whitespace (); + + var expr = Expect (Expression, "initial value for ") as Parsed.Expression; + if (!(expr is Number || expr is DivertTarget || expr is StringExpression)) { + Error ("initial value for a constant must be a number or divert target"); + } + + // Ensure string expressions are simple + else if (expr is StringExpression) { + var strExpr = expr as StringExpression; + if (!strExpr.isSingleString) + Error ("Constant strings cannot contain any logic."); + } + + + var result = new ConstantDeclaration (varName, expr); + return result; + } + + protected Parsed.Object InlineLogicOrGlue() + { + return (Parsed.Object) OneOf (InlineLogic, Glue); + } + + protected Parsed.Glue Glue() + { + // Don't want to parse whitespace, since it might be important + // surrounding the glue. + var glueStr = ParseString("<>"); + if (glueStr != null) { + return new Parsed.Glue (new Runtime.Glue ()); + } else { + return null; + } + } + + protected Parsed.Object InlineLogic() + { + if ( ParseString ("{") == null) { + return null; + } + + Whitespace (); + + var logic = (Parsed.Object) Expect(InnerLogic, "some kind of logic, conditional or sequence within braces: { ... }"); + if (logic == null) + return null; + + DisallowIncrement (logic); + + ContentList contentList = logic as ContentList; + if (!contentList) { + contentList = new ContentList (logic); + } + + Whitespace (); + + Expect (String("}"), "closing brace '}' for inline logic"); + + return contentList; + } + + protected Parsed.Object InnerLogic() + { + Whitespace (); + + // Explicitly try the combinations of inner logic + // that could potentially have conflicts first. + + // Explicit sequence annotation? + SequenceType? explicitSeqType = (SequenceType?) ParseObject(SequenceTypeAnnotation); + if (explicitSeqType != null) { + var contentLists = (List) Expect(InnerSequenceObjects, "sequence elements (for cycle/stoping etc)"); + if (contentLists == null) + return null; + return new Sequence (contentLists, (SequenceType) explicitSeqType); + } + + // Conditional with expression? + var initialQueryExpression = Parse(ConditionExpression); + if (initialQueryExpression) { + var conditional = (Conditional) Expect(() => InnerConditionalContent (initialQueryExpression), "conditional content following query"); + return conditional; + } + + // Now try to evaluate each of the "full" rules in turn + ParseRule[] rules = { + + // Conditional still necessary, since you can have a multi-line conditional + // without an initial query expression: + // { + // - true: this is true + // - false: this is false + // } + InnerConditionalContent, + InnerSequence, + InnerExpression, + }; + + // Adapted from "OneOf" structuring rule except that in + // order for the rule to succeed, it has to maximally + // cover the entire string within the { }. Used to + // differentiate between: + // {myVar} -- Expression (try first) + // {my content is jolly} -- sequence with single element + foreach (ParseRule rule in rules) { + int ruleId = BeginRule (); + + Parsed.Object result = ParseObject(rule) as Parsed.Object; + if (result) { + + // Not yet at end? + if (Peek (Spaced (String ("}"))) == null) + FailRule (ruleId); + + // Full parse of content within braces + else + return (Parsed.Object) SucceedRule (ruleId, result); + + } else { + FailRule (ruleId); + } + } + + return null; + } + + protected Parsed.Object InnerExpression() + { + var expr = Parse(Expression); + if (expr) { + expr.outputWhenComplete = true; + } + return expr; + } + + protected Identifier IdentifierWithMetadata() + { + var id = Identifier(); + if( id == null ) return null; + + // InkParser.RuleDidSucceed will add DebugMetadata + return new Identifier { name = id, debugMetadata = null }; + } + + // Note: we allow identifiers that start with a number, + // but not if they *only* comprise numbers + protected string Identifier() + { + // Parse remaining characters (if any) + var name = ParseCharactersFromCharSet (identifierCharSet); + if (name == null) + return null; + + // Reject if it's just a number + bool isNumberCharsOnly = true; + foreach (var c in name) { + if ( !(c >= '0' && c <= '9') ) { + isNumberCharsOnly = false; + break; + } + } + if (isNumberCharsOnly) { + return null; + } + + return name; + } + + CharacterSet identifierCharSet { + get { + if (_identifierCharSet == null) { + (_identifierCharSet = new CharacterSet ()) + .AddRange ('A', 'Z') + .AddRange ('a', 'z') + .AddRange ('0', '9') + .Add ('_'); + // Enable non-ASCII characters for story identifiers. + ExtendIdentifierCharacterRanges (_identifierCharSet); + } + return _identifierCharSet; + } + } + + private CharacterSet _identifierCharSet; + } +} + diff --git a/Assets/Ink/compiler/InkParser/InkParser_Logic.cs.meta b/Assets/Ink/compiler/InkParser/InkParser_Logic.cs.meta new file mode 100644 index 000000000..75be609f4 --- /dev/null +++ b/Assets/Ink/compiler/InkParser/InkParser_Logic.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: 9ae50990c607b634e96436c994039bc0 +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/Assets/Ink/compiler/InkParser/InkParser_Sequences.cs b/Assets/Ink/compiler/InkParser/InkParser_Sequences.cs new file mode 100644 index 000000000..b9156e861 --- /dev/null +++ b/Assets/Ink/compiler/InkParser/InkParser_Sequences.cs @@ -0,0 +1,231 @@ +using System.Collections.Generic; +using System.Linq; +using Ink.Parsed; + +namespace Ink +{ + public partial class InkParser + { + protected Sequence InnerSequence() + { + Whitespace (); + + // Default sequence type + SequenceType seqType = SequenceType.Stopping; + + // Optional explicit sequence type + SequenceType? parsedSeqType = (SequenceType?) Parse(SequenceTypeAnnotation); + if (parsedSeqType != null) + seqType = parsedSeqType.Value; + + var contentLists = Parse(InnerSequenceObjects); + if (contentLists == null || contentLists.Count <= 1) { + return null; + } + + return new Sequence (contentLists, seqType); + } + + protected object SequenceTypeAnnotation() + { + var annotation = (SequenceType?) Parse(SequenceTypeSymbolAnnotation); + + if(annotation == null) + annotation = (SequenceType?) Parse(SequenceTypeWordAnnotation); + + if (annotation == null) + return null; + + switch (annotation.Value) + { + case SequenceType.Once: + case SequenceType.Cycle: + case SequenceType.Stopping: + case SequenceType.Shuffle: + case (SequenceType.Shuffle | SequenceType.Stopping): + case (SequenceType.Shuffle | SequenceType.Once): + break; + + default: + Error("Sequence type combination not supported: " + annotation.Value); + return SequenceType.Stopping; + } + + return annotation; + } + + protected object SequenceTypeSymbolAnnotation() + { + if(_sequenceTypeSymbols == null ) + _sequenceTypeSymbols = new CharacterSet("!&~$ "); + + var sequenceType = (SequenceType)0; + var sequenceAnnotations = ParseCharactersFromCharSet(_sequenceTypeSymbols); + if (sequenceAnnotations == null) + return null; + + foreach(char symbolChar in sequenceAnnotations) { + switch(symbolChar) { + case '!': sequenceType |= SequenceType.Once; break; + case '&': sequenceType |= SequenceType.Cycle; break; + case '~': sequenceType |= SequenceType.Shuffle; break; + case '$': sequenceType |= SequenceType.Stopping; break; + } + } + + if (sequenceType == (SequenceType)0) + return null; + + return sequenceType; + } + + CharacterSet _sequenceTypeSymbols = new CharacterSet("!&~$"); + + protected object SequenceTypeWordAnnotation() + { + var sequenceTypes = Interleave(SequenceTypeSingleWord, Exclude(Whitespace)); + if (sequenceTypes == null || sequenceTypes.Count == 0) + return null; + + if (ParseString (":") == null) + return null; + + var combinedSequenceType = (SequenceType)0; + foreach(var seqType in sequenceTypes) { + combinedSequenceType |= seqType.Value; + } + + return combinedSequenceType; + } + + protected object SequenceTypeSingleWord() + { + SequenceType? seqType = null; + + var word = Parse(IdentifierWithMetadata); + if (word != null) + { + switch (word.name) + { + case "once": + seqType = SequenceType.Once; + break; + case "cycle": + seqType = SequenceType.Cycle; + break; + case "shuffle": + seqType = SequenceType.Shuffle; + break; + case "stopping": + seqType = SequenceType.Stopping; + break; + } + } + + if (seqType == null) + return null; + + return seqType; + } + + protected List InnerSequenceObjects() + { + var multiline = Parse(Newline) != null; + + List result = null; + if (multiline) { + result = Parse(InnerMultilineSequenceObjects); + } else { + result = Parse(InnerInlineSequenceObjects); + } + + return result; + } + + protected List InnerInlineSequenceObjects() + { + var interleavedContentAndPipes = Interleave (Optional (MixedTextAndLogic), String ("|"), flatten:false); + if (interleavedContentAndPipes == null) + return null; + + var result = new List (); + + // The content and pipes won't necessarily be perfectly interleaved in the sense that + // the content can be missing, but in that case it's intended that there's blank content. + bool justHadContent = false; + foreach (object contentOrPipe in interleavedContentAndPipes) { + + // Pipe/separator + if (contentOrPipe as string == "|") { + + // Expected content, saw pipe - need blank content now + if (!justHadContent) { + + // Add blank content + result.Add (new ContentList ()); + } + + justHadContent = false; + } + + // Real content + else { + + var content = contentOrPipe as List; + if (content == null) { + Error ("Expected content, but got " + contentOrPipe + " (this is an ink compiler bug!)"); + } else { + result.Add (new ContentList (content)); + } + + justHadContent = true; + } + } + + // Ended in a pipe? Need to insert final blank content + if (!justHadContent) + result.Add (new ContentList ()); + + return result; + } + + protected List InnerMultilineSequenceObjects() + { + MultilineWhitespace (); + + var contentLists = OneOrMore (SingleMultilineSequenceElement); + if (contentLists == null) + return null; + + return contentLists.Cast ().ToList(); + } + + protected ContentList SingleMultilineSequenceElement() + { + Whitespace (); + + // Make sure we're not accidentally parsing a divert + if (ParseString ("->") != null) + return null; + + if (ParseString ("-") == null) + return null; + + Whitespace (); + + + List content = StatementsAtLevel (StatementLevel.InnerBlock); + + if (content == null) + MultilineWhitespace (); + + // Add newline at the start of each branch + else { + content.Insert (0, new Parsed.Text ("\n")); + } + + return new ContentList (content); + } + } +} + diff --git a/Assets/Ink/compiler/InkParser/InkParser_Sequences.cs.meta b/Assets/Ink/compiler/InkParser/InkParser_Sequences.cs.meta new file mode 100644 index 000000000..6d95be193 --- /dev/null +++ b/Assets/Ink/compiler/InkParser/InkParser_Sequences.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: 26cfb99fad990de4883b6437e5d2d6a2 +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/Assets/Ink/compiler/InkParser/InkParser_Statements.cs b/Assets/Ink/compiler/InkParser/InkParser_Statements.cs new file mode 100644 index 000000000..0b622f20c --- /dev/null +++ b/Assets/Ink/compiler/InkParser/InkParser_Statements.cs @@ -0,0 +1,163 @@ +using System; +using System.Collections.Generic; +using System.Linq; +using Ink.Parsed; + +namespace Ink +{ + public partial class InkParser + { + protected enum StatementLevel + { + InnerBlock, + Stitch, + Knot, + Top + } + + protected List StatementsAtLevel(StatementLevel level) + { + // Check for error: Should not be allowed gather dashes within an inner block + if (level == StatementLevel.InnerBlock) { + object badGatherDashCount = Parse(GatherDashes); + if (badGatherDashCount != null) { + Error ("You can't use a gather (the dashes) within the { curly braces } context. For multi-line sequences and conditions, you should only use one dash."); + } + } + + return Interleave( + Optional (MultilineWhitespace), + () => StatementAtLevel (level), + untilTerminator: () => StatementsBreakForLevel(level)); + } + + protected object StatementAtLevel(StatementLevel level) + { + ParseRule[] rulesAtLevel = _statementRulesAtLevel[(int)level]; + + var statement = OneOf (rulesAtLevel); + + // For some statements, allow them to parse, but create errors, since + // writers may think they can use the statement, so it's useful to have + // the error message. + if (level == StatementLevel.Top) { + if( statement is Return ) + Error ("should not have return statement outside of a knot"); + } + + return statement; + } + + protected object StatementsBreakForLevel(StatementLevel level) + { + Whitespace (); + + ParseRule[] breakRules = _statementBreakRulesAtLevel[(int)level]; + + var breakRuleResult = OneOf (breakRules); + if (breakRuleResult == null) + return null; + + return breakRuleResult; + } + + void GenerateStatementLevelRules() + { + var levels = Enum.GetValues (typeof(StatementLevel)).Cast ().ToList(); + + _statementRulesAtLevel = new ParseRule[levels.Count][]; + _statementBreakRulesAtLevel = new ParseRule[levels.Count][]; + + foreach (var level in levels) { + List rulesAtLevel = new List (); + List breakingRules = new List (); + + // Diverts can go anywhere + rulesAtLevel.Add(Line(MultiDivert)); + + // Knots can only be parsed at Top/Global scope + if (level >= StatementLevel.Top) + rulesAtLevel.Add (KnotDefinition); + + rulesAtLevel.Add(Line(Choice)); + + rulesAtLevel.Add(Line(AuthorWarning)); + + // Gather lines would be confused with multi-line block separators, like + // within a multi-line if statement + if (level > StatementLevel.InnerBlock) { + rulesAtLevel.Add (Gather); + } + + // Stitches (and gathers) can (currently) only go in Knots and top level + if (level >= StatementLevel.Knot) { + rulesAtLevel.Add (StitchDefinition); + } + + // Global variable declarations can go anywhere + rulesAtLevel.Add(Line(ListDeclaration)); + rulesAtLevel.Add(Line(VariableDeclaration)); + rulesAtLevel.Add(Line(ConstDeclaration)); + rulesAtLevel.Add(Line(ExternalDeclaration)); + + // Global include can go anywhere + rulesAtLevel.Add(Line(IncludeStatement)); + + // Normal logic / text can go anywhere + rulesAtLevel.Add(LogicLine); + rulesAtLevel.Add(LineOfMixedTextAndLogic); + + // -------- + // Breaking rules + + // Break current knot with a new knot + if (level <= StatementLevel.Knot) { + breakingRules.Add (KnotDeclaration); + } + + // Break current stitch with a new stitch + if (level <= StatementLevel.Stitch) { + breakingRules.Add (StitchDeclaration); + } + + // Breaking an inner block (like a multi-line condition statement) + if (level <= StatementLevel.InnerBlock) { + breakingRules.Add (ParseDashNotArrow); + breakingRules.Add (String ("}")); + } + + _statementRulesAtLevel [(int)level] = rulesAtLevel.ToArray (); + _statementBreakRulesAtLevel [(int)level] = breakingRules.ToArray (); + } + } + + protected object SkipToNextLine() + { + ParseUntilCharactersFromString ("\n\r"); + ParseNewline (); + return ParseSuccess; + } + + // Modifier to turn a rule into one that expects a newline on the end. + // e.g. anywhere you can use "MixedTextAndLogic" as a rule, you can use + // "Line(MixedTextAndLogic)" to specify that it expects a newline afterwards. + protected ParseRule Line(ParseRule inlineRule) + { + return () => { + object result = ParseObject(inlineRule); + if (result == null) { + return null; + } + + Expect(EndOfLine, "end of line", recoveryRule: SkipToNextLine); + + return result; + }; + } + + + ParseRule[][] _statementRulesAtLevel; + ParseRule[][] _statementBreakRulesAtLevel; + } +} + diff --git a/Assets/Ink/compiler/InkParser/InkParser_Statements.cs.meta b/Assets/Ink/compiler/InkParser/InkParser_Statements.cs.meta new file mode 100644 index 000000000..e9bc576a5 --- /dev/null +++ b/Assets/Ink/compiler/InkParser/InkParser_Statements.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: fc56a52fd65ef9746ad8c635b665054a +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/Assets/Ink/compiler/InkParser/InkParser_Tags.cs b/Assets/Ink/compiler/InkParser/InkParser_Tags.cs new file mode 100644 index 000000000..7f8d12a61 --- /dev/null +++ b/Assets/Ink/compiler/InkParser/InkParser_Tags.cs @@ -0,0 +1,50 @@ +using System.Text; +using System.Collections.Generic; +using System.Linq; + +namespace Ink +{ + public partial class InkParser + { + protected Parsed.Tag Tag () + { + Whitespace (); + + if (ParseString ("#") == null) + return null; + + Whitespace (); + + var sb = new StringBuilder (); + do { + // Read up to another #, end of input or newline + string tagText = ParseUntilCharactersFromCharSet (_endOfTagCharSet); + sb.Append (tagText); + + // Escape character + if (ParseString ("\\") != null) { + char c = ParseSingleCharacter (); + if( c != (char)0 ) sb.Append(c); + continue; + } + + break; + } while ( true ); + + var fullTagText = sb.ToString ().Trim(); + + return new Parsed.Tag (new Runtime.Tag (fullTagText)); + } + + protected List Tags () + { + var tags = OneOrMore (Tag); + if (tags == null) return null; + + return tags.Cast().ToList(); + } + + CharacterSet _endOfTagCharSet = new CharacterSet ("#\n\r\\"); + } +} + diff --git a/Assets/Ink/compiler/InkParser/InkParser_Tags.cs.meta b/Assets/Ink/compiler/InkParser/InkParser_Tags.cs.meta new file mode 100644 index 000000000..9769b4be6 --- /dev/null +++ b/Assets/Ink/compiler/InkParser/InkParser_Tags.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: 6c24086827a204b418bba51e98525480 +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/Assets/Ink/compiler/InkParser/InkParser_Whitespace.cs b/Assets/Ink/compiler/InkParser/InkParser_Whitespace.cs new file mode 100644 index 000000000..96031e7a0 --- /dev/null +++ b/Assets/Ink/compiler/InkParser/InkParser_Whitespace.cs @@ -0,0 +1,112 @@ +using System.Collections.Generic; + +namespace Ink +{ + public partial class InkParser + { + // Handles both newline and endOfFile + protected object EndOfLine() + { + return OneOf(Newline, EndOfFile); + } + + // Allow whitespace before the actual newline + protected object Newline() + { + Whitespace(); + + bool gotNewline = ParseNewline () != null; + + // Optional \r, definite \n to support Windows (\r\n) and Mac/Unix (\n) + + if( !gotNewline ) { + return null; + } else { + return ParseSuccess; + } + } + + protected object EndOfFile() + { + Whitespace(); + + if (!endOfInput) + return null; + + return ParseSuccess; + } + + + // General purpose space, returns N-count newlines (fails if no newlines) + protected object MultilineWhitespace() + { + List newlines = OneOrMore(Newline); + if (newlines == null) + return null; + + // Use content field of Token to say how many newlines there were + // (in most circumstances it's unimportant) + int numNewlines = newlines.Count; + if (numNewlines >= 1) { + return ParseSuccess; + } else { + return null; + } + } + + protected object Whitespace() + { + if( ParseCharactersFromCharSet(_inlineWhitespaceChars) != null ) { + return ParseSuccess; + } + + return null; + } + + protected ParseRule Spaced(ParseRule rule) + { + return () => { + + Whitespace (); + + var result = ParseObject(rule); + if (result == null) { + return null; + } + + Whitespace (); + + return result; + }; + } + + protected object AnyWhitespace () + { + bool anyWhitespace = false; + while (OneOf (Whitespace, MultilineWhitespace) != null) { + anyWhitespace = true; + } + return anyWhitespace ? ParseSuccess : null; + } + + protected ParseRule MultiSpaced (ParseRule rule) + { + return () => { + + AnyWhitespace (); + + var result = ParseObject (rule); + if (result == null) { + return null; + } + + AnyWhitespace (); + + return result; + }; + } + + private CharacterSet _inlineWhitespaceChars = new CharacterSet(" \t"); + } +} + diff --git a/Assets/Ink/compiler/InkParser/InkParser_Whitespace.cs.meta b/Assets/Ink/compiler/InkParser/InkParser_Whitespace.cs.meta new file mode 100644 index 000000000..a6b91740f --- /dev/null +++ b/Assets/Ink/compiler/InkParser/InkParser_Whitespace.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: 970c5ebcd2579d647a72e5949b3a266b +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/Assets/Ink/compiler/InkStringConversionExtensions.cs b/Assets/Ink/compiler/InkStringConversionExtensions.cs new file mode 100644 index 000000000..47f07b815 --- /dev/null +++ b/Assets/Ink/compiler/InkStringConversionExtensions.cs @@ -0,0 +1,18 @@ +using System.Collections.Generic; + +namespace Ink +{ + public static class InkStringConversionExtensions + { + public static string[] ToStringsArray(this List list) { + int count = list.Count; + var strings = new string[count]; + + for(int i = 0; i < count; i++) { + strings[i] = list[i].ToString(); + } + + return strings; + } + } +} diff --git a/Assets/Ink/compiler/InkStringConversionExtensions.cs.meta b/Assets/Ink/compiler/InkStringConversionExtensions.cs.meta new file mode 100644 index 000000000..f5ac12697 --- /dev/null +++ b/Assets/Ink/compiler/InkStringConversionExtensions.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: 6a20342fd5a7af246b0d8486a9a242c5 +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/Assets/Ink/compiler/ParsedHierarchy.meta b/Assets/Ink/compiler/ParsedHierarchy.meta new file mode 100644 index 000000000..9a1a08eb2 --- /dev/null +++ b/Assets/Ink/compiler/ParsedHierarchy.meta @@ -0,0 +1,8 @@ +fileFormatVersion: 2 +guid: 3bbf30acdd181d1418263a86b8d4de36 +folderAsset: yes +DefaultImporter: + externalObjects: {} + userData: + assetBundleName: + assetBundleVariant: diff --git a/Assets/Ink/compiler/ParsedHierarchy/AuthorWarning.cs b/Assets/Ink/compiler/ParsedHierarchy/AuthorWarning.cs new file mode 100644 index 000000000..e61805b0d --- /dev/null +++ b/Assets/Ink/compiler/ParsedHierarchy/AuthorWarning.cs @@ -0,0 +1,20 @@ + +namespace Ink.Parsed +{ + public class AuthorWarning : Parsed.Object + { + public string warningMessage; + + public AuthorWarning(string message) + { + warningMessage = message; + } + + public override Runtime.Object GenerateRuntimeObject () + { + Warning (warningMessage); + return null; + } + } +} + diff --git a/Assets/Ink/compiler/ParsedHierarchy/AuthorWarning.cs.meta b/Assets/Ink/compiler/ParsedHierarchy/AuthorWarning.cs.meta new file mode 100644 index 000000000..aa3eb2f21 --- /dev/null +++ b/Assets/Ink/compiler/ParsedHierarchy/AuthorWarning.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: 41069d3b98c64f44180e0569b3bab64c +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/Assets/Ink/compiler/ParsedHierarchy/Choice.cs b/Assets/Ink/compiler/ParsedHierarchy/Choice.cs new file mode 100644 index 000000000..4b2934fbc --- /dev/null +++ b/Assets/Ink/compiler/ParsedHierarchy/Choice.cs @@ -0,0 +1,290 @@ +using System.Text; + +namespace Ink.Parsed +{ + public class Choice : Parsed.Object, IWeavePoint, INamedContent + { + public ContentList startContent { get; protected set; } + public ContentList choiceOnlyContent { get; protected set; } + public ContentList innerContent { get; protected set; } + + public string name + { + get { return identifier?.name; } + } + public Identifier identifier { get; set; } + + public Expression condition { + get { + return _condition; + } + set { + _condition = value; + if( _condition ) + AddContent (_condition); + } + } + + public bool onceOnly { get; set; } + public bool isInvisibleDefault { get; set; } + + public int indentationDepth { get; set; }// = 1; + public bool hasWeaveStyleInlineBrackets { get; set; } + + // Required for IWeavePoint interface + // Choice's target container. Used by weave to append any extra + // nested weave content into. + public Runtime.Container runtimeContainer { get { return _innerContentContainer; } } + + + public Runtime.Container innerContentContainer { + get { + return _innerContentContainer; + } + } + + public override Runtime.Container containerForCounting { + get { + return _innerContentContainer; + } + } + + // Override runtimePath to point to the Choice's target content (after it's chosen), + // as opposed to the default implementation which would point to the choice itself + // (or it's outer container), which is what runtimeObject is. + public override Runtime.Path runtimePath + { + get { + return _innerContentContainer.path; + } + } + + public Choice (ContentList startContent, ContentList choiceOnlyContent, ContentList innerContent) + { + this.startContent = startContent; + this.choiceOnlyContent = choiceOnlyContent; + this.innerContent = innerContent; + this.indentationDepth = 1; + + if (startContent) + AddContent (this.startContent); + + if (choiceOnlyContent) + AddContent (this.choiceOnlyContent); + + if( innerContent ) + AddContent (this.innerContent); + + this.onceOnly = true; // default + } + + + public override Runtime.Object GenerateRuntimeObject () + { + _outerContainer = new Runtime.Container (); + + // Content names for different types of choice: + // * start content [choice only content] inner content + // * start content -> divert + // * start content + // * [choice only content] + + // Hmm, this structure has become slightly insane! + // + // [ + // EvalStart + // assign $r = $r1 -- return target = return label 1 + // BeginString + // -> s + // [(r1)] -- return label 1 (after start content) + // EndString + // BeginString + // ... choice only content + // EndEval + // Condition expression + // choice: -> "c-0" + // (s) = [ + // start content + // -> r -- goto return label 1 or 2 + // ] + // ] + // + // in parent's container: (the inner content for the choice) + // + // (c-0) = [ + // EvalStart + // assign $r = $r2 -- return target = return label 2 + // EndEval + // -> s + // [(r2)] -- return label 1 (after start content) + // inner content + // ] + // + + _runtimeChoice = new Runtime.ChoicePoint (onceOnly); + _runtimeChoice.isInvisibleDefault = this.isInvisibleDefault; + + if (startContent || choiceOnlyContent || condition) { + _outerContainer.AddContent (Runtime.ControlCommand.EvalStart ()); + } + + // Start content is put into a named container that's referenced both + // when displaying the choice initially, and when generating the text + // when the choice is chosen. + if (startContent) { + + // Generate start content and return + // - We can't use a function since it uses a call stack element, which would + // put temporary values out of scope. Instead we manually divert around. + // - $r is a variable divert target contains the return point + _returnToR1 = new Runtime.DivertTargetValue (); + _outerContainer.AddContent (_returnToR1); + var varAssign = new Runtime.VariableAssignment ("$r", true); + _outerContainer.AddContent (varAssign); + + // Mark the start of the choice text generation, so that the runtime + // knows where to rewind to to extract the content from the output stream. + _outerContainer.AddContent (Runtime.ControlCommand.BeginString ()); + + _divertToStartContentOuter = new Runtime.Divert (); + _outerContainer.AddContent (_divertToStartContentOuter); + + // Start content itself in a named container + _startContentRuntimeContainer = startContent.GenerateRuntimeObject () as Runtime.Container; + _startContentRuntimeContainer.name = "s"; + + // Effectively, the "return" statement - return to the point specified by $r + var varDivert = new Runtime.Divert (); + varDivert.variableDivertName = "$r"; + _startContentRuntimeContainer.AddContent (varDivert); + + // Add the container + _outerContainer.AddToNamedContentOnly (_startContentRuntimeContainer); + + // This is the label to return to + _r1Label = new Runtime.Container (); + _r1Label.name = "$r1"; + _outerContainer.AddContent (_r1Label); + + _outerContainer.AddContent (Runtime.ControlCommand.EndString ()); + + _runtimeChoice.hasStartContent = true; + } + + // Choice only content - mark the start, then generate it directly into the outer container + if (choiceOnlyContent) { + _outerContainer.AddContent (Runtime.ControlCommand.BeginString ()); + + var choiceOnlyRuntimeContent = choiceOnlyContent.GenerateRuntimeObject () as Runtime.Container; + _outerContainer.AddContentsOfContainer (choiceOnlyRuntimeContent); + + _outerContainer.AddContent (Runtime.ControlCommand.EndString ()); + + _runtimeChoice.hasChoiceOnlyContent = true; + } + + // Generate any condition for this choice + if (condition) { + condition.GenerateIntoContainer (_outerContainer); + _runtimeChoice.hasCondition = true; + } + + if (startContent || choiceOnlyContent || condition) { + _outerContainer.AddContent (Runtime.ControlCommand.EvalEnd ()); + } + + // Add choice itself + _outerContainer.AddContent (_runtimeChoice); + + // Container that choice points to for when it's chosen + _innerContentContainer = new Runtime.Container (); + + // Repeat start content by diverting to its container + if (startContent) { + + // Set the return point when jumping back into the start content + // - In this case, it's the $r2 point, within the choice content "c". + _returnToR2 = new Runtime.DivertTargetValue (); + _innerContentContainer.AddContent (Runtime.ControlCommand.EvalStart ()); + _innerContentContainer.AddContent (_returnToR2); + _innerContentContainer.AddContent (Runtime.ControlCommand.EvalEnd ()); + var varAssign = new Runtime.VariableAssignment ("$r", true); + _innerContentContainer.AddContent (varAssign); + + // Main divert into start content + _divertToStartContentInner = new Runtime.Divert (); + _innerContentContainer.AddContent (_divertToStartContentInner); + + // Define label to return to + _r2Label = new Runtime.Container (); + _r2Label.name = "$r2"; + _innerContentContainer.AddContent (_r2Label); + } + + // Choice's own inner content + if (innerContent) { + var innerChoiceOnlyContent = innerContent.GenerateRuntimeObject () as Runtime.Container; + _innerContentContainer.AddContentsOfContainer (innerChoiceOnlyContent); + } + + if (this.story.countAllVisits) { + _innerContentContainer.visitsShouldBeCounted = true; + } + + _innerContentContainer.countingAtStartOnly = true; + + return _outerContainer; + } + + public override void ResolveReferences(Story context) + { + // Weave style choice - target own content container + if (_innerContentContainer) { + _runtimeChoice.pathOnChoice = _innerContentContainer.path; + + if (onceOnly) + _innerContentContainer.visitsShouldBeCounted = true; + } + + if (_returnToR1) + _returnToR1.targetPath = _r1Label.path; + + if (_returnToR2) + _returnToR2.targetPath = _r2Label.path; + + if( _divertToStartContentOuter ) + _divertToStartContentOuter.targetPath = _startContentRuntimeContainer.path; + + if( _divertToStartContentInner ) + _divertToStartContentInner.targetPath = _startContentRuntimeContainer.path; + + base.ResolveReferences (context); + + if( identifier != null && identifier.name.Length > 0 ) + context.CheckForNamingCollisions (this, identifier, Story.SymbolType.SubFlowAndWeave); + } + + public override string ToString () + { + if (choiceOnlyContent != null) { + return string.Format ("* {0}[{1}]...", startContent, choiceOnlyContent); + } else { + return string.Format ("* {0}...", startContent); + } + } + + Runtime.ChoicePoint _runtimeChoice; + Runtime.Container _innerContentContainer; + Runtime.Container _outerContainer; + Runtime.Container _startContentRuntimeContainer; + Runtime.Divert _divertToStartContentOuter; + Runtime.Divert _divertToStartContentInner; + Runtime.Container _r1Label; + Runtime.Container _r2Label; + Runtime.DivertTargetValue _returnToR1; + Runtime.DivertTargetValue _returnToR2; + Expression _condition; + } + +} + diff --git a/Assets/Ink/compiler/ParsedHierarchy/Choice.cs.meta b/Assets/Ink/compiler/ParsedHierarchy/Choice.cs.meta new file mode 100644 index 000000000..f9b23d00e --- /dev/null +++ b/Assets/Ink/compiler/ParsedHierarchy/Choice.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: 9c1c1a3eaa8256641a14fc27fca420d8 +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/Assets/Ink/compiler/ParsedHierarchy/Conditional.cs b/Assets/Ink/compiler/ParsedHierarchy/Conditional.cs new file mode 100644 index 000000000..2343df2ea --- /dev/null +++ b/Assets/Ink/compiler/ParsedHierarchy/Conditional.cs @@ -0,0 +1,71 @@ +using System.Collections.Generic; +using System.Linq; +using Ink.Runtime; + +namespace Ink.Parsed +{ + public class Conditional : Parsed.Object + { + public Expression initialCondition { get; private set; } + public List branches { get; private set; } + + public Conditional (Expression condition, List branches) + { + this.initialCondition = condition; + if (this.initialCondition) { + AddContent (condition); + } + + this.branches = branches; + if (this.branches != null) { + AddContent (this.branches.Cast ().ToList ()); + } + + } + + public override Runtime.Object GenerateRuntimeObject () + { + var container = new Runtime.Container (); + + // Initial condition + if (this.initialCondition) { + container.AddContent (initialCondition.runtimeObject); + } + + // Individual branches + foreach (var branch in branches) { + var branchContainer = (Container) branch.runtimeObject; + container.AddContent (branchContainer); + } + + // If it's a switch-like conditional, each branch + // will have a "duplicate" operation for the original + // switched value. If there's no final else clause + // and we fall all the way through, we need to clean up. + // (An else clause doesn't dup but it *does* pop) + if (this.initialCondition != null && branches [0].ownExpression != null && !branches [branches.Count - 1].isElse) { + container.AddContent (Runtime.ControlCommand.PopEvaluatedValue ()); + } + + // Target for branches to rejoin to + _reJoinTarget = Runtime.ControlCommand.NoOp (); + container.AddContent (_reJoinTarget); + + return container; + } + + public override void ResolveReferences (Story context) + { + var pathToReJoin = _reJoinTarget.path; + + foreach (var branch in branches) { + branch.returnDivert.targetPath = pathToReJoin; + } + + base.ResolveReferences (context); + } + + Runtime.ControlCommand _reJoinTarget; + } +} + diff --git a/Assets/Ink/compiler/ParsedHierarchy/Conditional.cs.meta b/Assets/Ink/compiler/ParsedHierarchy/Conditional.cs.meta new file mode 100644 index 000000000..2575d9444 --- /dev/null +++ b/Assets/Ink/compiler/ParsedHierarchy/Conditional.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: 0563dff86f800ea4b9ee7f4474aadca4 +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/Assets/Ink/compiler/ParsedHierarchy/ConditionalSingleBranch.cs b/Assets/Ink/compiler/ParsedHierarchy/ConditionalSingleBranch.cs new file mode 100644 index 000000000..3f6663687 --- /dev/null +++ b/Assets/Ink/compiler/ParsedHierarchy/ConditionalSingleBranch.cs @@ -0,0 +1,158 @@ + +using System.Collections.Generic; + +namespace Ink.Parsed +{ + public class ConditionalSingleBranch : Parsed.Object + { + // bool condition, e.g.: + // { 5 == 4: + // - the true branch + // - the false branch + // } + public bool isTrueBranch { get; set; } + + // When each branch has its own expression like a switch statement, + // this is non-null. e.g. + // { x: + // - 4: the value of x is four (ownExpression is the value 4) + // - 3: the value of x is three + // } + public Expression ownExpression { + get { + return _ownExpression; + } + set { + _ownExpression = value; + if (_ownExpression) { + AddContent (_ownExpression); + } + } + } + + // In the above example, match equality of x with 4 for the first branch. + // This is as opposed to simply evaluating boolean equality for each branch, + // example when shouldMatchEqualtity is FALSE: + // { + // 3 > 2: This will happen + // 2 > 3: This won't happen + // } + public bool matchingEquality { get; set; } + + public bool isElse { get; set; } + + public bool isInline { get; set; } + + public Runtime.Divert returnDivert { get; protected set; } + + public ConditionalSingleBranch (List content) + { + // Branches are allowed to be empty + if (content != null) { + _innerWeave = new Weave (content); + AddContent (_innerWeave); + } + } + + // Runtime content can be summarised as follows: + // - Evaluate an expression if necessary to branch on + // - Branch to a named container if true + // - Divert back to main flow + // (owner Conditional is in control of this target point) + public override Runtime.Object GenerateRuntimeObject () + { + // Check for common mistake, of putting "else:" instead of "- else:" + if (_innerWeave) { + foreach (var c in _innerWeave.content) { + var text = c as Parsed.Text; + if (text) { + // Don't need to trim at the start since the parser handles that already + if (text.text.StartsWith ("else:")) { + Warning ("Saw the text 'else:' which is being treated as content. Did you mean '- else:'?", text); + } + } + } + } + + var container = new Runtime.Container (); + + // Are we testing against a condition that's used for more than just this + // branch? If so, the first thing we need to do is replicate the value that's + // on the evaluation stack so that we don't fully consume it, in case other + // branches need to use it. + bool duplicatesStackValue = matchingEquality && !isElse; + if ( duplicatesStackValue ) + container.AddContent (Runtime.ControlCommand.Duplicate ()); + + _conditionalDivert = new Runtime.Divert (); + + // else clause is unconditional catch-all, otherwise the divert is conditional + _conditionalDivert.isConditional = !isElse; + + // Need extra evaluation? + if( !isTrueBranch && !isElse ) { + + bool needsEval = ownExpression != null; + if( needsEval ) + container.AddContent (Runtime.ControlCommand.EvalStart ()); + + if (ownExpression) + ownExpression.GenerateIntoContainer (container); + + // Uses existing duplicated value + if (matchingEquality) + container.AddContent (Runtime.NativeFunctionCall.CallWithName ("==")); + + if( needsEval ) + container.AddContent (Runtime.ControlCommand.EvalEnd ()); + } + + // Will pop from stack if conditional + container.AddContent (_conditionalDivert); + + _contentContainer = GenerateRuntimeForContent (); + _contentContainer.name = "b"; + + // Multi-line conditionals get a newline at the start of each branch + // (as opposed to the start of the multi-line conditional since the condition + // may evaluate to false.) + if (!isInline) { + _contentContainer.InsertContent (new Runtime.StringValue ("\n"), 0); + } + + if( duplicatesStackValue || (isElse && matchingEquality) ) + _contentContainer.InsertContent (Runtime.ControlCommand.PopEvaluatedValue (), 0); + + container.AddToNamedContentOnly (_contentContainer); + + returnDivert = new Runtime.Divert (); + _contentContainer.AddContent (returnDivert); + + return container; + } + + Runtime.Container GenerateRuntimeForContent() + { + // Empty branch - create empty container + if (_innerWeave == null) { + return new Runtime.Container (); + } + + return _innerWeave.rootContainer; + } + + public override void ResolveReferences (Story context) + { + _conditionalDivert.targetPath = _contentContainer.path; + + base.ResolveReferences (context); + } + + Runtime.Container _contentContainer; + Runtime.Divert _conditionalDivert; + Expression _ownExpression; + + Weave _innerWeave; + } +} + diff --git a/Assets/Ink/compiler/ParsedHierarchy/ConditionalSingleBranch.cs.meta b/Assets/Ink/compiler/ParsedHierarchy/ConditionalSingleBranch.cs.meta new file mode 100644 index 000000000..b2ebb5588 --- /dev/null +++ b/Assets/Ink/compiler/ParsedHierarchy/ConditionalSingleBranch.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: 80b8abff03bc7fa43b6cba87d29c2b40 +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/Assets/Ink/compiler/ParsedHierarchy/ConstantDeclaration.cs b/Assets/Ink/compiler/ParsedHierarchy/ConstantDeclaration.cs new file mode 100644 index 000000000..3852bcdb7 --- /dev/null +++ b/Assets/Ink/compiler/ParsedHierarchy/ConstantDeclaration.cs @@ -0,0 +1,46 @@ +//using System.Collections.Generic; + +namespace Ink.Parsed +{ + public class ConstantDeclaration : Parsed.Object + { + public string constantName + { + get { return constantIdentifier?.name; } + } + public Identifier constantIdentifier { get; protected set; } + public Expression expression { get; protected set; } + + public ConstantDeclaration (Identifier name, Expression assignedExpression) + { + this.constantIdentifier = name; + + // Defensive programming in case parsing of assignedExpression failed + if( assignedExpression ) + this.expression = AddContent(assignedExpression); + } + + public override Runtime.Object GenerateRuntimeObject () + { + // Global declarations don't generate actual procedural + // runtime objects, but instead add a global variable to the story itself. + // The story then initialises them all in one go at the start of the game. + return null; + } + + public override void ResolveReferences (Story context) + { + base.ResolveReferences (context); + + context.CheckForNamingCollisions (this, constantIdentifier, Story.SymbolType.Var); + } + + public override string typeName { + get { + return "Constant"; + } + } + + } +} + diff --git a/Assets/Ink/compiler/ParsedHierarchy/ConstantDeclaration.cs.meta b/Assets/Ink/compiler/ParsedHierarchy/ConstantDeclaration.cs.meta new file mode 100644 index 000000000..d5e384ad1 --- /dev/null +++ b/Assets/Ink/compiler/ParsedHierarchy/ConstantDeclaration.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: 4055e73c795d4754f8482b4764a15249 +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/Assets/Ink/compiler/ParsedHierarchy/ContentList.cs b/Assets/Ink/compiler/ParsedHierarchy/ContentList.cs new file mode 100644 index 000000000..737875ebb --- /dev/null +++ b/Assets/Ink/compiler/ParsedHierarchy/ContentList.cs @@ -0,0 +1,78 @@ +using System.Collections.Generic; +using System.Text; + +namespace Ink.Parsed +{ + public class ContentList : Parsed.Object + { + public bool dontFlatten { get; set; } + + public Runtime.Container runtimeContainer { + get { + return (Runtime.Container) this.runtimeObject; + } + } + + public ContentList (List objects) + { + if( objects != null ) + AddContent (objects); + } + + public ContentList (params Parsed.Object[] objects) + { + if (objects != null) { + var objList = new List (objects); + AddContent (objList); + } + } + + public ContentList() + { + } + + public void TrimTrailingWhitespace() + { + for (int i = this.content.Count - 1; i >= 0; --i) { + var text = this.content [i] as Text; + if (text == null) + break; + + text.text = text.text.TrimEnd (' ', '\t'); + if (text.text.Length == 0) + this.content.RemoveAt (i); + else + break; + } + } + + public override Runtime.Object GenerateRuntimeObject () + { + var container = new Runtime.Container (); + if (content != null) { + foreach (var obj in content) { + var contentObjRuntime = obj.runtimeObject; + + // Some objects (e.g. author warnings) don't generate runtime objects + if( contentObjRuntime ) + container.AddContent (contentObjRuntime); + } + } + + if( dontFlatten ) + story.DontFlattenContainer (container); + + return container; + } + + public override string ToString () + { + var sb = new StringBuilder (); + sb.Append ("ContentList("); + sb.Append(string.Join (", ", content.ToStringsArray())); + sb.Append (")"); + return sb.ToString (); + } + } +} + diff --git a/Assets/Ink/compiler/ParsedHierarchy/ContentList.cs.meta b/Assets/Ink/compiler/ParsedHierarchy/ContentList.cs.meta new file mode 100644 index 000000000..17fbcf1c1 --- /dev/null +++ b/Assets/Ink/compiler/ParsedHierarchy/ContentList.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: 20b4723f51ab8dc4fa31e9d29d92f1d1 +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/Assets/Ink/compiler/ParsedHierarchy/Divert.cs b/Assets/Ink/compiler/ParsedHierarchy/Divert.cs new file mode 100644 index 000000000..f87ce8dff --- /dev/null +++ b/Assets/Ink/compiler/ParsedHierarchy/Divert.cs @@ -0,0 +1,403 @@ +using System.Collections.Generic; +using System.Linq; + +namespace Ink.Parsed +{ + public class Divert : Parsed.Object + { + public Parsed.Path target { get; protected set; } + public Parsed.Object targetContent { get; protected set; } + public List arguments { get; protected set; } + public Runtime.Divert runtimeDivert { get; protected set; } + public bool isFunctionCall { get; set; } + public bool isEmpty { get; set; } + public bool isTunnel { get; set; } + public bool isThread { get; set; } + public bool isEnd { + get { + return target != null && target.dotSeparatedComponents == "END"; + } + } + public bool isDone { + get { + return target != null && target.dotSeparatedComponents == "DONE"; + } + } + + public Divert (Parsed.Path target, List arguments = null) + { + this.target = target; + this.arguments = arguments; + + if (arguments != null) { + AddContent (arguments.Cast ().ToList ()); + } + } + + public Divert (Parsed.Object targetContent) + { + this.targetContent = targetContent; + } + + public override Runtime.Object GenerateRuntimeObject () + { + // End = end flow immediately + // Done = return from thread or instruct the flow that it's safe to exit + if (isEnd) { + return Runtime.ControlCommand.End (); + } + if (isDone) { + return Runtime.ControlCommand.Done (); + } + + runtimeDivert = new Runtime.Divert (); + + // Normally we resolve the target content during the + // Resolve phase, since we expect all runtime objects to + // be available in order to find the final runtime path for + // the destination. However, we need to resolve the target + // (albeit without the runtime target) early so that + // we can get information about the arguments - whether + // they're by reference - since it affects the code we + // generate here. + ResolveTargetContent (); + + + CheckArgumentValidity (); + + // Passing arguments to the knot + bool requiresArgCodeGen = arguments != null && arguments.Count > 0; + if ( requiresArgCodeGen || isFunctionCall || isTunnel || isThread ) { + + var container = new Runtime.Container (); + + // Generate code for argument evaluation + // This argument generation is coded defensively - it should + // attempt to generate the code for all the parameters, even if + // they don't match the expected arguments. This is so that the + // parameter objects themselves are generated correctly and don't + // get into a state of attempting to resolve references etc + // without being generated. + if (requiresArgCodeGen) { + + // Function calls already in an evaluation context + if (!isFunctionCall) { + container.AddContent (Runtime.ControlCommand.EvalStart()); + } + + List targetArguments = null; + if( targetContent ) + targetArguments = (targetContent as FlowBase).arguments; + + for (var i = 0; i < arguments.Count; ++i) { + Expression argToPass = arguments [i]; + FlowBase.Argument argExpected = null; + if( targetArguments != null && i < targetArguments.Count ) + argExpected = targetArguments [i]; + + // Pass by reference: argument needs to be a variable reference + if (argExpected != null && argExpected.isByReference) { + + var varRef = argToPass as VariableReference; + if (varRef == null) { + Error ("Expected variable name to pass by reference to 'ref " + argExpected.identifier + "' but saw " + argToPass.ToString ()); + break; + } + + // Check that we're not attempting to pass a read count by reference + var targetPath = new Path(varRef.pathIdentifiers); + Parsed.Object targetForCount = targetPath.ResolveFromContext (this); + if (targetForCount != null) { + Error ("can't pass a read count by reference. '" + targetPath.dotSeparatedComponents+"' is a knot/stitch/label, but '"+target.dotSeparatedComponents+"' requires the name of a VAR to be passed."); + break; + } + + var varPointer = new Runtime.VariablePointerValue (varRef.name); + container.AddContent (varPointer); + } + + // Normal value being passed: evaluate it as normal + else { + argToPass.GenerateIntoContainer (container); + } + } + + // Function calls were already in an evaluation context + if (!isFunctionCall) { + container.AddContent (Runtime.ControlCommand.EvalEnd()); + } + } + + + // Starting a thread? A bit like a push to the call stack below... but not. + // It sort of puts the call stack on a thread stack (argh!) - forks the full flow. + if (isThread) { + container.AddContent(Runtime.ControlCommand.StartThread()); + } + + // If this divert is a function call, tunnel, we push to the call stack + // so we can return again + else if (isFunctionCall || isTunnel) { + runtimeDivert.pushesToStack = true; + runtimeDivert.stackPushType = isFunctionCall ? Runtime.PushPopType.Function : Runtime.PushPopType.Tunnel; + } + + // Jump into the "function" (knot/stitch) + container.AddContent (runtimeDivert); + + return container; + } + + // Simple divert + else { + return runtimeDivert; + } + } + + + // When the divert is to a target that's actually a variable name + // rather than an explicit knot/stitch name, try interpretting it + // as such by getting the variable name. + public string PathAsVariableName() + { + return target.firstComponent; + } + + + void ResolveTargetContent() + { + if (isEmpty || isEnd) { + return; + } + + if (targetContent == null) { + + // Is target of this divert a variable name that will be de-referenced + // at runtime? If so, there won't be any further reference resolution + // we can do at this point. + var variableTargetName = PathAsVariableName (); + if (variableTargetName != null) { + var flowBaseScope = ClosestFlowBase (); + var resolveResult = flowBaseScope.ResolveVariableWithName (variableTargetName, fromNode: this); + if (resolveResult.found) { + + // Make sure that the flow was typed correctly, given that we know that this + // is meant to be a divert target + if (resolveResult.isArgument) { + var argument = resolveResult.ownerFlow.arguments.Where (a => a.identifier.name == variableTargetName).First(); + if ( !argument.isDivertTarget ) { + Error ("Since '" + argument.identifier + "' is used as a variable divert target (on "+this.debugMetadata+"), it should be marked as: -> " + argument.identifier, resolveResult.ownerFlow); + } + } + + runtimeDivert.variableDivertName = variableTargetName; + return; + + } + } + + targetContent = target.ResolveFromContext (this); + } + } + + public override void ResolveReferences(Story context) + { + if (isEmpty || isEnd || isDone) { + return; + } + + if (targetContent) { + runtimeDivert.targetPath = targetContent.runtimePath; + } + + // Resolve children (the arguments) + base.ResolveReferences (context); + + // May be null if it's a built in function (e.g. TURNS_SINCE) + // or if it's a variable target. + var targetFlow = targetContent as FlowBase; + if (targetFlow) { + if (!targetFlow.isFunction && this.isFunctionCall) { + base.Error (targetFlow.identifier + " hasn't been marked as a function, but it's being called as one. Do you need to delcare the knot as '== function " + targetFlow.identifier + " =='?"); + } else if (targetFlow.isFunction && !this.isFunctionCall && !(this.parent is DivertTarget)) { + base.Error (targetFlow.identifier + " can't be diverted to. It can only be called as a function since it's been marked as such: '" + targetFlow.identifier + "(...)'"); + } + } + + // Check validity of target content + bool targetWasFound = targetContent != null; + bool isBuiltIn = false; + bool isExternal = false; + + if (target.numberOfComponents == 1 ) { + + // BuiltIn means TURNS_SINCE, CHOICE_COUNT, RANDOM or SEED_RANDOM + isBuiltIn = FunctionCall.IsBuiltIn (target.firstComponent); + + // Client-bound function? + isExternal = context.IsExternal (target.firstComponent); + + if (isBuiltIn || isExternal) { + if (!isFunctionCall) { + base.Error (target.firstComponent + " must be called as a function: ~ " + target.firstComponent + "()"); + } + if (isExternal) { + runtimeDivert.isExternal = true; + if( arguments != null ) + runtimeDivert.externalArgs = arguments.Count; + runtimeDivert.pushesToStack = false; + runtimeDivert.targetPath = new Runtime.Path (this.target.firstComponent); + CheckExternalArgumentValidity (context); + } + return; + } + } + + // Variable target? + if (runtimeDivert.variableDivertName != null) { + return; + } + + if( !targetWasFound && !isBuiltIn && !isExternal ) + Error ("target not found: '" + target + "'"); + } + + // Returns false if there's an error + void CheckArgumentValidity() + { + if (isEmpty) + return; + + // Argument passing: Check for errors in number of arguments + var numArgs = 0; + if (arguments != null && arguments.Count > 0) + numArgs = arguments.Count; + + // Missing content? + // Can't check arguments properly. It'll be due to some + // other error though, so although there's a problem and + // we report false, we don't need to report a specific error. + // It may also be because it's a valid call to an external + // function, that we check at the resolve stage. + if (targetContent == null) { + return; + } + + FlowBase targetFlow = targetContent as FlowBase; + + // No error, crikey! + if (numArgs == 0 && (targetFlow == null || !targetFlow.hasParameters)) { + return; + } + + if (targetFlow == null && numArgs > 0) { + Error ("target needs to be a knot or stitch in order to pass arguments"); + return; + } + + if (targetFlow.arguments == null && numArgs > 0) { + Error ("target (" + targetFlow.name + ") doesn't take parameters"); + return; + } + + if( this.parent is DivertTarget ) { + if (numArgs > 0) + Error ("can't store arguments in a divert target variable"); + return; + } + + var paramCount = targetFlow.arguments.Count; + if (paramCount != numArgs) { + + string butClause; + if (numArgs == 0) { + butClause = "but there weren't any passed to it"; + } else if (numArgs < paramCount) { + butClause = "but only got " + numArgs; + } else { + butClause = "but got " + numArgs; + } + Error ("to '" + targetFlow.identifier + "' requires " + paramCount + " arguments, "+butClause); + return; + } + + // Light type-checking for divert target arguments + for (int i = 0; i < paramCount; ++i) { + FlowBase.Argument flowArg = targetFlow.arguments [i]; + Parsed.Expression divArgExpr = arguments [i]; + + // Expecting a divert target as an argument, let's do some basic type checking + if (flowArg.isDivertTarget) { + + // Not passing a divert target or any kind of variable reference? + var varRef = divArgExpr as VariableReference; + if (!(divArgExpr is DivertTarget) && varRef == null ) { + Error ("Target '" + targetFlow.identifier + "' expects a divert target for the parameter named -> " + flowArg.identifier + " but saw " + divArgExpr, divArgExpr); + } + + // Passing 'a' instead of '-> a'? + // i.e. read count instead of divert target + else if (varRef != null) { + + // Unfortunately have to manually resolve here since we're still in code gen + var knotCountPath = new Path(varRef.pathIdentifiers); + Parsed.Object targetForCount = knotCountPath.ResolveFromContext (varRef); + if (targetForCount != null) { + Error ("Passing read count of '" + knotCountPath.dotSeparatedComponents + "' instead of a divert target. You probably meant '" + knotCountPath + "'"); + } + } + } + } + + if (targetFlow == null) { + Error ("Can't call as a function or with arguments unless it's a knot or stitch"); + return; + } + + return; + } + + void CheckExternalArgumentValidity(Story context) + { + string externalName = target.firstComponent; + ExternalDeclaration external = null; + var found = context.externals.TryGetValue(externalName, out external); + System.Diagnostics.Debug.Assert (found, "external not found"); + + int externalArgCount = external.argumentNames.Count; + int ownArgCount = 0; + if (arguments != null) { + ownArgCount = arguments.Count; + } + + if (ownArgCount != externalArgCount) { + Error ("incorrect number of arguments sent to external function '" + externalName + "'. Expected " + externalArgCount + " but got " + ownArgCount); + } + } + + public override void Error (string message, Object source = null, bool isWarning = false) + { + // Could be getting an error from a nested Divert + if (source != this && source) { + base.Error (message, source); + return; + } + + if (isFunctionCall) { + base.Error ("Function call " + message, source, isWarning); + } else { + base.Error ("Divert " + message, source, isWarning); + } + } + + public override string ToString () + { + if (target != null) + return target.ToString (); + else + return "-> "; + } + + } +} + diff --git a/Assets/Ink/compiler/ParsedHierarchy/Divert.cs.meta b/Assets/Ink/compiler/ParsedHierarchy/Divert.cs.meta new file mode 100644 index 000000000..d2f245e2d --- /dev/null +++ b/Assets/Ink/compiler/ParsedHierarchy/Divert.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: bbf7175e88d0a3445a925a32e0edcb84 +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/Assets/Ink/compiler/ParsedHierarchy/DivertTarget.cs b/Assets/Ink/compiler/ParsedHierarchy/DivertTarget.cs new file mode 100644 index 000000000..c1223a496 --- /dev/null +++ b/Assets/Ink/compiler/ParsedHierarchy/DivertTarget.cs @@ -0,0 +1,172 @@ + +namespace Ink.Parsed +{ + public class DivertTarget : Expression + { + public Divert divert; + + public DivertTarget (Divert divert) + { + this.divert = AddContent(divert); + } + + public override void GenerateIntoContainer (Runtime.Container container) + { + divert.GenerateRuntimeObject(); + + _runtimeDivert = (Runtime.Divert) divert.runtimeDivert; + _runtimeDivertTargetValue = new Runtime.DivertTargetValue (); + + container.AddContent (_runtimeDivertTargetValue); + } + + public override void ResolveReferences (Story context) + { + base.ResolveReferences (context); + + if( divert.isDone || divert.isEnd ) + { + Error("Can't Can't use -> DONE or -> END as variable divert targets", this); + return; + } + + Parsed.Object usageContext = this; + while (usageContext && usageContext is Expression) { + + bool badUsage = false; + bool foundUsage = false; + + var usageParent = usageContext.parent; + if (usageParent is BinaryExpression) { + + // Only allowed to compare for equality + + var binaryExprParent = usageParent as BinaryExpression; + if (binaryExprParent.opName != "==" && binaryExprParent.opName != "!=") { + badUsage = true; + } else { + if (!(binaryExprParent.leftExpression is DivertTarget || binaryExprParent.leftExpression is VariableReference)) { + badUsage = true; + } + if (!(binaryExprParent.rightExpression is DivertTarget || binaryExprParent.rightExpression is VariableReference)) { + badUsage = true; + } + } + foundUsage = true; + } + else if( usageParent is FunctionCall ) { + var funcCall = usageParent as FunctionCall; + if( !funcCall.isTurnsSince && !funcCall.isReadCount ) { + badUsage = true; + } + foundUsage = true; + } + else if (usageParent is Expression) { + badUsage = true; + foundUsage = true; + } + else if (usageParent is MultipleConditionExpression) { + badUsage = true; + foundUsage = true; + } else if (usageParent is Choice && ((Choice)usageParent).condition == usageContext) { + badUsage = true; + foundUsage = true; + } else if (usageParent is Conditional || usageParent is ConditionalSingleBranch) { + badUsage = true; + foundUsage = true; + } + + if (badUsage) { + Error ("Can't use a divert target like that. Did you intend to call '" + divert.target + "' as a function: likeThis(), or check the read count: likeThis, with no arrows?", this); + } + + if (foundUsage) + break; + + usageContext = usageParent; + } + + // Example ink for this case: + // + // VAR x = -> blah + // + // ...which means that "blah" is expected to be a literal stitch target rather + // than a variable name. We can't really intelligently recover from this (e.g. if blah happens to + // contain a divert target itself) since really we should be generating a variable reference + // rather than a concrete DivertTarget, so we list it as an error. + if (_runtimeDivert.hasVariableTarget) + Error ("Since '"+divert.target.dotSeparatedComponents+"' is a variable, it shouldn't be preceded by '->' here."); + + // Main resolve + _runtimeDivertTargetValue.targetPath = _runtimeDivert.targetPath; + + // Tell hard coded (yet variable) divert targets that they also need to be counted + // TODO: Only detect DivertTargets that are values rather than being used directly for + // read or turn counts. Should be able to detect this by looking for other uses of containerForCounting + var targetContent = this.divert.targetContent; + if (targetContent != null ) { + var target = targetContent.containerForCounting; + if (target != null) + { + // Purpose is known: used directly in TURNS_SINCE(-> divTarg) + var parentFunc = this.parent as FunctionCall; + if( parentFunc && parentFunc.isTurnsSince ) { + target.turnIndexShouldBeCounted = true; + } + + // Unknown purpose, count everything + else { + target.visitsShouldBeCounted = true; + target.turnIndexShouldBeCounted = true; + } + + } + + // Unfortunately not possible: + // https://github.com/inkle/ink/issues/538 + // + // VAR func = -> double + // + // === function double(ref x) + // ~ x = x * 2 + // + // Because when generating the parameters for a function + // to be called, it needs to know ahead of time when + // compiling whether to pass a variable reference or value. + // + var targetFlow = (targetContent as FlowBase); + if (targetFlow != null && targetFlow.arguments != null) + { + foreach(var arg in targetFlow.arguments) { + if(arg.isByReference) + { + Error("Can't store a divert target to a knot or function that has by-reference arguments ('"+targetFlow.identifier+"' has 'ref "+arg.identifier+"')."); + } + } + } + } + } + + // Equals override necessary in order to check for CONST multiple definition equality + public override bool Equals (object obj) + { + var otherDivTarget = obj as DivertTarget; + if (otherDivTarget == null) return false; + + var targetStr = this.divert.target.dotSeparatedComponents; + var otherTargetStr = otherDivTarget.divert.target.dotSeparatedComponents; + + return targetStr.Equals (otherTargetStr); + } + + public override int GetHashCode () + { + var targetStr = this.divert.target.dotSeparatedComponents; + return targetStr.GetHashCode (); + } + + Runtime.DivertTargetValue _runtimeDivertTargetValue; + Runtime.Divert _runtimeDivert; + } +} + diff --git a/Assets/Ink/compiler/ParsedHierarchy/DivertTarget.cs.meta b/Assets/Ink/compiler/ParsedHierarchy/DivertTarget.cs.meta new file mode 100644 index 000000000..e674cdfe9 --- /dev/null +++ b/Assets/Ink/compiler/ParsedHierarchy/DivertTarget.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: a98ed61e93bc3bf4f9134b63d9e4461a +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/Assets/Ink/compiler/ParsedHierarchy/Expression.cs b/Assets/Ink/compiler/ParsedHierarchy/Expression.cs new file mode 100644 index 000000000..ad752021d --- /dev/null +++ b/Assets/Ink/compiler/ParsedHierarchy/Expression.cs @@ -0,0 +1,307 @@ +using System.Collections.Generic; +using System.Linq; + +namespace Ink.Parsed +{ + public abstract class Expression : Parsed.Object + { + public bool outputWhenComplete { get; set; } + + public override Runtime.Object GenerateRuntimeObject () + { + var container = new Runtime.Container (); + + // Tell Runtime to start evaluating the following content as an expression + container.AddContent (Runtime.ControlCommand.EvalStart()); + + GenerateIntoContainer (container); + + // Tell Runtime to output the result of the expression evaluation to the output stream + if (outputWhenComplete) { + container.AddContent (Runtime.ControlCommand.EvalOutput()); + } + + // Tell Runtime to stop evaluating the content as an expression + container.AddContent (Runtime.ControlCommand.EvalEnd()); + + return container; + } + + // When generating the value of a constant expression, + // we can't just keep generating the same constant expression into + // different places where the constant value is referenced, since then + // the same runtime objects would be used in multiple places, which + // is impossible since each runtime object should have one parent. + // Instead, we generate a prototype of the runtime object(s), then + // copy them each time they're used. + public void GenerateConstantIntoContainer(Runtime.Container container) + { + if( _prototypeRuntimeConstantExpression == null ) { + _prototypeRuntimeConstantExpression = new Runtime.Container (); + GenerateIntoContainer (_prototypeRuntimeConstantExpression); + } + + foreach (var runtimeObj in _prototypeRuntimeConstantExpression.content) { + container.AddContent (runtimeObj.Copy()); + } + } + + public abstract void GenerateIntoContainer (Runtime.Container container); + + Runtime.Container _prototypeRuntimeConstantExpression; + } + + public class BinaryExpression : Expression + { + public Expression leftExpression; + public Expression rightExpression; + public string opName; + + public BinaryExpression(Expression left, Expression right, string opName) + { + leftExpression = AddContent(left); + rightExpression = AddContent(right); + this.opName = opName; + } + + public override void GenerateIntoContainer(Runtime.Container container) + { + leftExpression.GenerateIntoContainer (container); + rightExpression.GenerateIntoContainer (container); + + opName = NativeNameForOp (opName); + + container.AddContent(Runtime.NativeFunctionCall.CallWithName(opName)); + } + + public override void ResolveReferences (Story context) + { + base.ResolveReferences (context); + + // Check for the following case: + // + // (not A) ? B + // + // Since this easy to accidentally do: + // + // not A ? B + // + // when you intend: + // + // not (A ? B) + if (NativeNameForOp (opName) == "?") { + var leftUnary = leftExpression as UnaryExpression; + if( leftUnary != null && (leftUnary.op == "not" || leftUnary.op == "!") ) { + Error ("Using 'not' or '!' here negates '"+leftUnary.innerExpression+"' rather than the result of the '?' or 'has' operator. You need to add parentheses around the (A ? B) expression."); + } + } + } + + string NativeNameForOp(string opName) + { + if (opName == "and") + return "&&"; + + if (opName == "or") + return "||"; + + if (opName == "mod") + return "%"; + + if (opName == "has") + return "?"; + + if (opName == "hasnt") + return "!?"; + + return opName; + } + + public override string ToString () + { + return string.Format ("({0} {1} {2})", leftExpression, opName, rightExpression); + } + } + + public class UnaryExpression : Expression + { + public Expression innerExpression; + public string op; + + // Attempt to flatten inner expression immediately + // e.g. convert (-(5)) into (-5) + public static Expression WithInner(Expression inner, string op) { + + var innerNumber = inner as Number; + if( innerNumber ) { + + if( op == "-" ) { + if( innerNumber.value is int ) { + return new Number( -((int)innerNumber.value) ); + } else if( innerNumber.value is float ) { + return new Number( -((float)innerNumber.value) ); + } + } + + else if( op == "!" || op == "not" ) { + if( innerNumber.value is int ) { + return new Number( (int)innerNumber.value == 0 ); + } else if( innerNumber.value is float ) { + return new Number( (float)innerNumber.value == 0.0f ); + } else if( innerNumber.value is bool ) { + return new Number( !(bool)innerNumber.value ); + } + } + + throw new System.Exception ("Unexpected operation or number type"); + } + + // Normal fallback + var unary = new UnaryExpression (inner, op); + return unary; + } + + public UnaryExpression(Expression inner, string op) + { + this.innerExpression = AddContent(inner); + this.op = op; + } + + public override void GenerateIntoContainer(Runtime.Container container) + { + innerExpression.GenerateIntoContainer (container); + + container.AddContent(Runtime.NativeFunctionCall.CallWithName(nativeNameForOp)); + } + + public override string ToString () + { + return nativeNameForOp + innerExpression; + } + + string nativeNameForOp + { + get { + // Replace "-" with "_" to make it unique (compared to subtraction) + if (op == "-") + return "_"; + if (op == "not") + return "!"; + return op; + } + } + } + + public class IncDecExpression : Expression + { + public Identifier varIdentifier; + public bool isInc; + public Expression expression; + + public IncDecExpression(Identifier varIdentifier, bool isInc) + { + this.varIdentifier = varIdentifier; + this.isInc = isInc; + } + + public IncDecExpression (Identifier varIdentifier, Expression expression, bool isInc) : this(varIdentifier, isInc) + { + this.expression = expression; + AddContent (expression); + } + + public override void GenerateIntoContainer(Runtime.Container container) + { + // x = x + y + // ^^^ ^ ^ ^ + // 4 1 3 2 + // Reverse polish notation: (x 1 +) (assign to x) + + // 1. + container.AddContent (new Runtime.VariableReference (varIdentifier?.name)); + + // 2. + // - Expression used in the form ~ x += y + // - Simple version: ~ x++ + if (expression) + expression.GenerateIntoContainer (container); + else + container.AddContent (new Runtime.IntValue (1)); + + // 3. + container.AddContent (Runtime.NativeFunctionCall.CallWithName (isInc ? "+" : "-")); + + // 4. + _runtimeAssignment = new Runtime.VariableAssignment(varIdentifier?.name, false); + container.AddContent (_runtimeAssignment); + } + + public override void ResolveReferences (Story context) + { + base.ResolveReferences (context); + + var varResolveResult = context.ResolveVariableWithName(varIdentifier?.name, fromNode: this); + if (!varResolveResult.found) { + Error ("variable for "+incrementDecrementWord+" could not be found: '"+varIdentifier+"' after searching: "+this.descriptionOfScope); + } + + _runtimeAssignment.isGlobal = varResolveResult.isGlobal; + + if (!(parent is Weave) && !(parent is FlowBase) && !(parent is ContentList)) { + Error ("Can't use " + incrementDecrementWord + " as sub-expression"); + } + } + + string incrementDecrementWord { + get { + if (isInc) + return "increment"; + else + return "decrement"; + } + } + + public override string ToString () + { + if (expression) + return varIdentifier + (isInc ? " += " : " -= ") + expression.ToString (); + else + return varIdentifier + (isInc ? "++" : "--"); + } + + Runtime.VariableAssignment _runtimeAssignment; + } + + public class MultipleConditionExpression : Expression + { + public List subExpressions { + get { + return this.content.Cast ().ToList (); + } + } + + public MultipleConditionExpression(List conditionExpressions) + { + AddContent (conditionExpressions); + } + + public override void GenerateIntoContainer(Runtime.Container container) + { + // A && B && C && D + // => (((A B &&) C &&) D &&) etc + bool isFirst = true; + foreach (var conditionExpr in subExpressions) { + + conditionExpr.GenerateIntoContainer (container); + + if (!isFirst) { + container.AddContent (Runtime.NativeFunctionCall.CallWithName ("&&")); + } + + isFirst = false; + } + } + } + +} + diff --git a/Assets/Ink/compiler/ParsedHierarchy/Expression.cs.meta b/Assets/Ink/compiler/ParsedHierarchy/Expression.cs.meta new file mode 100644 index 000000000..e804868a9 --- /dev/null +++ b/Assets/Ink/compiler/ParsedHierarchy/Expression.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: 1edc533f07321ae4d9c34b10af8b03c7 +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/Assets/Ink/compiler/ParsedHierarchy/ExternalDeclaration.cs b/Assets/Ink/compiler/ParsedHierarchy/ExternalDeclaration.cs new file mode 100644 index 000000000..909450055 --- /dev/null +++ b/Assets/Ink/compiler/ParsedHierarchy/ExternalDeclaration.cs @@ -0,0 +1,30 @@ +using System; +using System.Collections.Generic; + +namespace Ink.Parsed +{ + public class ExternalDeclaration : Parsed.Object, INamedContent + { + public string name + { + get { return identifier?.name; } + } + public Identifier identifier { get; set; } + public List argumentNames { get; set; } + + public ExternalDeclaration (Identifier identifier, List argumentNames) + { + this.identifier = identifier; + this.argumentNames = argumentNames; + } + + public override Ink.Runtime.Object GenerateRuntimeObject () + { + story.AddExternal (this); + + // No runtime code exists for an external, only metadata + return null; + } + } +} + diff --git a/Assets/Ink/compiler/ParsedHierarchy/ExternalDeclaration.cs.meta b/Assets/Ink/compiler/ParsedHierarchy/ExternalDeclaration.cs.meta new file mode 100644 index 000000000..d8a395b44 --- /dev/null +++ b/Assets/Ink/compiler/ParsedHierarchy/ExternalDeclaration.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: e9f2dc2870db5b84b961d5899b4b18ae +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/Assets/Ink/compiler/ParsedHierarchy/FlowBase.cs b/Assets/Ink/compiler/ParsedHierarchy/FlowBase.cs new file mode 100644 index 000000000..17aca4209 --- /dev/null +++ b/Assets/Ink/compiler/ParsedHierarchy/FlowBase.cs @@ -0,0 +1,439 @@ +using System.Collections.Generic; + +namespace Ink.Parsed +{ + // Base class for Knots and Stitches + public abstract class FlowBase : Parsed.Object, INamedContent + { + public class Argument + { + public Identifier identifier; + public bool isByReference; + public bool isDivertTarget; + } + + public string name + { + get { return identifier?.name; } + } + public Identifier identifier { get; set; } + public List arguments { get; protected set; } + public bool hasParameters { get { return arguments != null && arguments.Count > 0; } } + public Dictionary variableDeclarations; + + public abstract FlowLevel flowLevel { get; } + public bool isFunction { get; protected set; } + + public FlowBase (Identifier name = null, List topLevelObjects = null, List arguments = null, bool isFunction = false, bool isIncludedStory = false) + { + this.identifier = name; + + if (topLevelObjects == null) { + topLevelObjects = new List (); + } + + // Used by story to add includes + PreProcessTopLevelObjects (topLevelObjects); + + topLevelObjects = SplitWeaveAndSubFlowContent (topLevelObjects, isRootStory:this is Story && !isIncludedStory); + + AddContent(topLevelObjects); + + this.arguments = arguments; + this.isFunction = isFunction; + this.variableDeclarations = new Dictionary (); + } + + List SplitWeaveAndSubFlowContent(List contentObjs, bool isRootStory) + { + var weaveObjs = new List (); + var subFlowObjs = new List (); + + _subFlowsByName = new Dictionary (); + + foreach (var obj in contentObjs) { + + var subFlow = obj as FlowBase; + if (subFlow) { + if (_firstChildFlow == null) + _firstChildFlow = subFlow; + + subFlowObjs.Add (obj); + _subFlowsByName [subFlow.identifier?.name] = subFlow; + } else { + weaveObjs.Add (obj); + } + } + + // Implicit final gather in top level story for ending without warning that you run out of content + if (isRootStory) { + weaveObjs.Add (new Gather (null, 1)); + weaveObjs.Add (new Divert (new Path (Identifier.Done))); + } + + var finalContent = new List (); + + if (weaveObjs.Count > 0) { + _rootWeave = new Weave (weaveObjs, 0); + finalContent.Add (_rootWeave); + } + + if (subFlowObjs.Count > 0) { + finalContent.AddRange (subFlowObjs); + } + + return finalContent; + } + + protected virtual void PreProcessTopLevelObjects(List topLevelObjects) + { + // empty by default, used by Story to process included file references + } + + public struct VariableResolveResult + { + public bool found; + public bool isGlobal; + public bool isArgument; + public bool isTemporary; + public FlowBase ownerFlow; + } + + public VariableResolveResult ResolveVariableWithName(string varName, Parsed.Object fromNode) + { + var result = new VariableResolveResult (); + + // Search in the stitch / knot that owns the node first + var ownerFlow = fromNode == null ? this : fromNode.ClosestFlowBase (); + + // Argument + if (ownerFlow.arguments != null ) { + foreach (var arg in ownerFlow.arguments) { + if (arg.identifier.name.Equals (varName)) { + result.found = true; + result.isArgument = true; + result.ownerFlow = ownerFlow; + return result; + } + } + } + + // Temp + var story = this.story; // optimisation + if (ownerFlow != story && ownerFlow.variableDeclarations.ContainsKey (varName)) { + result.found = true; + result.ownerFlow = ownerFlow; + result.isTemporary = true; + return result; + } + + // Global + if (story.variableDeclarations.ContainsKey (varName)) { + result.found = true; + result.ownerFlow = story; + result.isGlobal = true; + return result; + } + + result.found = false; + return result; + } + + public void TryAddNewVariableDeclaration(VariableAssignment varDecl) + { + var varName = varDecl.variableName; + if (variableDeclarations.ContainsKey (varName)) { + + var prevDeclError = ""; + var debugMetadata = variableDeclarations [varName].debugMetadata; + if (debugMetadata != null) { + prevDeclError = " ("+variableDeclarations [varName].debugMetadata+")"; + } + Error("found declaration variable '"+varName+"' that was already declared"+prevDeclError, varDecl, false); + + return; + } + + variableDeclarations [varDecl.variableName] = varDecl; + } + + public void ResolveWeavePointNaming () + { + // Find all weave points and organise them by name ready for + // diverting. Also detect naming collisions. + if( _rootWeave ) + _rootWeave.ResolveWeavePointNaming (); + + if (_subFlowsByName != null) { + foreach (var namedSubFlow in _subFlowsByName) { + namedSubFlow.Value.ResolveWeavePointNaming (); + } + } + } + + public override Runtime.Object GenerateRuntimeObject () + { + Return foundReturn = null; + if (isFunction) { + CheckForDisallowedFunctionFlowControl (); + } + + // Non-functon: Make sure knots and stitches don't attempt to use Return statement + else if( flowLevel == FlowLevel.Knot || flowLevel == FlowLevel.Stitch ) { + foundReturn = Find (); + if (foundReturn != null) { + Error ("Return statements can only be used in knots that are declared as functions: == function " + this.identifier + " ==", foundReturn); + } + } + + var container = new Runtime.Container (); + container.name = identifier?.name; + + if( this.story.countAllVisits ) { + container.visitsShouldBeCounted = true; + } + + GenerateArgumentVariableAssignments (container); + + // Run through content defined for this knot/stitch: + // - First of all, any initial content before a sub-stitch + // or any weave content is added to the main content container + // - The first inner knot/stitch is automatically entered, while + // the others are only accessible by an explicit divert + // - The exception to this rule is if the knot/stitch takes + // parameters, in which case it can't be auto-entered. + // - Any Choices and Gathers (i.e. IWeavePoint) found are + // processsed by GenerateFlowContent. + int contentIdx = 0; + while (content != null && contentIdx < content.Count) { + + Parsed.Object obj = content [contentIdx]; + + // Inner knots and stitches + if (obj is FlowBase) { + + var childFlow = (FlowBase)obj; + + var childFlowRuntime = childFlow.runtimeObject; + + // First inner stitch - automatically step into it + // 20/09/2016 - let's not auto step into knots + if (contentIdx == 0 && !childFlow.hasParameters + && this.flowLevel == FlowLevel.Knot) { + _startingSubFlowDivert = new Runtime.Divert (); + container.AddContent(_startingSubFlowDivert); + _startingSubFlowRuntime = childFlowRuntime; + } + + // Check for duplicate knots/stitches with same name + var namedChild = (Runtime.INamedContent)childFlowRuntime; + Runtime.INamedContent existingChild = null; + if (container.namedContent.TryGetValue(namedChild.name, out existingChild) ) { + var errorMsg = string.Format ("{0} already contains flow named '{1}' (at {2})", + this.GetType().Name, + namedChild.name, + (existingChild as Runtime.Object).debugMetadata); + + Error (errorMsg, childFlow); + } + + container.AddToNamedContentOnly (namedChild); + } + + // Other content (including entire Weaves that were grouped in the constructor) + // At the time of writing, all FlowBases have a maximum of one piece of "other content" + // and it's always the root Weave + else { + container.AddContent (obj.runtimeObject); + } + + contentIdx++; + } + + // CHECK FOR FINAL LOOSE ENDS! + // Notes: + // - Functions don't need to terminate - they just implicitly return + // - If return statement was found, don't continue finding warnings for missing control flow, + // since it's likely that a return statement has been used instead of a ->-> or something, + // or the writer failed to mark the knot as a function. + // - _rootWeave may be null if it's a knot that only has stitches + if (flowLevel != FlowLevel.Story && !this.isFunction && _rootWeave != null && foundReturn == null) { + _rootWeave.ValidateTermination (WarningInTermination); + } + + return container; + } + + void GenerateArgumentVariableAssignments(Runtime.Container container) + { + if (this.arguments == null || this.arguments.Count == 0) { + return; + } + + // Assign parameters in reverse since they'll be popped off the evaluation stack + // No need to generate EvalStart and EvalEnd since there's nothing being pushed + // back onto the evaluation stack. + for (int i = arguments.Count - 1; i >= 0; --i) { + var paramName = arguments [i].identifier?.name; + + var assign = new Runtime.VariableAssignment (paramName, isNewDeclaration:true); + container.AddContent (assign); + } + } + + public Parsed.Object ContentWithNameAtLevel(string name, FlowLevel? level = null, bool deepSearch = false) + { + // Referencing self? + if (level == this.flowLevel || level == null) { + if (name == this.identifier?.name) { + return this; + } + } + + if ( level == FlowLevel.WeavePoint || level == null ) { + + Parsed.Object weavePointResult = null; + + if (_rootWeave) { + weavePointResult = (Parsed.Object)_rootWeave.WeavePointNamed (name); + if (weavePointResult) + return weavePointResult; + } + + // Stop now if we only wanted a result if it's a weave point? + if (level == FlowLevel.WeavePoint) + return deepSearch ? DeepSearchForAnyLevelContent(name) : null; + } + + // If this flow would be incapable of containing the requested level, early out + // (e.g. asking for a Knot from a Stitch) + if (level != null && level < this.flowLevel) + return null; + + FlowBase subFlow = null; + + if (_subFlowsByName.TryGetValue (name, out subFlow)) { + if (level == null || level == subFlow.flowLevel) + return subFlow; + } + + return deepSearch ? DeepSearchForAnyLevelContent(name) : null; + } + + Parsed.Object DeepSearchForAnyLevelContent(string name) + { + var weaveResultSelf = ContentWithNameAtLevel (name, level:FlowLevel.WeavePoint, deepSearch: false); + if (weaveResultSelf) { + return weaveResultSelf; + } + + foreach (var subFlowNamePair in _subFlowsByName) { + var subFlow = subFlowNamePair.Value; + var deepResult = subFlow.ContentWithNameAtLevel (name, level:null, deepSearch: true); + if (deepResult) + return deepResult; + } + + return null; + } + + public override void ResolveReferences (Story context) + { + if (_startingSubFlowDivert) { + _startingSubFlowDivert.targetPath = _startingSubFlowRuntime.path; + } + + base.ResolveReferences(context); + + // Check validity of parameter names + if (arguments != null) { + + foreach (var arg in arguments) + context.CheckForNamingCollisions (this, arg.identifier, Story.SymbolType.Arg, "argument"); + + // Separately, check for duplicate arugment names, since they aren't Parsed.Objects, + // so have to be checked independently. + for (int i = 0; i < arguments.Count; i++) { + for (int j = i + 1; j < arguments.Count; j++) { + if (arguments [i].identifier?.name == arguments [j].identifier?.name) { + Error ("Multiple arguments with the same name: '" + arguments [i].identifier + "'"); + } + } + } + } + + // Check naming collisions for knots and stitches + if (flowLevel != FlowLevel.Story) { + // Weave points aren't FlowBases, so this will only be knot or stitch + var symbolType = flowLevel == FlowLevel.Knot ? Story.SymbolType.Knot : Story.SymbolType.SubFlowAndWeave; + context.CheckForNamingCollisions (this, identifier, symbolType); + } + } + + void CheckForDisallowedFunctionFlowControl() + { + if (!(this is Knot)) { + Error ("Functions cannot be stitches - i.e. they should be defined as '== function myFunc ==' rather than public to another knot."); + } + + // Not allowed sub-flows + foreach (var subFlowAndName in _subFlowsByName) { + var name = subFlowAndName.Key; + var subFlow = subFlowAndName.Value; + Error ("Functions may not contain stitches, but saw '"+name+"' within the function '"+this.identifier+"'", subFlow); + } + + var allDiverts = _rootWeave.FindAll (); + foreach (var divert in allDiverts) { + if( !divert.isFunctionCall && !(divert.parent is DivertTarget) ) + Error ("Functions may not contain diverts, but saw '"+divert.ToString()+"'", divert); + } + + var allChoices = _rootWeave.FindAll (); + foreach (var choice in allChoices) { + Error ("Functions may not contain choices, but saw '"+choice.ToString()+"'", choice); + } + } + + void WarningInTermination(Parsed.Object terminatingObject) + { + string message = "Apparent loose end exists where the flow runs out. Do you need a '-> DONE' statement, choice or divert?"; + if (terminatingObject.parent == _rootWeave && _firstChildFlow) { + message = message + " Note that if you intend to enter '"+_firstChildFlow.identifier+"' next, you need to divert to it explicitly."; + } + + var terminatingDivert = terminatingObject as Divert; + if (terminatingDivert && terminatingDivert.isTunnel) { + message = message + " When final tunnel to '"+terminatingDivert.target+" ->' returns it won't have anywhere to go."; + } + + Warning (message, terminatingObject); + } + + protected Dictionary subFlowsByName { + get { + return _subFlowsByName; + } + } + + public override string typeName { + get { + if (isFunction) return "Function"; + else return flowLevel.ToString (); + } + } + + public override string ToString () + { + return typeName+" '" + identifier + "'"; + } + + Weave _rootWeave; + Dictionary _subFlowsByName; + Runtime.Divert _startingSubFlowDivert; + Runtime.Object _startingSubFlowRuntime; + FlowBase _firstChildFlow; + + } +} + diff --git a/Assets/Ink/compiler/ParsedHierarchy/FlowBase.cs.meta b/Assets/Ink/compiler/ParsedHierarchy/FlowBase.cs.meta new file mode 100644 index 000000000..debb480b9 --- /dev/null +++ b/Assets/Ink/compiler/ParsedHierarchy/FlowBase.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: c936ee81c2333434e9fa16f064b00713 +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/Assets/Ink/compiler/ParsedHierarchy/FlowLevel.cs b/Assets/Ink/compiler/ParsedHierarchy/FlowLevel.cs new file mode 100644 index 000000000..5bbdce00b --- /dev/null +++ b/Assets/Ink/compiler/ParsedHierarchy/FlowLevel.cs @@ -0,0 +1,11 @@ +namespace Ink.Parsed +{ + public enum FlowLevel + { + Story, + Knot, + Stitch, + WeavePoint // not actually a FlowBase, but used for diverts + } +} + diff --git a/Assets/Ink/compiler/ParsedHierarchy/FlowLevel.cs.meta b/Assets/Ink/compiler/ParsedHierarchy/FlowLevel.cs.meta new file mode 100644 index 000000000..d9dca7f9c --- /dev/null +++ b/Assets/Ink/compiler/ParsedHierarchy/FlowLevel.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: d23be1022b71f37498259aec83d4f1ea +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/Assets/Ink/compiler/ParsedHierarchy/FunctionCall.cs b/Assets/Ink/compiler/ParsedHierarchy/FunctionCall.cs new file mode 100644 index 000000000..d3d40f5ca --- /dev/null +++ b/Assets/Ink/compiler/ParsedHierarchy/FunctionCall.cs @@ -0,0 +1,242 @@ +using System.Collections.Generic; + +namespace Ink.Parsed +{ + public class FunctionCall : Expression + { + public string name { get { return _proxyDivert.target.firstComponent; } } + public Divert proxyDivert { get { return _proxyDivert; } } + public List arguments { get { return _proxyDivert.arguments; } } + public Runtime.Divert runtimeDivert { get { return _proxyDivert.runtimeDivert; } } + public bool isChoiceCount { get { return name == "CHOICE_COUNT"; } } + public bool isTurns { get { return name == "TURNS"; } } + public bool isTurnsSince { get { return name == "TURNS_SINCE"; } } + public bool isRandom { get { return name == "RANDOM"; } } + public bool isSeedRandom { get { return name == "SEED_RANDOM"; } } + public bool isListRange { get { return name == "LIST_RANGE"; } } + public bool isListRandom { get { return name == "LIST_RANDOM"; } } + public bool isReadCount { get { return name == "READ_COUNT"; } } + + public bool shouldPopReturnedValue; + + public FunctionCall (Identifier functionName, List arguments) + { + _proxyDivert = new Parsed.Divert(new Path(functionName), arguments); + _proxyDivert.isFunctionCall = true; + AddContent (_proxyDivert); + } + + public override void GenerateIntoContainer (Runtime.Container container) + { + var foundList = story.ResolveList (name); + + bool usingProxyDivert = false; + + if (isChoiceCount) { + + if (arguments.Count > 0) + Error ("The CHOICE_COUNT() function shouldn't take any arguments"); + + container.AddContent (Runtime.ControlCommand.ChoiceCount ()); + + } else if (isTurns) { + + if (arguments.Count > 0) + Error ("The TURNS() function shouldn't take any arguments"); + + container.AddContent (Runtime.ControlCommand.Turns ()); + + } else if (isTurnsSince || isReadCount) { + + var divertTarget = arguments [0] as DivertTarget; + var variableDivertTarget = arguments [0] as VariableReference; + + if (arguments.Count != 1 || (divertTarget == null && variableDivertTarget == null)) { + Error ("The " + name + "() function should take one argument: a divert target to the target knot, stitch, gather or choice you want to check. e.g. TURNS_SINCE(-> myKnot)"); + return; + } + + if (divertTarget) { + _divertTargetToCount = divertTarget; + AddContent (_divertTargetToCount); + + _divertTargetToCount.GenerateIntoContainer (container); + } else { + _variableReferenceToCount = variableDivertTarget; + AddContent (_variableReferenceToCount); + + _variableReferenceToCount.GenerateIntoContainer (container); + } + + if (isTurnsSince) + container.AddContent (Runtime.ControlCommand.TurnsSince ()); + else + container.AddContent (Runtime.ControlCommand.ReadCount ()); + + } else if (isRandom) { + if (arguments.Count != 2) + Error ("RANDOM should take 2 parameters: a minimum and a maximum integer"); + + // We can type check single values, but not complex expressions + for (int arg = 0; arg < arguments.Count; arg++) { + if (arguments [arg] is Number) { + var num = arguments [arg] as Number; + if (!(num.value is int)) { + string paramName = arg == 0 ? "minimum" : "maximum"; + Error ("RANDOM's " + paramName + " parameter should be an integer"); + } + } + + arguments [arg].GenerateIntoContainer (container); + } + + container.AddContent (Runtime.ControlCommand.Random ()); + + } else if (isSeedRandom) { + if (arguments.Count != 1) + Error ("SEED_RANDOM should take 1 parameter - an integer seed"); + + var num = arguments [0] as Number; + if (num && !(num.value is int)) { + Error ("SEED_RANDOM's parameter should be an integer seed"); + } + + arguments [0].GenerateIntoContainer (container); + + container.AddContent (Runtime.ControlCommand.SeedRandom ()); + + } else if (isListRange) { + if (arguments.Count != 3) + Error ("LIST_RANGE should take 3 parameters - a list, a min and a max"); + + for (int arg = 0; arg < arguments.Count; arg++) + arguments [arg].GenerateIntoContainer (container); + + container.AddContent (Runtime.ControlCommand.ListRange ()); + + } else if( isListRandom ) { + if (arguments.Count != 1) + Error ("LIST_RANDOM should take 1 parameter - a list"); + + arguments [0].GenerateIntoContainer (container); + + container.AddContent (Runtime.ControlCommand.ListRandom ()); + + } else if (Runtime.NativeFunctionCall.CallExistsWithName (name)) { + + var nativeCall = Runtime.NativeFunctionCall.CallWithName (name); + + if (nativeCall.numberOfParameters != arguments.Count) { + var msg = name + " should take " + nativeCall.numberOfParameters + " parameter"; + if (nativeCall.numberOfParameters > 1) + msg += "s"; + Error (msg); + } + + for (int arg = 0; arg < arguments.Count; arg++) + arguments [arg].GenerateIntoContainer (container); + + container.AddContent (Runtime.NativeFunctionCall.CallWithName (name)); + } else if (foundList != null) { + if (arguments.Count > 1) + Error ("Can currently only construct a list from one integer (or an empty list from a given list definition)"); + + // List item from given int + if (arguments.Count == 1) { + container.AddContent (new Runtime.StringValue (name)); + arguments [0].GenerateIntoContainer (container); + container.AddContent (Runtime.ControlCommand.ListFromInt ()); + } + + // Empty list with given origin. + else { + var list = new Runtime.InkList (); + list.SetInitialOriginName (name); + container.AddContent (new Runtime.ListValue (list)); + } + } + + // Normal function call + else { + container.AddContent (_proxyDivert.runtimeObject); + usingProxyDivert = true; + } + + // Don't attempt to resolve as a divert if we're not doing a normal function call + if( !usingProxyDivert ) content.Remove (_proxyDivert); + + // Function calls that are used alone on a tilda-based line: + // ~ func() + // Should tidy up any returned value from the evaluation stack, + // since it's unused. + if (shouldPopReturnedValue) + container.AddContent (Runtime.ControlCommand.PopEvaluatedValue ()); + } + + public override void ResolveReferences (Story context) + { + base.ResolveReferences (context); + + // If we aren't using the proxy divert after all (e.g. if + // it's a native function call), but we still have arguments, + // we need to make sure they get resolved since the proxy divert + // is no longer in the content array. + if (!content.Contains(_proxyDivert) && arguments != null) { + foreach (var arg in arguments) + arg.ResolveReferences (context); + } + + if( _divertTargetToCount ) { + var divert = _divertTargetToCount.divert; + var attemptingTurnCountOfVariableTarget = divert.runtimeDivert.variableDivertName != null; + + if( attemptingTurnCountOfVariableTarget ) { + Error("When getting the TURNS_SINCE() of a variable target, remove the '->' - i.e. it should just be TURNS_SINCE("+divert.runtimeDivert.variableDivertName+")"); + return; + } + + var targetObject = divert.targetContent; + if( targetObject == null ) { + if( !attemptingTurnCountOfVariableTarget ) { + Error("Failed to find target for TURNS_SINCE: '"+divert.target+"'"); + } + } else { + targetObject.containerForCounting.turnIndexShouldBeCounted = true; + } + } + + else if( _variableReferenceToCount ) { + var runtimeVarRef = _variableReferenceToCount.runtimeVarRef; + if( runtimeVarRef.pathForCount != null ) { + Error("Should be "+name+"(-> "+_variableReferenceToCount.name+"). Usage without the '->' only makes sense for variable targets."); + } + } + } + + public static bool IsBuiltIn(string name) + { + if (Runtime.NativeFunctionCall.CallExistsWithName (name)) + return true; + + return name == "CHOICE_COUNT" + || name == "TURNS_SINCE" + || name == "TURNS" + || name == "RANDOM" + || name == "SEED_RANDOM" + || name == "LIST_VALUE" + || name == "LIST_RANDOM" + || name == "READ_COUNT"; + } + + public override string ToString () + { + var strArgs = string.Join (", ", arguments.ToStringsArray()); + return string.Format ("{0}({1})", name, strArgs); + } + + Parsed.Divert _proxyDivert; + Parsed.DivertTarget _divertTargetToCount; + Parsed.VariableReference _variableReferenceToCount; + } +} + diff --git a/Assets/Ink/compiler/ParsedHierarchy/FunctionCall.cs.meta b/Assets/Ink/compiler/ParsedHierarchy/FunctionCall.cs.meta new file mode 100644 index 000000000..ba7946b02 --- /dev/null +++ b/Assets/Ink/compiler/ParsedHierarchy/FunctionCall.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: d0c4ce3f9917d9640992812b5a79ab0f +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/Assets/Ink/compiler/ParsedHierarchy/Gather.cs b/Assets/Ink/compiler/ParsedHierarchy/Gather.cs new file mode 100644 index 000000000..ca86acf52 --- /dev/null +++ b/Assets/Ink/compiler/ParsedHierarchy/Gather.cs @@ -0,0 +1,51 @@ + +namespace Ink.Parsed +{ + public class Gather : Parsed.Object, IWeavePoint, INamedContent + { + public string name + { + get { return identifier?.name; } + } + public Identifier identifier { get; set; } + public int indentationDepth { get; protected set; } + + public Runtime.Container runtimeContainer { get { return (Runtime.Container) runtimeObject; } } + + public Gather (Identifier identifier, int indentationDepth) + { + this.identifier = identifier; + this.indentationDepth = indentationDepth; + } + + public override Runtime.Object GenerateRuntimeObject () + { + var container = new Runtime.Container (); + container.name = name; + + if (this.story.countAllVisits) { + container.visitsShouldBeCounted = true; + } + + container.countingAtStartOnly = true; + + // A gather can have null content, e.g. it's just purely a line with "-" + if (content != null) { + foreach (var c in content) { + container.AddContent (c.runtimeObject); + } + } + + return container; + } + + public override void ResolveReferences (Story context) + { + base.ResolveReferences (context); + + if( identifier != null && identifier.name.Length > 0 ) + context.CheckForNamingCollisions (this, identifier, Story.SymbolType.SubFlowAndWeave); + } + } +} + diff --git a/Assets/Ink/compiler/ParsedHierarchy/Gather.cs.meta b/Assets/Ink/compiler/ParsedHierarchy/Gather.cs.meta new file mode 100644 index 000000000..0b9c2f05d --- /dev/null +++ b/Assets/Ink/compiler/ParsedHierarchy/Gather.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: fc66aa755c03c4446a671dc409d2a3d4 +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/Assets/Ink/compiler/ParsedHierarchy/INamedContent.cs b/Assets/Ink/compiler/ParsedHierarchy/INamedContent.cs new file mode 100644 index 000000000..fa1444905 --- /dev/null +++ b/Assets/Ink/compiler/ParsedHierarchy/INamedContent.cs @@ -0,0 +1,9 @@ + +namespace Ink.Parsed +{ + public interface INamedContent + { + string name { get; } + } +} + diff --git a/Assets/Ink/compiler/ParsedHierarchy/INamedContent.cs.meta b/Assets/Ink/compiler/ParsedHierarchy/INamedContent.cs.meta new file mode 100644 index 000000000..d2a9aff34 --- /dev/null +++ b/Assets/Ink/compiler/ParsedHierarchy/INamedContent.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: fe4e97c6e629c9549b6dd70ad506b3c5 +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/Assets/Ink/compiler/ParsedHierarchy/IWeavePoint.cs b/Assets/Ink/compiler/ParsedHierarchy/IWeavePoint.cs new file mode 100644 index 000000000..4155823f3 --- /dev/null +++ b/Assets/Ink/compiler/ParsedHierarchy/IWeavePoint.cs @@ -0,0 +1,15 @@ +using System.Collections.Generic; + +namespace Ink.Parsed +{ + public interface IWeavePoint + { + int indentationDepth { get; } + Runtime.Container runtimeContainer { get; } + List content { get; } + string name { get; } + Identifier identifier { get; } + + } +} + diff --git a/Assets/Ink/compiler/ParsedHierarchy/IWeavePoint.cs.meta b/Assets/Ink/compiler/ParsedHierarchy/IWeavePoint.cs.meta new file mode 100644 index 000000000..99f84663e --- /dev/null +++ b/Assets/Ink/compiler/ParsedHierarchy/IWeavePoint.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: c5a8ee94bb73bc146a9dd64fa514588d +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/Assets/Ink/compiler/ParsedHierarchy/Identifier.cs b/Assets/Ink/compiler/ParsedHierarchy/Identifier.cs new file mode 100644 index 000000000..5f76529a6 --- /dev/null +++ b/Assets/Ink/compiler/ParsedHierarchy/Identifier.cs @@ -0,0 +1,13 @@ +namespace Ink.Parsed { + public class Identifier { + public string name; + public Runtime.DebugMetadata debugMetadata; + + public override string ToString() + { + return name; + } + + public static Identifier Done = new Identifier { name = "DONE", debugMetadata = null }; + } +} diff --git a/Assets/Ink/compiler/ParsedHierarchy/Identifier.cs.meta b/Assets/Ink/compiler/ParsedHierarchy/Identifier.cs.meta new file mode 100644 index 000000000..493c9ec70 --- /dev/null +++ b/Assets/Ink/compiler/ParsedHierarchy/Identifier.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: b328538ea93d8484da7f7740ed92e222 +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/Assets/Ink/compiler/ParsedHierarchy/IncludedFile.cs b/Assets/Ink/compiler/ParsedHierarchy/IncludedFile.cs new file mode 100644 index 000000000..5eee99b38 --- /dev/null +++ b/Assets/Ink/compiler/ParsedHierarchy/IncludedFile.cs @@ -0,0 +1,20 @@ + +namespace Ink.Parsed +{ + public class IncludedFile : Parsed.Object + { + public Parsed.Story includedStory { get; private set; } + + public IncludedFile (Parsed.Story includedStory) + { + this.includedStory = includedStory; + } + + public override Runtime.Object GenerateRuntimeObject () + { + // Left to the main story to process + return null; + } + } +} + diff --git a/Assets/Ink/compiler/ParsedHierarchy/IncludedFile.cs.meta b/Assets/Ink/compiler/ParsedHierarchy/IncludedFile.cs.meta new file mode 100644 index 000000000..1bfa6eebb --- /dev/null +++ b/Assets/Ink/compiler/ParsedHierarchy/IncludedFile.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: 43fcbe37e6ea64e41a9ae8930f60482c +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/Assets/Ink/compiler/ParsedHierarchy/Knot.cs b/Assets/Ink/compiler/ParsedHierarchy/Knot.cs new file mode 100644 index 000000000..a39a44cb3 --- /dev/null +++ b/Assets/Ink/compiler/ParsedHierarchy/Knot.cs @@ -0,0 +1,35 @@ +using System.Collections.Generic; + +namespace Ink.Parsed +{ + public class Knot : FlowBase + { + public override FlowLevel flowLevel { get { return FlowLevel.Knot; } } + + public Knot (Identifier name, List topLevelObjects, List arguments, bool isFunction) : base(name, topLevelObjects, arguments, isFunction) + { + } + + public override void ResolveReferences (Story context) + { + base.ResolveReferences (context); + + var parentStory = this.story; + + // Enforce rule that stitches must not have the same + // name as any knots that exist in the story + foreach (var stitchNamePair in subFlowsByName) { + var stitchName = stitchNamePair.Key; + + var knotWithStitchName = parentStory.ContentWithNameAtLevel (stitchName, FlowLevel.Knot, false); + if (knotWithStitchName) { + var stitch = stitchNamePair.Value; + var errorMsg = string.Format ("Stitch '{0}' has the same name as a knot (on {1})", stitch.identifier, knotWithStitchName.debugMetadata); + Error(errorMsg, stitch); + } + } + } + + } +} + diff --git a/Assets/Ink/compiler/ParsedHierarchy/Knot.cs.meta b/Assets/Ink/compiler/ParsedHierarchy/Knot.cs.meta new file mode 100644 index 000000000..366db9839 --- /dev/null +++ b/Assets/Ink/compiler/ParsedHierarchy/Knot.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: 62729918840194249af54e112c8f2af2 +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/Assets/Ink/compiler/ParsedHierarchy/List.cs b/Assets/Ink/compiler/ParsedHierarchy/List.cs new file mode 100644 index 000000000..db48d8505 --- /dev/null +++ b/Assets/Ink/compiler/ParsedHierarchy/List.cs @@ -0,0 +1,53 @@ +using System.Collections.Generic; + +namespace Ink.Parsed +{ + public class List : Parsed.Expression + { + public List itemIdentifierList; + + public List (List itemIdentifierList) + { + this.itemIdentifierList = itemIdentifierList; + } + + public override void GenerateIntoContainer (Runtime.Container container) + { + var runtimeRawList = new Runtime.InkList (); + + if (itemIdentifierList != null) { + foreach (var itemIdentifier in itemIdentifierList) { + var nameParts = itemIdentifier?.name.Split ('.'); + + string listName = null; + string listItemName = null; + if (nameParts.Length > 1) { + listName = nameParts [0]; + listItemName = nameParts [1]; + } else { + listItemName = nameParts [0]; + } + + var listItem = story.ResolveListItem (listName, listItemName, this); + if (listItem == null) { + if (listName == null) + Error ("Could not find list definition that contains item '" + itemIdentifier + "'"); + else + Error ("Could not find list item " + itemIdentifier); + } else { + if (listName == null) + listName = ((ListDefinition)listItem.parent).identifier?.name; + var item = new Runtime.InkListItem (listName, listItem.name); + + if (runtimeRawList.ContainsKey (item)) + Warning ("Duplicate of item '"+itemIdentifier+"' in list."); + else + runtimeRawList [item] = listItem.seriesValue; + } + } + } + + container.AddContent(new Runtime.ListValue (runtimeRawList)); + } + } +} diff --git a/Assets/Ink/compiler/ParsedHierarchy/List.cs.meta b/Assets/Ink/compiler/ParsedHierarchy/List.cs.meta new file mode 100644 index 000000000..c2e088fa2 --- /dev/null +++ b/Assets/Ink/compiler/ParsedHierarchy/List.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: b4457a33a5ed85a45b70349f369742f3 +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/Assets/Ink/compiler/ParsedHierarchy/ListDefinition.cs b/Assets/Ink/compiler/ParsedHierarchy/ListDefinition.cs new file mode 100644 index 000000000..2010d1a0b --- /dev/null +++ b/Assets/Ink/compiler/ParsedHierarchy/ListDefinition.cs @@ -0,0 +1,139 @@ +using System; +using System.Collections.Generic; +using System.Linq; + +namespace Ink.Parsed +{ + public class ListDefinition : Parsed.Object + { + public Identifier identifier; + public List itemDefinitions; + + public VariableAssignment variableAssignment; + + public Runtime.ListDefinition runtimeListDefinition { + get { + var allItems = new Dictionary (); + foreach (var e in itemDefinitions) { + if( !allItems.ContainsKey(e.name) ) + allItems.Add (e.name, e.seriesValue); + else + Error("List '"+identifier+"' contains dupicate items called '"+e.name+"'"); + } + + return new Runtime.ListDefinition (identifier?.name, allItems); + } + } + + public ListElementDefinition ItemNamed (string itemName) + { + if (_elementsByName == null) { + _elementsByName = new Dictionary (); + foreach (var el in itemDefinitions) { + _elementsByName [el.name] = el; + } + } + + ListElementDefinition foundElement; + if (_elementsByName.TryGetValue (itemName, out foundElement)) + return foundElement; + + return null; + } + + public ListDefinition (List elements) + { + this.itemDefinitions = elements; + + int currentValue = 1; + foreach (var e in this.itemDefinitions) { + if (e.explicitValue != null) + currentValue = e.explicitValue.Value; + + e.seriesValue = currentValue; + + currentValue++; + } + + AddContent (elements); + } + + public override Runtime.Object GenerateRuntimeObject () + { + var initialValues = new Runtime.InkList (); + foreach (var itemDef in itemDefinitions) { + if (itemDef.inInitialList) { + var item = new Runtime.InkListItem (this.identifier?.name, itemDef.name); + initialValues [item] = itemDef.seriesValue; + } + } + + // Set origin name, so + initialValues.SetInitialOriginName (identifier?.name); + + return new Runtime.ListValue (initialValues); + } + + public override void ResolveReferences (Story context) + { + base.ResolveReferences (context); + + context.CheckForNamingCollisions (this, identifier, Story.SymbolType.List); + } + + public override string typeName { + get { + return "List definition"; + } + } + + Dictionary _elementsByName; + } + + public class ListElementDefinition : Parsed.Object + { + public string name + { + get { return identifier?.name; } + } + public Identifier identifier; + public int? explicitValue; + public int seriesValue; + public bool inInitialList; + + public string fullName { + get { + var parentList = parent as ListDefinition; + if (parentList == null) + throw new System.Exception ("Can't get full name without a parent list"); + + return parentList.identifier + "." + name; + } + } + + public ListElementDefinition (Identifier identifier, bool inInitialList, int? explicitValue = null) + { + this.identifier = identifier; + this.inInitialList = inInitialList; + this.explicitValue = explicitValue; + } + + public override Runtime.Object GenerateRuntimeObject () + { + throw new System.NotImplementedException (); + } + + public override void ResolveReferences (Story context) + { + base.ResolveReferences (context); + + context.CheckForNamingCollisions (this, identifier, Story.SymbolType.ListItem); + } + + public override string typeName { + get { + return "List element"; + } + } + } +} diff --git a/Assets/Ink/compiler/ParsedHierarchy/ListDefinition.cs.meta b/Assets/Ink/compiler/ParsedHierarchy/ListDefinition.cs.meta new file mode 100644 index 000000000..1307aa7ec --- /dev/null +++ b/Assets/Ink/compiler/ParsedHierarchy/ListDefinition.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: 0ea0412208ae5364db5254fd7f4031a0 +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/Assets/Ink/compiler/ParsedHierarchy/Number.cs b/Assets/Ink/compiler/ParsedHierarchy/Number.cs new file mode 100644 index 000000000..be67bfd94 --- /dev/null +++ b/Assets/Ink/compiler/ParsedHierarchy/Number.cs @@ -0,0 +1,53 @@ + +namespace Ink.Parsed +{ + public class Number : Parsed.Expression + { + public object value; + + public Number(object value) + { + if (value is int || value is float || value is bool) { + this.value = value; + } else { + throw new System.Exception ("Unexpected object type in Number"); + } + } + + public override void GenerateIntoContainer (Runtime.Container container) + { + if (value is int) { + container.AddContent (new Runtime.IntValue ((int)value)); + } else if (value is float) { + container.AddContent (new Runtime.FloatValue ((float)value)); + } else if(value is bool) { + container.AddContent (new Runtime.BoolValue ((bool)value)); + } + } + + public override string ToString () + { + if (value is float) { + return ((float)value).ToString(System.Globalization.CultureInfo.InvariantCulture); + } else { + return value.ToString(); + } + } + + // Equals override necessary in order to check for CONST multiple definition equality + public override bool Equals (object obj) + { + var otherNum = obj as Number; + if (otherNum == null) return false; + + return this.value.Equals (otherNum.value); + } + + public override int GetHashCode () + { + return this.value.GetHashCode (); + } + + } +} + diff --git a/Assets/Ink/compiler/ParsedHierarchy/Number.cs.meta b/Assets/Ink/compiler/ParsedHierarchy/Number.cs.meta new file mode 100644 index 000000000..76c28f223 --- /dev/null +++ b/Assets/Ink/compiler/ParsedHierarchy/Number.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: 147bc942db743f1448c887d60ac20fbf +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/Assets/Ink/compiler/ParsedHierarchy/Object.cs b/Assets/Ink/compiler/ParsedHierarchy/Object.cs new file mode 100644 index 000000000..381a11e04 --- /dev/null +++ b/Assets/Ink/compiler/ParsedHierarchy/Object.cs @@ -0,0 +1,363 @@ +using System.Collections.Generic; +using System.Text; + +namespace Ink.Parsed +{ + public abstract class Object + { + public Runtime.DebugMetadata debugMetadata { + get { + if (_debugMetadata == null) { + if (parent) { + return parent.debugMetadata; + } + } + + return _debugMetadata; + } + + set { + _debugMetadata = value; + } + } + private Runtime.DebugMetadata _debugMetadata; + + public bool hasOwnDebugMetadata { + get { + return _debugMetadata != null; + } + } + + public virtual string typeName { + get { + return GetType().Name; + } + } + + public Parsed.Object parent { get; set; } + public List content { get; protected set; } + + public Parsed.Story story { + get { + Parsed.Object ancestor = this; + while (ancestor.parent) { + ancestor = ancestor.parent; + } + return ancestor as Parsed.Story; + } + } + + private Runtime.Object _runtimeObject; + public Runtime.Object runtimeObject + { + get { + if (_runtimeObject == null) { + _runtimeObject = GenerateRuntimeObject (); + if( _runtimeObject ) + _runtimeObject.debugMetadata = debugMetadata; + } + return _runtimeObject; + } + + set { + _runtimeObject = value; + } + } + + // virtual so that certian object types can return a different + // path than just the path to the main runtimeObject. + // e.g. a Choice returns a path to its content rather than + // its outer container. + public virtual Runtime.Path runtimePath + { + get { + return runtimeObject.path; + } + } + + // When counting visits and turns since, different object + // types may have different containers that needs to be counted. + // For most it'll just be the object's main runtime object, + // but for e.g. choices, it'll be the target container. + public virtual Runtime.Container containerForCounting + { + get { + return this.runtimeObject as Runtime.Container; + } + } + + public Parsed.Path PathRelativeTo(Parsed.Object otherObj) + { + var ownAncestry = ancestry; + var otherAncestry = otherObj.ancestry; + + Parsed.Object highestCommonAncestor = null; + int minLength = System.Math.Min (ownAncestry.Count, otherAncestry.Count); + for (int i = 0; i < minLength; ++i) { + var a1 = ancestry [i]; + var a2 = otherAncestry [i]; + if (a1 == a2) + highestCommonAncestor = a1; + else + break; + } + + FlowBase commonFlowAncestor = highestCommonAncestor as FlowBase; + if (commonFlowAncestor == null) + commonFlowAncestor = highestCommonAncestor.ClosestFlowBase (); + + + var pathComponents = new List (); + bool hasWeavePoint = false; + FlowLevel baseFlow = FlowLevel.WeavePoint; + + var ancestor = this; + while(ancestor && (ancestor != commonFlowAncestor) && !(ancestor is Story)) { + + if (ancestor == commonFlowAncestor) + break; + + if (!hasWeavePoint) { + var weavePointAncestor = ancestor as IWeavePoint; + if (weavePointAncestor != null && weavePointAncestor.identifier != null) { + pathComponents.Add (weavePointAncestor.identifier); + hasWeavePoint = true; + continue; + } + } + + var flowAncestor = ancestor as FlowBase; + if (flowAncestor) { + pathComponents.Add (flowAncestor.identifier); + baseFlow = flowAncestor.flowLevel; + } + + ancestor = ancestor.parent; + } + + pathComponents.Reverse (); + + if (pathComponents.Count > 0) { + return new Path (baseFlow, pathComponents); + } + + return null; + } + + public List ancestry + { + get { + var result = new List (); + + var ancestor = this.parent; + while(ancestor) { + result.Add (ancestor); + ancestor = ancestor.parent; + } + + result.Reverse (); + + return result; + } + } + + public string descriptionOfScope + { + get { + var locationNames = new List (); + + Parsed.Object ancestor = this; + while (ancestor) { + var ancestorFlow = ancestor as FlowBase; + if (ancestorFlow && ancestorFlow.identifier != null) { + locationNames.Add ("'" + ancestorFlow.identifier + "'"); + } + ancestor = ancestor.parent; + } + + var scopeSB = new StringBuilder (); + if (locationNames.Count > 0) { + var locationsListStr = string.Join (", ", locationNames.ToArray()); + scopeSB.Append (locationsListStr); + scopeSB.Append (" and "); + } + + scopeSB.Append ("at top scope"); + + return scopeSB.ToString (); + } + } + + // Return the object so that method can be chained easily + public T AddContent(T subContent) where T : Parsed.Object + { + if (content == null) { + content = new List (); + } + + // Make resilient to content not existing, which can happen + // in the case of parse errors where we've already reported + // an error but still want a valid structure so we can + // carry on parsing. + if( subContent ) { + subContent.parent = this; + content.Add(subContent); + } + + return subContent; + } + + public void AddContent(List listContent) where T : Parsed.Object + { + foreach (var obj in listContent) { + AddContent (obj); + } + } + + public T InsertContent(int index, T subContent) where T : Parsed.Object + { + if (content == null) { + content = new List (); + } + + subContent.parent = this; + content.Insert (index, subContent); + + return subContent; + } + + public delegate bool FindQueryFunc(T obj); + public T Find(FindQueryFunc queryFunc = null) where T : class + { + var tObj = this as T; + if (tObj != null && (queryFunc == null || queryFunc (tObj) == true)) { + return tObj; + } + + if (content == null) + return null; + + foreach (var obj in content) { + var nestedResult = obj.Find (queryFunc); + if (nestedResult != null) + return nestedResult; + } + + return null; + } + + + public List FindAll(FindQueryFunc queryFunc = null) where T : class + { + var found = new List (); + + FindAll (queryFunc, found); + + return found; + } + + void FindAll(FindQueryFunc queryFunc, List foundSoFar) where T : class + { + var tObj = this as T; + if (tObj != null && (queryFunc == null || queryFunc (tObj) == true)) { + foundSoFar.Add (tObj); + } + + if (content == null) + return; + + foreach (var obj in content) { + obj.FindAll (queryFunc, foundSoFar); + } + } + + public abstract Runtime.Object GenerateRuntimeObject (); + + public virtual void ResolveReferences(Story context) + { + if (content != null) { + foreach(var obj in content) { + obj.ResolveReferences (context); + } + } + } + + public FlowBase ClosestFlowBase() + { + var ancestor = this.parent; + while (ancestor) { + if (ancestor is FlowBase) { + return (FlowBase)ancestor; + } + ancestor = ancestor.parent; + } + + return null; + } + + public virtual void Error(string message, Parsed.Object source = null, bool isWarning = false) + { + if (source == null) { + source = this; + } + + // Only allow a single parsed object to have a single error *directly* associated with it + if (source._alreadyHadError && !isWarning) { + return; + } + if (source._alreadyHadWarning && isWarning) { + return; + } + + if (this.parent) { + this.parent.Error (message, source, isWarning); + } else { + throw new System.Exception ("No parent object to send error to: "+message); + } + + if (isWarning) { + source._alreadyHadWarning = true; + } else { + source._alreadyHadError = true; + } + + } + + public void Warning(string message, Parsed.Object source = null) + { + Error (message, source, isWarning: true); + } + + // Allow implicit conversion to bool so you don't have to do: + // if( myObj != null ) ... + public static implicit operator bool (Object obj) + { + var isNull = object.ReferenceEquals (obj, null); + return !isNull; + } + + public static bool operator ==(Object a, Object b) + { + return object.ReferenceEquals (a, b); + } + + public static bool operator !=(Object a, Object b) + { + return !(a == b); + } + + public override bool Equals (object obj) + { + return object.ReferenceEquals (obj, this); + } + + public override int GetHashCode () + { + return base.GetHashCode (); + } + + bool _alreadyHadError; + bool _alreadyHadWarning; + } +} + diff --git a/Assets/Ink/compiler/ParsedHierarchy/Object.cs.meta b/Assets/Ink/compiler/ParsedHierarchy/Object.cs.meta new file mode 100644 index 000000000..3636b1965 --- /dev/null +++ b/Assets/Ink/compiler/ParsedHierarchy/Object.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: ea5c7fed1677ba846b5df29dda86ee3d +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/Assets/Ink/compiler/ParsedHierarchy/Path.cs b/Assets/Ink/compiler/ParsedHierarchy/Path.cs new file mode 100644 index 000000000..7a17bd358 --- /dev/null +++ b/Assets/Ink/compiler/ParsedHierarchy/Path.cs @@ -0,0 +1,192 @@ +using System; +using System.Collections.Generic; +using System.Linq; + +namespace Ink.Parsed +{ + public class Path + { + public FlowLevel baseTargetLevel { + get { + if (baseLevelIsAmbiguous) + return FlowLevel.Story; + else + return (FlowLevel) _baseTargetLevel; + } + } + + public bool baseLevelIsAmbiguous { + get { + return _baseTargetLevel == null; + } + } + + public string firstComponent { + get { + if (components == null || components.Count == 0) + return null; + + return components [0].name; + } + } + + public int numberOfComponents { + get { + return components.Count; + } + } + + public string dotSeparatedComponents { + get { + if( _dotSeparatedComponents == null ) { + _dotSeparatedComponents = string.Join(".", components.Select(c => c?.name)); + } + + return _dotSeparatedComponents; + } + } + string _dotSeparatedComponents; + + public List components { get; } + + public Path(FlowLevel baseFlowLevel, List components) + { + _baseTargetLevel = baseFlowLevel; + this.components = components; + } + + public Path(List components) + { + _baseTargetLevel = null; + this.components = components; + } + + public Path(Identifier ambiguousName) + { + _baseTargetLevel = null; + components = new List (); + components.Add (ambiguousName); + } + + public override string ToString () + { + if (components == null || components.Count == 0) { + if (baseTargetLevel == FlowLevel.WeavePoint) + return "-> "; + else + return ""; + } + + return "-> " + dotSeparatedComponents; + } + + public Parsed.Object ResolveFromContext(Parsed.Object context) + { + if (components == null || components.Count == 0) { + return null; + } + + // Find base target of path from current context. e.g. + // ==> BASE.sub.sub + var baseTargetObject = ResolveBaseTarget (context); + if (baseTargetObject == null) { + return null; + + } + + // Given base of path, resolve final target by working deeper into hierarchy + // e.g. ==> base.mid.FINAL + if (components.Count > 1) { + return ResolveTailComponents (baseTargetObject); + } + + return baseTargetObject; + } + + // Find the root object from the base, i.e. root from: + // root.sub1.sub2 + Parsed.Object ResolveBaseTarget(Parsed.Object originalContext) + { + var firstComp = firstComponent; + + // Work up the ancestry to find the node that has the named object + Parsed.Object ancestorContext = originalContext; + while (ancestorContext != null) { + + // Only allow deep search when searching deeper from original context. + // Don't allow search upward *then* downward, since that's searching *everywhere*! + // Allowed examples: + // - From an inner gather of a stitch, you should search up to find a knot called 'x' + // at the root of a story, but not a stitch called 'x' in that knot. + // - However, from within a knot, you should be able to find a gather/choice + // anywhere called 'x' + // (that latter example is quite loose, but we allow it) + bool deepSearch = ancestorContext == originalContext; + + var foundBase = TryGetChildFromContext (ancestorContext, firstComp, null, deepSearch); + if (foundBase != null) + return foundBase; + + ancestorContext = ancestorContext.parent; + } + + return null; + } + + // Find the final child from path given root, i.e.: + // root.sub.finalChild + Parsed.Object ResolveTailComponents(Parsed.Object rootTarget) + { + Parsed.Object foundComponent = rootTarget; + for (int i = 1; i < components.Count; ++i) { + var compName = components [i].name; + + FlowLevel minimumExpectedLevel; + var foundFlow = foundComponent as FlowBase; + if (foundFlow != null) + minimumExpectedLevel = (FlowLevel)(foundFlow.flowLevel + 1); + else + minimumExpectedLevel = FlowLevel.WeavePoint; + + + foundComponent = TryGetChildFromContext (foundComponent, compName, minimumExpectedLevel); + if (foundComponent == null) + break; + } + + return foundComponent; + } + + // See whether "context" contains a child with a given name at a given flow level + // Can either be a named knot/stitch (a FlowBase) or a weave point within a Weave (Choice or Gather) + // This function also ignores any other object types that are neither FlowBase nor Weave. + // Called from both ResolveBase (force deep) and ResolveTail for the individual components. + Parsed.Object TryGetChildFromContext(Parsed.Object context, string childName, FlowLevel? minimumLevel, bool forceDeepSearch = false) + { + // null childLevel means that we don't know where to find it + bool ambiguousChildLevel = minimumLevel == null; + + // Search for WeavePoint within Weave + var weaveContext = context as Weave; + if ( weaveContext != null && (ambiguousChildLevel || minimumLevel == FlowLevel.WeavePoint)) { + return (Parsed.Object) weaveContext.WeavePointNamed (childName); + } + + // Search for content within Flow (either a sub-Flow or a WeavePoint) + var flowContext = context as FlowBase; + if (flowContext != null) { + + // When searching within a Knot, allow a deep searches so that + // named weave points (choices and gathers) can be found within any stitch + // Otherwise, we just search within the immediate object. + var shouldDeepSearch = forceDeepSearch || flowContext.flowLevel == FlowLevel.Knot; + return flowContext.ContentWithNameAtLevel (childName, minimumLevel, shouldDeepSearch); + } + + return null; + } + + FlowLevel? _baseTargetLevel; + } +} + diff --git a/Assets/Ink/compiler/ParsedHierarchy/Path.cs.meta b/Assets/Ink/compiler/ParsedHierarchy/Path.cs.meta new file mode 100644 index 000000000..a94a2c0cf --- /dev/null +++ b/Assets/Ink/compiler/ParsedHierarchy/Path.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: 4f327415a36971e42b0f462a1f37f2a2 +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/Assets/Ink/compiler/ParsedHierarchy/Return.cs b/Assets/Ink/compiler/ParsedHierarchy/Return.cs new file mode 100644 index 000000000..2acb78d65 --- /dev/null +++ b/Assets/Ink/compiler/ParsedHierarchy/Return.cs @@ -0,0 +1,39 @@ +namespace Ink.Parsed +{ + public class Return : Parsed.Object + { + public Expression returnedExpression { get; protected set; } + + public Return (Expression returnedExpression = null) + { + if (returnedExpression) { + this.returnedExpression = AddContent(returnedExpression); + } + } + + public override Runtime.Object GenerateRuntimeObject () + { + var container = new Runtime.Container (); + + // Evaluate expression + if (returnedExpression) { + container.AddContent (returnedExpression.runtimeObject); + } + + // Return Runtime.Void when there's no expression to evaluate + // (This evaluation will just add the Void object to the evaluation stack) + else { + container.AddContent (Runtime.ControlCommand.EvalStart ()); + container.AddContent (new Runtime.Void()); + container.AddContent (Runtime.ControlCommand.EvalEnd ()); + } + + // Then pop the call stack + // (the evaluated expression will leave the return value on the evaluation stack) + container.AddContent (Runtime.ControlCommand.PopFunction()); + + return container; + } + } +} + diff --git a/Assets/Ink/compiler/ParsedHierarchy/Return.cs.meta b/Assets/Ink/compiler/ParsedHierarchy/Return.cs.meta new file mode 100644 index 000000000..d2a57a636 --- /dev/null +++ b/Assets/Ink/compiler/ParsedHierarchy/Return.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: 562b9111ffbd032428621f136af53db3 +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/Assets/Ink/compiler/ParsedHierarchy/Sequence.cs b/Assets/Ink/compiler/ParsedHierarchy/Sequence.cs new file mode 100644 index 000000000..b6282808c --- /dev/null +++ b/Assets/Ink/compiler/ParsedHierarchy/Sequence.cs @@ -0,0 +1,206 @@ +using System.Collections.Generic; + +namespace Ink.Parsed +{ + [System.Flags] + public enum SequenceType + { + Stopping = 1, // default + Cycle = 2, + Shuffle = 4, + Once = 8 + } + + public class Sequence : Parsed.Object + { + + public List sequenceElements; + public SequenceType sequenceType; + + public Sequence (List elementContentLists, SequenceType sequenceType) + { + this.sequenceType = sequenceType; + this.sequenceElements = new List (); + + foreach (var elementContentList in elementContentLists) { + + var contentObjs = elementContentList.content; + + Parsed.Object seqElObject = null; + + // Don't attempt to create a weave for the sequence element + // if the content list is empty. Weaves don't like it! + if (contentObjs == null || contentObjs.Count == 0) + seqElObject = elementContentList; + else + seqElObject = new Weave (contentObjs); + + this.sequenceElements.Add (seqElObject); + AddContent (seqElObject); + } + } + + // Generate runtime code that looks like: + // + // chosenIndex = MIN(sequence counter, num elements) e.g. for "Stopping" + // if chosenIndex == 0, divert to s0 + // if chosenIndex == 1, divert to s1 [etc] + // + // - s0: + // + // divert to no-op + // - s1: + // + // divert to no-op + // - s2: + // empty branch if using "once" + // divert to no-op + // + // no-op + // + public override Runtime.Object GenerateRuntimeObject () + { + var container = new Runtime.Container (); + container.visitsShouldBeCounted = true; + container.countingAtStartOnly = true; + + _sequenceDivertsToResove = new List (); + + // Get sequence read count + container.AddContent (Runtime.ControlCommand.EvalStart ()); + container.AddContent (Runtime.ControlCommand.VisitIndex ()); + + bool once = (sequenceType & SequenceType.Once) > 0; + bool cycle = (sequenceType & SequenceType.Cycle) > 0; + bool stopping = (sequenceType & SequenceType.Stopping) > 0; + bool shuffle = (sequenceType & SequenceType.Shuffle) > 0; + + var seqBranchCount = sequenceElements.Count; + if (once) seqBranchCount++; + + // Chosen sequence index: + // - Stopping: take the MIN(read count, num elements - 1) + // - Once: take the MIN(read count, num elements) + // (the last one being empty) + if (stopping || once) { + //var limit = stopping ? seqBranchCount-1 : seqBranchCount; + container.AddContent (new Runtime.IntValue (seqBranchCount-1)); + container.AddContent (Runtime.NativeFunctionCall.CallWithName ("MIN")); + } + + // - Cycle: take (read count % num elements) + else if (cycle) { + container.AddContent (new Runtime.IntValue (sequenceElements.Count)); + container.AddContent (Runtime.NativeFunctionCall.CallWithName ("%")); + } + + // Shuffle + if (shuffle) { + + // Create point to return to when sequence is complete + var postShuffleNoOp = Runtime.ControlCommand.NoOp(); + + // When visitIndex == lastIdx, we skip the shuffle + if ( once || stopping ) + { + // if( visitIndex == lastIdx ) -> skipShuffle + int lastIdx = stopping ? sequenceElements.Count - 1 : sequenceElements.Count; + container.AddContent(Runtime.ControlCommand.Duplicate()); + container.AddContent(new Runtime.IntValue(lastIdx)); + container.AddContent(Runtime.NativeFunctionCall.CallWithName("==")); + + var skipShuffleDivert = new Runtime.Divert(); + skipShuffleDivert.isConditional = true; + container.AddContent(skipShuffleDivert); + + AddDivertToResolve(skipShuffleDivert, postShuffleNoOp); + } + + // This one's a bit more complex! Choose the index at runtime. + var elementCountToShuffle = sequenceElements.Count; + if (stopping) elementCountToShuffle--; + container.AddContent (new Runtime.IntValue (elementCountToShuffle)); + container.AddContent (Runtime.ControlCommand.SequenceShuffleIndex ()); + if (once || stopping) container.AddContent(postShuffleNoOp); + } + + container.AddContent (Runtime.ControlCommand.EvalEnd ()); + + // Create point to return to when sequence is complete + var postSequenceNoOp = Runtime.ControlCommand.NoOp(); + + // Each of the main sequence branches, and one extra empty branch if + // we have a "once" sequence. + for (var elIndex=0; elIndex _sequenceDivertsToResove; + } +} + diff --git a/Assets/Ink/compiler/ParsedHierarchy/Sequence.cs.meta b/Assets/Ink/compiler/ParsedHierarchy/Sequence.cs.meta new file mode 100644 index 000000000..872f4513c --- /dev/null +++ b/Assets/Ink/compiler/ParsedHierarchy/Sequence.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: a23c932006a01fb48a6ec5a0196d7477 +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/Assets/Ink/compiler/ParsedHierarchy/Stitch.cs b/Assets/Ink/compiler/ParsedHierarchy/Stitch.cs new file mode 100644 index 000000000..a4ac723c1 --- /dev/null +++ b/Assets/Ink/compiler/ParsedHierarchy/Stitch.cs @@ -0,0 +1,14 @@ +using System.Collections.Generic; + +namespace Ink.Parsed +{ + public class Stitch : FlowBase + { + public override FlowLevel flowLevel { get { return FlowLevel.Stitch; } } + + public Stitch (Identifier name, List topLevelObjects, List arguments, bool isFunction) : base(name, topLevelObjects, arguments, isFunction) + { + } + } +} + diff --git a/Assets/Ink/compiler/ParsedHierarchy/Stitch.cs.meta b/Assets/Ink/compiler/ParsedHierarchy/Stitch.cs.meta new file mode 100644 index 000000000..c214f9bf3 --- /dev/null +++ b/Assets/Ink/compiler/ParsedHierarchy/Stitch.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: 2ac15710f45838e41bd446b204ca494c +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/Assets/Ink/compiler/ParsedHierarchy/Story.cs b/Assets/Ink/compiler/ParsedHierarchy/Story.cs new file mode 100644 index 000000000..cca1b5e97 --- /dev/null +++ b/Assets/Ink/compiler/ParsedHierarchy/Story.cs @@ -0,0 +1,508 @@ +using System; +using System.Collections.Generic; +using System.Text; +using System.Runtime.CompilerServices; +using System.Diagnostics; + +[assembly: InternalsVisibleTo("tests")] + +namespace Ink.Parsed +{ + public class Story : FlowBase + { + public override FlowLevel flowLevel { get { return FlowLevel.Story; } } + + /// + /// Had error during code gen, resolve references? + /// Most of the time it shouldn't be necessary to use this + /// since errors should be caught by the error handler. + /// + internal bool hadError { get { return _hadError; } } + internal bool hadWarning { get { return _hadWarning; } } + + public Dictionary constants; + public Dictionary externals; + + // Build setting for exporting: + // When true, the visit count for *all* knots, stitches, choices, + // and gathers is counted. When false, only those that are direclty + // referenced by the ink are recorded. Use this flag to allow game-side + // querying of arbitrary knots/stitches etc. + // Storing all counts is more robust and future proof (updates to the story file + // that reference previously uncounted visits are possible, but generates a much + // larger safe file, with a lot of potentially redundant counts. + public bool countAllVisits = false; + + public Story (List toplevelObjects, bool isInclude = false) : base(null, toplevelObjects, isIncludedStory:isInclude) + { + // Don't do anything much on construction, leave it lightweight until + // the ExportRuntime method is called. + } + + // Before this function is called, we have IncludedFile objects interspersed + // in our content wherever an include statement was. + // So that the include statement can be added in a sensible place (e.g. the + // top of the file) without side-effects of jumping into a knot that was + // defined in that include, we separate knots and stitches from anything + // else defined at the top scope of the included file. + // + // Algorithm: For each IncludedFile we find, split its contents into + // knots/stiches and any other content. Insert the normal content wherever + // the include statement was, and append the knots/stitches to the very + // end of the main story. + protected override void PreProcessTopLevelObjects(List topLevelContent) + { + var flowsFromOtherFiles = new List (); + + // Inject included files + int i = 0; + while (i < topLevelContent.Count) { + var obj = topLevelContent [i]; + if (obj is IncludedFile) { + + var file = (IncludedFile)obj; + + // Remove the IncludedFile itself + topLevelContent.RemoveAt (i); + + // When an included story fails to load, the include + // line itself is still valid, so we have to handle it here + if (file.includedStory) { + + var nonFlowContent = new List (); + + var subStory = file.includedStory; + + // Allow empty file + if (subStory.content != null) { + + foreach (var subStoryObj in subStory.content) { + if (subStoryObj is FlowBase) { + flowsFromOtherFiles.Add ((FlowBase)subStoryObj); + } else { + nonFlowContent.Add (subStoryObj); + } + } + + // Add newline on the end of the include + nonFlowContent.Add (new Parsed.Text ("\n")); + + // Add contents of the file in its place + topLevelContent.InsertRange (i, nonFlowContent); + + // Skip past the content of this sub story + // (since it will already have recursively included + // any lines from other files) + i += nonFlowContent.Count; + } + + } + + // Include object has been removed, with possible content inserted, + // and position of 'i' will have been determined already. + continue; + } + + // Non-include: skip over it + else { + i++; + } + } + + // Add the flows we collected from the included files to the + // end of our list of our content + topLevelContent.AddRange (flowsFromOtherFiles.ToArray()); + + } + + public Runtime.Story ExportRuntime(ErrorHandler errorHandler = null) + { + _errorHandler = errorHandler; + + // Find all constants before main export begins, so that VariableReferences know + // whether to generate a runtime variable reference or the literal value + constants = new Dictionary (); + foreach (var constDecl in FindAll ()) { + + // Check for duplicate definitions + Parsed.Expression existingDefinition = null; + if (constants.TryGetValue (constDecl.constantName, out existingDefinition)) { + if (!existingDefinition.Equals (constDecl.expression)) { + var errorMsg = string.Format ("CONST '{0}' has been redefined with a different value. Multiple definitions of the same CONST are valid so long as they contain the same value. Initial definition was on {1}.", constDecl.constantName, existingDefinition.debugMetadata); + Error (errorMsg, constDecl, isWarning:false); + } + } + + constants [constDecl.constantName] = constDecl.expression; + } + + // List definitions are treated like constants too - they should be usable + // from other variable declarations. + _listDefs = new Dictionary (); + foreach (var listDef in FindAll ()) { + _listDefs [listDef.identifier?.name] = listDef; + } + + externals = new Dictionary (); + + // Resolution of weave point names has to come first, before any runtime code generation + // since names have to be ready before diverts start getting created. + // (It used to be done in the constructor for a weave, but didn't allow us to generate + // errors when name resolution failed.) + ResolveWeavePointNaming (); + + // Get default implementation of runtimeObject, which calls ContainerBase's generation method + var rootContainer = runtimeObject as Runtime.Container; + + // Export initialisation of global variables + // TODO: We *could* add this as a declarative block to the story itself... + var variableInitialisation = new Runtime.Container (); + variableInitialisation.AddContent (Runtime.ControlCommand.EvalStart ()); + + // Global variables are those that are local to the story and marked as global + var runtimeLists = new List (); + foreach (var nameDeclPair in variableDeclarations) { + var varName = nameDeclPair.Key; + var varDecl = nameDeclPair.Value; + if (varDecl.isGlobalDeclaration) { + + if (varDecl.listDefinition != null) { + _listDefs[varName] = varDecl.listDefinition; + variableInitialisation.AddContent (varDecl.listDefinition.runtimeObject); + runtimeLists.Add (varDecl.listDefinition.runtimeListDefinition); + } else { + varDecl.expression.GenerateIntoContainer (variableInitialisation); + } + + var runtimeVarAss = new Runtime.VariableAssignment (varName, isNewDeclaration:true); + runtimeVarAss.isGlobal = true; + variableInitialisation.AddContent (runtimeVarAss); + } + } + + variableInitialisation.AddContent (Runtime.ControlCommand.EvalEnd ()); + variableInitialisation.AddContent (Runtime.ControlCommand.End ()); + + if (variableDeclarations.Count > 0) { + variableInitialisation.name = "global decl"; + rootContainer.AddToNamedContentOnly (variableInitialisation); + } + + // Signal that it's safe to exit without error, even if there are no choices generated + // (this only happens at the end of top level content that isn't in any particular knot) + rootContainer.AddContent (Runtime.ControlCommand.Done ()); + + // Replace runtimeObject with Story object instead of the Runtime.Container generated by Parsed.ContainerBase + var runtimeStory = new Runtime.Story (rootContainer, runtimeLists); + + runtimeObject = runtimeStory; + + if (_hadError) + return null; + + // Optimisation step - inline containers that can be + FlattenContainersIn (rootContainer); + + // Now that the story has been fulled parsed into a hierarchy, + // and the derived runtime hierarchy has been built, we can + // resolve referenced symbols such as variables and paths. + // e.g. for paths " -> knotName --> stitchName" into an INKPath (knotName.stitchName) + // We don't make any assumptions that the INKPath follows the same + // conventions as the script format, so we resolve to actual objects before + // translating into an INKPath. (This also allows us to choose whether + // we want the paths to be absolute) + ResolveReferences (this); + + if (_hadError) + return null; + + runtimeStory.ResetState (); + + return runtimeStory; + } + + public ListDefinition ResolveList (string listName) + { + ListDefinition list; + if (!_listDefs.TryGetValue (listName, out list)) + return null; + return list; + } + + public ListElementDefinition ResolveListItem (string listName, string itemName, Parsed.Object source = null) + { + ListDefinition listDef = null; + + // Search a specific list if we know its name (i.e. the form listName.itemName) + if (listName != null) { + if (!_listDefs.TryGetValue (listName, out listDef)) + return null; + + return listDef.ItemNamed (itemName); + } + + // Otherwise, try to search all lists + else { + + ListElementDefinition foundItem = null; + ListDefinition originalFoundList = null; + + foreach (var namedList in _listDefs) { + var listToSearch = namedList.Value; + var itemInThisList = listToSearch.ItemNamed (itemName); + if (itemInThisList) { + if (foundItem != null) { + Error ("Ambiguous item name '" + itemName + "' found in multiple sets, including "+originalFoundList.identifier+" and "+listToSearch.identifier, source, isWarning:false); + } else { + foundItem = itemInThisList; + originalFoundList = listToSearch; + } + } + } + + return foundItem; + } + } + + void FlattenContainersIn (Runtime.Container container) + { + // Need to create a collection to hold the inner containers + // because otherwise we'd end up modifying during iteration + var innerContainers = new HashSet (); + + foreach (var c in container.content) { + var innerContainer = c as Runtime.Container; + if (innerContainer) + innerContainers.Add (innerContainer); + } + + // Can't flatten the named inner containers, but we can at least + // iterate through their children + if (container.namedContent != null) { + foreach (var keyValue in container.namedContent) { + var namedInnerContainer = keyValue.Value as Runtime.Container; + if (namedInnerContainer) + innerContainers.Add (namedInnerContainer); + } + } + + foreach (var innerContainer in innerContainers) { + TryFlattenContainer (innerContainer); + FlattenContainersIn (innerContainer); + } + } + + void TryFlattenContainer (Runtime.Container container) + { + if (container.namedContent.Count > 0 || container.hasValidName || _dontFlattenContainers.Contains(container)) + return; + + // Inline all the content in container into the parent + var parentContainer = container.parent as Runtime.Container; + if (parentContainer) { + + var contentIdx = parentContainer.content.IndexOf (container); + parentContainer.content.RemoveAt (contentIdx); + + var dm = container.ownDebugMetadata; + + foreach (var innerContent in container.content) { + innerContent.parent = null; + if (dm != null && innerContent.ownDebugMetadata == null) + innerContent.debugMetadata = dm; + parentContainer.InsertContent (innerContent, contentIdx); + contentIdx++; + } + } + } + + public override void Error(string message, Parsed.Object source, bool isWarning) + { + ErrorType errorType = isWarning ? ErrorType.Warning : ErrorType.Error; + + var sb = new StringBuilder (); + if (source is AuthorWarning) { + sb.Append ("TODO: "); + errorType = ErrorType.Author; + } else if (isWarning) { + sb.Append ("WARNING: "); + } else { + sb.Append ("ERROR: "); + } + + if (source && source.debugMetadata != null && source.debugMetadata.startLineNumber >= 1 ) { + + if (source.debugMetadata.fileName != null) { + sb.AppendFormat ("'{0}' ", source.debugMetadata.fileName); + } + + sb.AppendFormat ("line {0}: ", source.debugMetadata.startLineNumber); + } + + sb.Append (message); + + message = sb.ToString (); + + if (_errorHandler != null) { + _hadError = errorType == ErrorType.Error; + _hadWarning = errorType == ErrorType.Warning; + _errorHandler (message, errorType); + } else { + throw new System.Exception (message); + } + } + + public void ResetError() + { + _hadError = false; + _hadWarning = false; + } + + public bool IsExternal(string namedFuncTarget) + { + return externals.ContainsKey (namedFuncTarget); + } + + public void AddExternal(ExternalDeclaration decl) + { + if (externals.ContainsKey (decl.name)) { + Error ("Duplicate EXTERNAL definition of '"+decl.name+"'", decl, false); + } else { + externals [decl.name] = decl; + } + } + + public void DontFlattenContainer (Runtime.Container container) + { + _dontFlattenContainers.Add (container); + } + + + + void NameConflictError (Parsed.Object obj, string name, Parsed.Object existingObj, string typeNameToPrint) + { + obj.Error (typeNameToPrint+" '" + name + "': name has already been used for a " + existingObj.typeName.ToLower() + " on " +existingObj.debugMetadata); + } + + public static bool IsReservedKeyword (string name) + { + switch (name) { + case "true": + case "false": + case "not": + case "return": + case "else": + case "VAR": + case "CONST": + case "temp": + case "LIST": + case "function": + return true; + } + + return false; + } + + public enum SymbolType : uint + { + Knot, + List, + ListItem, + Var, + SubFlowAndWeave, + Arg, + Temp + } + + // Check given symbol type against everything that's of a higher priority in the ordered SymbolType enum (above). + // When the given symbol type level is reached, we early-out / return. + public void CheckForNamingCollisions (Parsed.Object obj, Identifier identifier, SymbolType symbolType, string typeNameOverride = null) + { + string typeNameToPrint = typeNameOverride ?? obj.typeName; + if (IsReservedKeyword (identifier?.name)) { + obj.Error ("'"+name + "' cannot be used for the name of a " + typeNameToPrint.ToLower() + " because it's a reserved keyword"); + return; + } + + if (FunctionCall.IsBuiltIn (identifier?.name)) { + obj.Error ("'"+name + "' cannot be used for the name of a " + typeNameToPrint.ToLower() + " because it's a built in function"); + return; + } + + // Top level knots + FlowBase knotOrFunction = ContentWithNameAtLevel (identifier?.name, FlowLevel.Knot) as FlowBase; + if (knotOrFunction && (knotOrFunction != obj || symbolType == SymbolType.Arg)) { + NameConflictError (obj, identifier?.name, knotOrFunction, typeNameToPrint); + return; + } + + if (symbolType < SymbolType.List) return; + + // Lists + foreach (var namedListDef in _listDefs) { + var listDefName = namedListDef.Key; + var listDef = namedListDef.Value; + if (identifier?.name == listDefName && obj != listDef && listDef.variableAssignment != obj) { + NameConflictError (obj, identifier?.name, listDef, typeNameToPrint); + } + + // We don't check for conflicts between individual elements in + // different lists because they are namespaced. + if (!(obj is ListElementDefinition)) { + foreach (var item in listDef.itemDefinitions) { + if (identifier?.name == item.name) { + NameConflictError (obj, identifier?.name, item, typeNameToPrint); + } + } + } + } + + // Don't check for VAR->VAR conflicts because that's handled separately + // (necessary since checking looks up in a dictionary) + if (symbolType <= SymbolType.Var) return; + + // Global variable collision + VariableAssignment varDecl = null; + if (variableDeclarations.TryGetValue(identifier?.name, out varDecl) ) { + if (varDecl != obj && varDecl.isGlobalDeclaration && varDecl.listDefinition == null) { + NameConflictError (obj, identifier?.name, varDecl, typeNameToPrint); + } + } + + if (symbolType < SymbolType.SubFlowAndWeave) return; + + // Stitches, Choices and Gathers + var path = new Path (identifier); + var targetContent = path.ResolveFromContext (obj); + if (targetContent && targetContent != obj) { + NameConflictError (obj, identifier?.name, targetContent, typeNameToPrint); + return; + } + + if (symbolType < SymbolType.Arg) return; + + // Arguments to the current flow + if (symbolType != SymbolType.Arg) { + FlowBase flow = obj as FlowBase; + if( flow == null ) flow = obj.ClosestFlowBase (); + if (flow && flow.hasParameters) { + foreach (var arg in flow.arguments) { + if (arg.identifier?.name == identifier?.name) { + obj.Error (typeNameToPrint+" '" + name + "': Name has already been used for a argument to "+flow.identifier+" on " +flow.debugMetadata); + return; + } + } + } + } + } + + ErrorHandler _errorHandler; + bool _hadError; + bool _hadWarning; + + HashSet _dontFlattenContainers = new HashSet(); + + Dictionary _listDefs; + } +} + diff --git a/Assets/Ink/compiler/ParsedHierarchy/Story.cs.meta b/Assets/Ink/compiler/ParsedHierarchy/Story.cs.meta new file mode 100644 index 000000000..cb90376cd --- /dev/null +++ b/Assets/Ink/compiler/ParsedHierarchy/Story.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: 0d3e48d37073f8f49965133b8157d4e1 +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/Assets/Ink/compiler/ParsedHierarchy/StringExpression.cs b/Assets/Ink/compiler/ParsedHierarchy/StringExpression.cs new file mode 100644 index 000000000..189222d2d --- /dev/null +++ b/Assets/Ink/compiler/ParsedHierarchy/StringExpression.cs @@ -0,0 +1,70 @@ +using System; +using System.Collections.Generic; +using System.Text; + +namespace Ink.Parsed +{ + public class StringExpression : Parsed.Expression + { + public bool isSingleString { + get { + if (content.Count != 1) + return false; + + var c = content [0]; + if (!(c is Text)) + return false; + + return true; + } + } + + public StringExpression (List content) + { + AddContent (content); + } + + public override void GenerateIntoContainer (Runtime.Container container) + { + container.AddContent (Runtime.ControlCommand.BeginString()); + + foreach (var c in content) { + container.AddContent (c.runtimeObject); + } + + container.AddContent (Runtime.ControlCommand.EndString()); + } + + public override string ToString () + { + var sb = new StringBuilder (); + foreach (var c in content) { + sb.Append (c.ToString ()); + } + return sb.ToString (); + } + + // Equals override necessary in order to check for CONST multiple definition equality + public override bool Equals (object obj) + { + var otherStr = obj as StringExpression; + if (otherStr == null) return false; + + // Can only compare direct equality on single strings rather than + // complex string expressions that contain dynamic logic + if (!this.isSingleString || !otherStr.isSingleString) { + return false; + } + + var thisTxt = this.ToString (); + var otherTxt = otherStr.ToString (); + return thisTxt.Equals (otherTxt); + } + + public override int GetHashCode () + { + return this.ToString ().GetHashCode (); + } + } +} + diff --git a/Assets/Ink/compiler/ParsedHierarchy/StringExpression.cs.meta b/Assets/Ink/compiler/ParsedHierarchy/StringExpression.cs.meta new file mode 100644 index 000000000..49afa4cee --- /dev/null +++ b/Assets/Ink/compiler/ParsedHierarchy/StringExpression.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: 4db52858749e1ea438e06835cea4c7ee +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/Assets/Ink/compiler/ParsedHierarchy/Text.cs b/Assets/Ink/compiler/ParsedHierarchy/Text.cs new file mode 100644 index 000000000..f1b59bcae --- /dev/null +++ b/Assets/Ink/compiler/ParsedHierarchy/Text.cs @@ -0,0 +1,24 @@ + +namespace Ink.Parsed +{ + public class Text : Parsed.Object + { + public string text { get; set; } + + public Text (string str) + { + text = str; + } + + public override Runtime.Object GenerateRuntimeObject () + { + return new Runtime.StringValue(this.text); + } + + public override string ToString () + { + return this.text; + } + } +} + diff --git a/Assets/Ink/compiler/ParsedHierarchy/Text.cs.meta b/Assets/Ink/compiler/ParsedHierarchy/Text.cs.meta new file mode 100644 index 000000000..952d00fd4 --- /dev/null +++ b/Assets/Ink/compiler/ParsedHierarchy/Text.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: 3c8cb04fa3e49db4795bcfa6fc57c99b +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/Assets/Ink/compiler/ParsedHierarchy/TunnelOnwards.cs b/Assets/Ink/compiler/ParsedHierarchy/TunnelOnwards.cs new file mode 100644 index 000000000..a47dd38f9 --- /dev/null +++ b/Assets/Ink/compiler/ParsedHierarchy/TunnelOnwards.cs @@ -0,0 +1,85 @@ +using System.Collections.Generic; + +namespace Ink.Parsed +{ + public class TunnelOnwards : Parsed.Object + { + public Divert divertAfter { + get { + return _divertAfter; + } + set { + _divertAfter = value; + if (_divertAfter) AddContent (_divertAfter); + } + } + Divert _divertAfter; + + public override Runtime.Object GenerateRuntimeObject () + { + var container = new Runtime.Container (); + + // Set override path for tunnel onwards (or nothing) + container.AddContent (Runtime.ControlCommand.EvalStart ()); + + if (divertAfter) { + + // Generate runtime object's generated code and steal the arguments runtime code + var returnRuntimeObj = divertAfter.GenerateRuntimeObject (); + var returnRuntimeContainer = returnRuntimeObj as Runtime.Container; + if (returnRuntimeContainer) { + + // Steal all code for generating arguments from the divert + var args = divertAfter.arguments; + if (args != null && args.Count > 0) { + + // Steal everything betwen eval start and eval end + int evalStart = -1; + int evalEnd = -1; + for (int i = 0; i < returnRuntimeContainer.content.Count; i++) { + var cmd = returnRuntimeContainer.content [i] as Runtime.ControlCommand; + if (cmd) { + if (evalStart == -1 && cmd.commandType == Runtime.ControlCommand.CommandType.EvalStart) + evalStart = i; + else if (cmd.commandType == Runtime.ControlCommand.CommandType.EvalEnd) + evalEnd = i; + } + } + + for (int i = evalStart + 1; i < evalEnd; i++) { + var obj = returnRuntimeContainer.content [i]; + obj.parent = null; // prevent error of being moved between owners + container.AddContent (returnRuntimeContainer.content [i]); + } + } + } + + // Finally, divert to the requested target + _overrideDivertTarget = new Runtime.DivertTargetValue (); + container.AddContent (_overrideDivertTarget); + } + + // No divert after tunnel onwards + else { + container.AddContent (new Runtime.Void ()); + } + + container.AddContent (Runtime.ControlCommand.EvalEnd ()); + + container.AddContent (Runtime.ControlCommand.PopTunnel ()); + + return container; + } + + public override void ResolveReferences (Story context) + { + base.ResolveReferences (context); + + if (divertAfter && divertAfter.targetContent) + _overrideDivertTarget.targetPath = divertAfter.targetContent.runtimePath; + } + + Runtime.DivertTargetValue _overrideDivertTarget; + } +} + diff --git a/Assets/Ink/compiler/ParsedHierarchy/TunnelOnwards.cs.meta b/Assets/Ink/compiler/ParsedHierarchy/TunnelOnwards.cs.meta new file mode 100644 index 000000000..94fd2e936 --- /dev/null +++ b/Assets/Ink/compiler/ParsedHierarchy/TunnelOnwards.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: b150e104ab4c6234a95113c7bdddebd8 +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/Assets/Ink/compiler/ParsedHierarchy/VariableAssignment.cs b/Assets/Ink/compiler/ParsedHierarchy/VariableAssignment.cs new file mode 100644 index 000000000..34e281e2e --- /dev/null +++ b/Assets/Ink/compiler/ParsedHierarchy/VariableAssignment.cs @@ -0,0 +1,123 @@ +using System.Collections.Generic; + +namespace Ink.Parsed +{ + public class VariableAssignment : Parsed.Object + { + public string variableName + { + get { return variableIdentifier.name; } + } + public Identifier variableIdentifier { get; protected set; } + public Expression expression { get; protected set; } + public ListDefinition listDefinition { get; protected set; } + + public bool isGlobalDeclaration { get; set; } + public bool isNewTemporaryDeclaration { get; set; } + + public bool isDeclaration { + get { + return isGlobalDeclaration || isNewTemporaryDeclaration; + } + } + + public VariableAssignment (Identifier identifier, Expression assignedExpression) + { + this.variableIdentifier = identifier; + + // Defensive programming in case parsing of assignedExpression failed + if( assignedExpression ) + this.expression = AddContent(assignedExpression); + } + + public VariableAssignment (Identifier identifier, ListDefinition listDef) + { + this.variableIdentifier = identifier; + + if (listDef) { + this.listDefinition = AddContent (listDef); + this.listDefinition.variableAssignment = this; + } + + // List definitions are always global + isGlobalDeclaration = true; + } + + public override Runtime.Object GenerateRuntimeObject () + { + FlowBase newDeclScope = null; + if (isGlobalDeclaration) { + newDeclScope = story; + } else if(isNewTemporaryDeclaration) { + newDeclScope = ClosestFlowBase (); + } + + if( newDeclScope ) + newDeclScope.TryAddNewVariableDeclaration (this); + + // Global declarations don't generate actual procedural + // runtime objects, but instead add a global variable to the story itself. + // The story then initialises them all in one go at the start of the game. + if( isGlobalDeclaration ) + return null; + + var container = new Runtime.Container (); + + // The expression's runtimeObject is actually another nested container + if( expression != null ) + container.AddContent (expression.runtimeObject); + else if( listDefinition != null ) + container.AddContent (listDefinition.runtimeObject); + + _runtimeAssignment = new Runtime.VariableAssignment(variableName, isNewTemporaryDeclaration); + container.AddContent (_runtimeAssignment); + + return container; + } + + public override void ResolveReferences (Story context) + { + base.ResolveReferences (context); + + // List definitions are checked for conflicts separately + if( this.isDeclaration && listDefinition == null ) + context.CheckForNamingCollisions (this, variableIdentifier, this.isGlobalDeclaration ? Story.SymbolType.Var : Story.SymbolType.Temp); + + // Initial VAR x = [intialValue] declaration, not re-assignment + if (this.isGlobalDeclaration) { + var variableReference = expression as VariableReference; + if (variableReference && !variableReference.isConstantReference && !variableReference.isListItemReference) { + Error ("global variable assignments cannot refer to other variables, only literal values, constants and list items"); + } + } + + if (!this.isNewTemporaryDeclaration) { + var resolvedVarAssignment = context.ResolveVariableWithName(this.variableName, fromNode: this); + if (!resolvedVarAssignment.found) { + if (story.constants.ContainsKey (variableName)) { + Error ("Can't re-assign to a constant (do you need to use VAR when declaring '" + this.variableName + "'?)", this); + } else { + Error ("Variable could not be found to assign to: '" + this.variableName + "'", this); + } + } + + // A runtime assignment may not have been generated if it's the initial global declaration, + // since these are hoisted out and handled specially in Story.ExportRuntime. + if( _runtimeAssignment != null ) + _runtimeAssignment.isGlobal = resolvedVarAssignment.isGlobal; + } + } + + + public override string typeName { + get { + if (isNewTemporaryDeclaration) return "temp"; + else if (isGlobalDeclaration) return "VAR"; + else return "variable assignment"; + } + } + + Runtime.VariableAssignment _runtimeAssignment; + } +} + diff --git a/Assets/Ink/compiler/ParsedHierarchy/VariableAssignment.cs.meta b/Assets/Ink/compiler/ParsedHierarchy/VariableAssignment.cs.meta new file mode 100644 index 000000000..a883d1198 --- /dev/null +++ b/Assets/Ink/compiler/ParsedHierarchy/VariableAssignment.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: 9b11fd7e975da714893a6ecf9950f60f +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/Assets/Ink/compiler/ParsedHierarchy/VariableReference.cs b/Assets/Ink/compiler/ParsedHierarchy/VariableReference.cs new file mode 100644 index 000000000..f0359aa54 --- /dev/null +++ b/Assets/Ink/compiler/ParsedHierarchy/VariableReference.cs @@ -0,0 +1,152 @@ +using System.Collections.Generic; +using System.Linq; + +namespace Ink.Parsed +{ + public class VariableReference : Expression + { + // - Normal variables have a single item in their "path" + // - Knot/stitch names for read counts are actual dot-separated paths + // (though this isn't actually used at time of writing) + // - List names are dot separated: listName.itemName (or just itemName) + public string name { get; private set; } + + public Identifier identifier { + get { + // Merging the list of identifiers into a single identifier. + // Debug metadata is also merged. + if (pathIdentifiers == null || pathIdentifiers.Count == 0) { + return null; + } + + if( _singleIdentifier == null ) { + var name = string.Join (".", path.ToArray()); + var firstDebugMetadata = pathIdentifiers.First().debugMetadata; + var debugMetadata = pathIdentifiers.Aggregate(firstDebugMetadata, (acc, id) => acc.Merge(id.debugMetadata)); + _singleIdentifier = new Identifier { name = name, debugMetadata = debugMetadata }; + } + + return _singleIdentifier; + } + } + Identifier _singleIdentifier; + + public List pathIdentifiers; + public List path { get; private set; } + + // Only known after GenerateIntoContainer has run + public bool isConstantReference; + public bool isListItemReference; + + public Runtime.VariableReference runtimeVarRef { get { return _runtimeVarRef; } } + + public VariableReference (List pathIdentifiers) + { + this.pathIdentifiers = pathIdentifiers; + this.path = pathIdentifiers.Select(id => id?.name).ToList(); + this.name = string.Join (".", pathIdentifiers); + } + + public override void GenerateIntoContainer (Runtime.Container container) + { + Expression constantValue = null; + + // If it's a constant reference, just generate the literal expression value + // It's okay to access the constants at code generation time, since the + // first thing the ExportRuntime function does it search for all the constants + // in the story hierarchy, so they're all available. + if ( story.constants.TryGetValue (name, out constantValue) ) { + constantValue.GenerateConstantIntoContainer (container); + isConstantReference = true; + return; + } + + _runtimeVarRef = new Runtime.VariableReference (name); + + // List item reference? + // Path might be to a list (listName.listItemName or just listItemName) + if (path.Count == 1 || path.Count == 2) { + string listItemName = null; + string listName = null; + + if (path.Count == 1) listItemName = path [0]; + else { + listName = path [0]; + listItemName = path [1]; + } + + var listItem = story.ResolveListItem (listName, listItemName, this); + if (listItem) { + isListItemReference = true; + } + } + + container.AddContent (_runtimeVarRef); + } + + public override void ResolveReferences (Story context) + { + base.ResolveReferences (context); + + // Work is already done if it's a constant or list item reference + if (isConstantReference || isListItemReference) { + return; + } + + // Is it a read count? + var parsedPath = new Path (pathIdentifiers); + Parsed.Object targetForCount = parsedPath.ResolveFromContext (this); + if (targetForCount) { + + targetForCount.containerForCounting.visitsShouldBeCounted = true; + + // If this is an argument to a function that wants a variable to be + // passed by reference, then the Parsed.Divert will have generated a + // Runtime.VariablePointerValue instead of allowing this object + // to generate its RuntimeVariableReference. This only happens under + // error condition since we shouldn't be passing a read count by + // reference, but we don't want it to crash! + if (_runtimeVarRef == null) return; + + _runtimeVarRef.pathForCount = targetForCount.runtimePath; + _runtimeVarRef.name = null; + + // Check for very specific writer error: getting read count and + // printing it as content rather than as a piece of logic + // e.g. Writing {myFunc} instead of {myFunc()} + var targetFlow = targetForCount as FlowBase; + if (targetFlow && targetFlow.isFunction) { + + // Is parent context content rather than logic? + if ( parent is Weave || parent is ContentList || parent is FlowBase) { + Warning ("'" + targetFlow.identifier + "' being used as read count rather than being called as function. Perhaps you intended to write " + targetFlow.name + "()"); + } + } + + return; + } + + // Couldn't find this multi-part path at all, whether as a divert + // target or as a list item reference. + if (path.Count > 1) { + var errorMsg = "Could not find target for read count: " + parsedPath; + if (path.Count <= 2) + errorMsg += ", or couldn't find list item with the name " + string.Join (",", path.ToArray()); + Error (errorMsg); + return; + } + + if (!context.ResolveVariableWithName (this.name, fromNode: this).found) { + Error("Unresolved variable: "+this.ToString(), this); + } + } + + public override string ToString () + { + return string.Join(".", path.ToArray()); + } + + Runtime.VariableReference _runtimeVarRef; + } +} + diff --git a/Assets/Ink/compiler/ParsedHierarchy/VariableReference.cs.meta b/Assets/Ink/compiler/ParsedHierarchy/VariableReference.cs.meta new file mode 100644 index 000000000..8ee510e2b --- /dev/null +++ b/Assets/Ink/compiler/ParsedHierarchy/VariableReference.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: f07f270c59e74254698cc0829275a8ae +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/Assets/Ink/compiler/ParsedHierarchy/Weave.cs b/Assets/Ink/compiler/ParsedHierarchy/Weave.cs new file mode 100644 index 000000000..42048e1fc --- /dev/null +++ b/Assets/Ink/compiler/ParsedHierarchy/Weave.cs @@ -0,0 +1,730 @@ +using System.Collections.Generic; + +namespace Ink.Parsed +{ + // Used by the FlowBase when constructing the weave flow from + // a flat list of content objects. + public class Weave : Parsed.Object + { + // Containers can be chained as multiple gather points + // get created as the same indentation level. + // rootContainer is always the first in the chain, while + // currentContainer is the latest. + public Runtime.Container rootContainer { + get { + if (_rootContainer == null) { + GenerateRuntimeObject (); + } + + return _rootContainer; + } + } + Runtime.Container currentContainer { get; set; } + + public int baseIndentIndex { get; private set; } + + // Loose ends are: + // - Choices or Gathers that need to be joined up + // - Explicit Divert to gather points (i.e. "->" without a target) + public List looseEnds; + + public List gatherPointsToResolve; + public class GatherPointToResolve + { + public Runtime.Divert divert; + public Runtime.Object targetRuntimeObj; + } + + public Parsed.Object lastParsedSignificantObject + { + get { + if (content.Count == 0) return null; + + // Don't count extraneous newlines or VAR/CONST declarations, + // since they're "empty" statements outside of the main flow. + Parsed.Object lastObject = null; + for (int i = content.Count - 1; i >= 0; --i) { + lastObject = content [i]; + + var lastText = lastObject as Parsed.Text; + if (lastText && lastText.text == "\n") { + continue; + } + + if (IsGlobalDeclaration (lastObject)) + continue; + + break; + } + + var lastWeave = lastObject as Weave; + if (lastWeave) + lastObject = lastWeave.lastParsedSignificantObject; + + return lastObject; + } + } + + public Weave(List cont, int indentIndex=-1) + { + if (indentIndex == -1) { + baseIndentIndex = DetermineBaseIndentationFromContent (cont); + } else { + baseIndentIndex = indentIndex; + } + + AddContent (cont); + + ConstructWeaveHierarchyFromIndentation (); + } + + public void ResolveWeavePointNaming () + { + var namedWeavePoints = FindAll (w => !string.IsNullOrEmpty (w.name)); + + _namedWeavePoints = new Dictionary (); + + foreach (var weavePoint in namedWeavePoints) { + + // Check for weave point naming collisions + IWeavePoint existingWeavePoint; + if (_namedWeavePoints.TryGetValue (weavePoint.name, out existingWeavePoint)) { + var typeName = existingWeavePoint is Gather ? "gather" : "choice"; + var existingObj = (Parsed.Object)existingWeavePoint; + + Error ("A " + typeName + " with the same label name '" + weavePoint.name + "' already exists in this context on line " + existingObj.debugMetadata.startLineNumber, (Parsed.Object)weavePoint); + } + + _namedWeavePoints [weavePoint.name] = weavePoint; + } + } + + void ConstructWeaveHierarchyFromIndentation() + { + // Find nested indentation and convert to a proper object hierarchy + // (i.e. indented content is replaced with a Weave object that contains + // that nested content) + int contentIdx = 0; + while (contentIdx < content.Count) { + + Parsed.Object obj = content [contentIdx]; + + // Choice or Gather + if (obj is IWeavePoint) { + var weavePoint = (IWeavePoint)obj; + var weaveIndentIdx = weavePoint.indentationDepth - 1; + + // Inner level indentation - recurse + if (weaveIndentIdx > baseIndentIndex) { + + // Step through content until indent jumps out again + int innerWeaveStartIdx = contentIdx; + while (contentIdx < content.Count) { + var innerWeaveObj = content [contentIdx] as IWeavePoint; + if (innerWeaveObj != null) { + var innerIndentIdx = innerWeaveObj.indentationDepth - 1; + if (innerIndentIdx <= baseIndentIndex) { + break; + } + } + + contentIdx++; + } + + int weaveContentCount = contentIdx - innerWeaveStartIdx; + + var weaveContent = content.GetRange (innerWeaveStartIdx, weaveContentCount); + content.RemoveRange (innerWeaveStartIdx, weaveContentCount); + + var weave = new Weave (weaveContent, weaveIndentIdx); + InsertContent (innerWeaveStartIdx, weave); + + // Continue iteration from this point + contentIdx = innerWeaveStartIdx; + } + + } + + contentIdx++; + } + } + + // When the indentation wasn't told to us at construction time using + // a choice point with a known indentation level, we may be told to + // determine the indentation level by incrementing from our closest ancestor. + public int DetermineBaseIndentationFromContent(List contentList) + { + foreach (var obj in contentList) { + if (obj is IWeavePoint) { + return ((IWeavePoint)obj).indentationDepth - 1; + } + } + + // No weave points, so it doesn't matter + return 0; + } + + public override Runtime.Object GenerateRuntimeObject () + { + _rootContainer = currentContainer = new Runtime.Container(); + looseEnds = new List (); + + gatherPointsToResolve = new List (); + + // Iterate through content for the block at this level of indentation + // - Normal content is nested under Choices and Gathers + // - Blocks that are further indented cause recursion + // - Keep track of loose ends so that they can be diverted to Gathers + foreach(var obj in content) { + + // Choice or Gather + if (obj is IWeavePoint) { + AddRuntimeForWeavePoint ((IWeavePoint)obj); + } + + // Non-weave point + else { + + // Nested weave + if (obj is Weave) { + var weave = (Weave)obj; + AddRuntimeForNestedWeave (weave); + gatherPointsToResolve.AddRange (weave.gatherPointsToResolve); + } + + // Other object + // May be complex object that contains statements - e.g. a multi-line conditional + else { + AddGeneralRuntimeContent (obj.runtimeObject); + } + } + } + + // Pass any loose ends up the hierarhcy + PassLooseEndsToAncestors(); + + return _rootContainer; + } + + // Found gather point: + // - gather any loose ends + // - set the gather as the main container to dump new content in + void AddRuntimeForGather(Gather gather) + { + // Determine whether this Gather should be auto-entered: + // - It is auto-entered if there were no choices in the last section + // - A section is "since the previous gather" - so reset now + bool autoEnter = !hasSeenChoiceInSection; + hasSeenChoiceInSection = false; + + var gatherContainer = gather.runtimeContainer; + + if (gather.name == null) { + // Use disallowed character so it's impossible to have a name collision + gatherContainer.name = "g-" + _unnamedGatherCount; + _unnamedGatherCount++; + } + + // Auto-enter: include in main content + if (autoEnter) { + currentContainer.AddContent (gatherContainer); + } + + // Don't auto-enter: + // Add this gather to the main content, but only accessible + // by name so that it isn't stepped into automatically, but only via + // a divert from a loose end. + else { + _rootContainer.AddToNamedContentOnly (gatherContainer); + } + + // Consume loose ends: divert them to this gather + foreach (IWeavePoint looseEndWeavePoint in looseEnds) { + + var looseEnd = (Parsed.Object)looseEndWeavePoint; + + // Skip gather loose ends that are at the same level + // since they'll be handled by the auto-enter code below + // that only jumps into the gather if (current runtime choices == 0) + if (looseEnd is Gather) { + var prevGather = (Gather)looseEnd; + if (prevGather.indentationDepth == gather.indentationDepth) { + continue; + } + } + + Runtime.Divert divert = null; + + if (looseEnd is Parsed.Divert) { + divert = (Runtime.Divert) looseEnd.runtimeObject; + } else { + divert = new Runtime.Divert (); + var looseWeavePoint = looseEnd as IWeavePoint; + looseWeavePoint.runtimeContainer.AddContent (divert); + } + + // Pass back knowledge of this loose end being diverted + // to the FlowBase so that it can maintain a list of them, + // and resolve the divert references later + gatherPointsToResolve.Add (new GatherPointToResolve{ divert = divert, targetRuntimeObj = gatherContainer }); + } + looseEnds.Clear (); + + // Replace the current container itself + currentContainer = gatherContainer; + } + + void AddRuntimeForWeavePoint(IWeavePoint weavePoint) + { + // Current level Gather + if (weavePoint is Gather) { + AddRuntimeForGather ((Gather)weavePoint); + } + + // Current level choice + else if (weavePoint is Choice) { + + // Gathers that contain choices are no longer loose ends + // (same as when weave points get nested content) + if (previousWeavePoint is Gather) { + looseEnds.Remove (previousWeavePoint); + } + + // Add choice point content + var choice = (Choice)weavePoint; + currentContainer.AddContent (choice.runtimeObject); + + // Add choice's inner content to self + choice.innerContentContainer.name = "c-" + _choiceCount; + currentContainer.AddToNamedContentOnly (choice.innerContentContainer); + _choiceCount++; + + hasSeenChoiceInSection = true; + } + + // Keep track of loose ends + addContentToPreviousWeavePoint = false; // default + if (WeavePointHasLooseEnd (weavePoint)) { + looseEnds.Add (weavePoint); + + + var looseChoice = weavePoint as Choice; + if (looseChoice) { + addContentToPreviousWeavePoint = true; + } + } + previousWeavePoint = weavePoint; + } + + // Add nested block at a greater indentation level + public void AddRuntimeForNestedWeave(Weave nestedResult) + { + // Add this inner block to current container + // (i.e. within the main container, or within the last defined Choice/Gather) + AddGeneralRuntimeContent (nestedResult.rootContainer); + + // Now there's a deeper indentation level, the previous weave point doesn't + // count as a loose end (since it will have content to go to) + if (previousWeavePoint != null) { + looseEnds.Remove (previousWeavePoint); + addContentToPreviousWeavePoint = false; + } + } + + // Normal content gets added into the latest Choice or Gather by default, + // unless there hasn't been one yet. + void AddGeneralRuntimeContent(Runtime.Object content) + { + // Content is allowed to evaluate runtimeObject to null + // (e.g. AuthorWarning, which doesn't make it into the runtime) + if (content == null) + return; + + if (addContentToPreviousWeavePoint) { + previousWeavePoint.runtimeContainer.AddContent (content); + } else { + currentContainer.AddContent (content); + } + } + + void PassLooseEndsToAncestors() + { + if (looseEnds.Count == 0) return; + + // Search for Weave ancestor to pass loose ends to for gathering. + // There are two types depending on whether the current weave + // is separated by a conditional or sequence. + // - An "inner" weave is one that is directly connected to the current + // weave - i.e. you don't have to pass through a conditional or + // sequence to get to it. We're allowed to pass all loose ends to + // one of these. + // - An "outer" weave is one that is outside of a conditional/sequence + // that the current weave is nested within. We're only allowed to + // pass gathers (i.e. 'normal flow') loose ends up there, not normal + // choices. The rule is that choices have to be diverted explicitly + // by the author since it's ambiguous where flow should go otherwise. + // + // e.g.: + // + // - top <- e.g. outer weave + // {true: + // * choice <- e.g. inner weave + // * * choice 2 + // more content <- e.g. current weave + // * choice 2 + // } + // - more of outer weave + // + Weave closestInnerWeaveAncestor = null; + Weave closestOuterWeaveAncestor = null; + + // Find inner and outer ancestor weaves as defined above. + bool nested = false; + for (var ancestor = this.parent; ancestor != null; ancestor = ancestor.parent) + { + + // Found ancestor? + var weaveAncestor = ancestor as Weave; + if (weaveAncestor != null) + { + if (!nested && closestInnerWeaveAncestor == null) + closestInnerWeaveAncestor = weaveAncestor; + + if (nested && closestOuterWeaveAncestor == null) + closestOuterWeaveAncestor = weaveAncestor; + } + + + // Weaves nested within Sequences or Conditionals are + // "sealed" - any loose ends require explicit diverts. + if (ancestor is Sequence || ancestor is Conditional) + nested = true; + } + + // No weave to pass loose ends to at all? + if (closestInnerWeaveAncestor == null && closestOuterWeaveAncestor == null) + return; + + // Follow loose end passing logic as defined above + for (int i = looseEnds.Count - 1; i >= 0; i--) { + var looseEnd = looseEnds[i]; + + bool received = false; + + // This weave is nested within a conditional or sequence: + // - choices can only be passed up to direct ancestor ("inner") weaves + // - gathers can be passed up to either, but favour the closer (inner) weave + // if there is one + if(nested) { + if( looseEnd is Choice && closestInnerWeaveAncestor != null) { + closestInnerWeaveAncestor.ReceiveLooseEnd(looseEnd); + received = true; + } + + else if( !(looseEnd is Choice) ) { + var receivingWeave = closestInnerWeaveAncestor ?? closestOuterWeaveAncestor; + if(receivingWeave != null) { + receivingWeave.ReceiveLooseEnd(looseEnd); + received = true; + } + } + } + + // No nesting, all loose ends can be safely passed up + else { + closestInnerWeaveAncestor.ReceiveLooseEnd(looseEnd); + received = true; + } + + if(received) looseEnds.RemoveAt(i); + } + } + + void ReceiveLooseEnd(IWeavePoint childWeaveLooseEnd) + { + looseEnds.Add(childWeaveLooseEnd); + } + + public override void ResolveReferences(Story context) + { + base.ResolveReferences (context); + + // Check that choices nested within conditionals and sequences are terminated + if( looseEnds != null && looseEnds.Count > 0 ) { + var isNestedWeave = false; + for (var ancestor = this.parent; ancestor != null; ancestor = ancestor.parent) + { + if (ancestor is Sequence || ancestor is Conditional) + { + isNestedWeave = true; + break; + } + } + if (isNestedWeave) + { + ValidateTermination(BadNestedTerminationHandler); + } + } + + foreach(var gatherPoint in gatherPointsToResolve) { + gatherPoint.divert.targetPath = gatherPoint.targetRuntimeObj.path; + } + + CheckForWeavePointNamingCollisions (); + } + + public IWeavePoint WeavePointNamed(string name) + { + if (_namedWeavePoints == null) + return null; + + IWeavePoint weavePointResult = null; + if (_namedWeavePoints.TryGetValue (name, out weavePointResult)) + return weavePointResult; + + return null; + } + + // Global VARs and CONSTs are treated as "outside of the flow" + // when iterating over content that follows loose ends + bool IsGlobalDeclaration (Parsed.Object obj) + { + + var varAss = obj as VariableAssignment; + if (varAss && varAss.isGlobalDeclaration && varAss.isDeclaration) + return true; + + var constDecl = obj as ConstantDeclaration; + if (constDecl) + return true; + + return false; + } + + // While analysing final loose ends, we look to see whether there + // are any diverts etc which choices etc divert from + IEnumerable ContentThatFollowsWeavePoint (IWeavePoint weavePoint) + { + var obj = (Parsed.Object)weavePoint; + + // Inner content first (e.g. for a choice) + if (obj.content != null) { + foreach (var contentObj in obj.content) { + + // Global VARs and CONSTs are treated as "outside of the flow" + if (IsGlobalDeclaration (contentObj)) continue; + + yield return contentObj; + } + } + + + var parentWeave = obj.parent as Weave; + if (parentWeave == null) { + throw new System.Exception ("Expected weave point parent to be weave?"); + } + + var weavePointIdx = parentWeave.content.IndexOf (obj); + + for (int i = weavePointIdx+1; i < parentWeave.content.Count; i++) { + var laterObj = parentWeave.content [i]; + + // Global VARs and CONSTs are treated as "outside of the flow" + if (IsGlobalDeclaration (laterObj)) continue; + + // End of the current flow + if (laterObj is IWeavePoint) + break; + + // Other weaves will be have their own loose ends + if (laterObj is Weave) + break; + + yield return laterObj; + } + } + + public delegate void BadTerminationHandler (Parsed.Object terminatingObj); + public void ValidateTermination (BadTerminationHandler badTerminationHandler) + { + // Don't worry if the last object in the flow is a "TODO", + // even if there are other loose ends in other places + if (lastParsedSignificantObject is AuthorWarning) { + return; + } + + // By now, any sub-weaves will have passed loose ends up to the root weave (this). + // So there are 2 possible situations: + // - There are loose ends from somewhere in the flow. + // These aren't necessarily "real" loose ends - they're weave points + // that don't connect to any lower weave points, so we just + // have to check that they terminate properly. + // - This weave is just a list of content with no actual weave points, + // so we just need to check that the list of content terminates. + + bool hasLooseEnds = looseEnds != null && looseEnds.Count > 0; + + if (hasLooseEnds) { + foreach (var looseEnd in looseEnds) { + var looseEndFlow = ContentThatFollowsWeavePoint (looseEnd); + ValidateFlowOfObjectsTerminates (looseEndFlow, (Parsed.Object)looseEnd, badTerminationHandler); + } + } + + // No loose ends... is there any inner weaving at all? + // If not, make sure the single content stream is terminated correctly + else { + + // If there's any actual weaving, assume that content is + // terminated correctly since we would've had a loose end otherwise + foreach (var obj in content) { + if (obj is IWeavePoint) return; + } + + // Straight linear flow? Check it terminates + ValidateFlowOfObjectsTerminates (content, this, badTerminationHandler); + } + } + + void BadNestedTerminationHandler(Parsed.Object terminatingObj) + { + Conditional conditional = null; + for (var ancestor = terminatingObj.parent; ancestor != null; ancestor = ancestor.parent) { + if( ancestor is Sequence || ancestor is Conditional ) { + conditional = ancestor as Conditional; + break; + } + } + + var errorMsg = "Choices nested in conditionals or sequences need to explicitly divert afterwards."; + + // Tutorialise proper choice syntax if this looks like a single choice within a condition, e.g. + // { condition: + // * choice + // } + if (conditional != null) { + var numChoices = conditional.FindAll().Count; + if( numChoices == 1 ) { + errorMsg = "Choices with conditions should be written: '* {condition} choice'. Otherwise, "+ errorMsg.ToLower(); + } + } + + Error(errorMsg, terminatingObj); + } + + void ValidateFlowOfObjectsTerminates (IEnumerable objFlow, Parsed.Object defaultObj, BadTerminationHandler badTerminationHandler) + { + bool terminated = false; + Parsed.Object terminatingObj = defaultObj; + foreach (var flowObj in objFlow) { + + var divert = flowObj.Find (d => !d.isThread && !d.isTunnel && !d.isFunctionCall && !(d.parent is DivertTarget)); + if (divert != null) { + terminated = true; + } + + if (flowObj.Find () != null) { + terminated = true; + break; + } + + terminatingObj = flowObj; + } + + + if (!terminated) { + + // Author has left a note to self here - clearly we don't need + // to leave them with another warning since they know what they're doing. + if (terminatingObj is AuthorWarning) { + return; + } + + badTerminationHandler (terminatingObj); + } + } + + bool WeavePointHasLooseEnd(IWeavePoint weavePoint) + { + // No content, must be a loose end. + if (weavePoint.content == null) return true; + + // If a weave point is diverted from, it doesn't have a loose end. + // Detect a divert object within a weavePoint's main content + // Work backwards since we're really interested in the end, + // although it doesn't actually make a difference! + // (content after a divert will simply be inaccessible) + for (int i = weavePoint.content.Count - 1; i >= 0; --i) { + var innerDivert = weavePoint.content [i] as Divert; + if (innerDivert) { + bool willReturn = innerDivert.isThread || innerDivert.isTunnel || innerDivert.isFunctionCall; + if (!willReturn) return false; + } + } + + return true; + } + + // Enforce rule that weave points must not have the same + // name as any stitches or knots upwards in the hierarchy + void CheckForWeavePointNamingCollisions() + { + if (_namedWeavePoints == null) + return; + + var ancestorFlows = new List (); + foreach (var obj in this.ancestry) { + var flow = obj as FlowBase; + if (flow) + ancestorFlows.Add (flow); + else + break; + } + + + foreach (var namedWeavePointPair in _namedWeavePoints) { + var weavePointName = namedWeavePointPair.Key; + var weavePoint = (Parsed.Object) namedWeavePointPair.Value; + + foreach(var flow in ancestorFlows) { + + // Shallow search + var otherContentWithName = flow.ContentWithNameAtLevel (weavePointName); + + if (otherContentWithName && otherContentWithName != weavePoint) { + var errorMsg = string.Format ("{0} '{1}' has the same label name as a {2} (on {3})", + weavePoint.GetType().Name, + weavePointName, + otherContentWithName.GetType().Name, + otherContentWithName.debugMetadata); + + Error(errorMsg, (Parsed.Object) weavePoint); + } + + } + } + } + + // Keep track of previous weave point (Choice or Gather) + // at the current indentation level: + // - to add ordinary content to be nested under it + // - to add nested content under it when it's indented + // - to remove it from the list of loose ends when + // - it has indented content since it's no longer a loose end + // - it's a gather and it has a choice added to it + IWeavePoint previousWeavePoint = null; + bool addContentToPreviousWeavePoint = false; + + // Used for determining whether the next Gather should auto-enter + bool hasSeenChoiceInSection = false; + + int _unnamedGatherCount; + + int _choiceCount; + + + Runtime.Container _rootContainer; + Dictionary _namedWeavePoints; + } +} + diff --git a/Assets/Ink/compiler/ParsedHierarchy/Weave.cs.meta b/Assets/Ink/compiler/ParsedHierarchy/Weave.cs.meta new file mode 100644 index 000000000..277c4e5b7 --- /dev/null +++ b/Assets/Ink/compiler/ParsedHierarchy/Weave.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: b4246f12808c0104dbba368744d9e43b +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/Assets/Ink/compiler/ParsedHierarchy/Wrap.cs b/Assets/Ink/compiler/ParsedHierarchy/Wrap.cs new file mode 100644 index 000000000..d6b435a9b --- /dev/null +++ b/Assets/Ink/compiler/ParsedHierarchy/Wrap.cs @@ -0,0 +1,27 @@ + +namespace Ink.Parsed +{ + public class Wrap : Parsed.Object where T : Runtime.Object + { + public Wrap (T objToWrap) + { + _objToWrap = objToWrap; + } + + public override Runtime.Object GenerateRuntimeObject () + { + return _objToWrap; + } + + T _objToWrap; + } + + // Shorthand for writing Parsed.Wrap and Parsed.Wrap + public class Glue : Wrap { + public Glue (Runtime.Glue glue) : base(glue) {} + } + public class Tag : Wrap { + public Tag (Runtime.Tag tag) : base (tag) { } + } +} + diff --git a/Assets/Ink/compiler/ParsedHierarchy/Wrap.cs.meta b/Assets/Ink/compiler/ParsedHierarchy/Wrap.cs.meta new file mode 100644 index 000000000..c07a8781d --- /dev/null +++ b/Assets/Ink/compiler/ParsedHierarchy/Wrap.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: 29a76a6c4b4014c45ae0c350251009f2 +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/Assets/Ink/compiler/Plugins.meta b/Assets/Ink/compiler/Plugins.meta new file mode 100644 index 000000000..c94b3527c --- /dev/null +++ b/Assets/Ink/compiler/Plugins.meta @@ -0,0 +1,8 @@ +fileFormatVersion: 2 +guid: 252b1de67c607c941818fcbd7d630331 +folderAsset: yes +DefaultImporter: + externalObjects: {} + userData: + assetBundleName: + assetBundleVariant: diff --git a/Assets/Ink/compiler/Plugins/Plugin.cs b/Assets/Ink/compiler/Plugins/Plugin.cs new file mode 100644 index 000000000..c56e98cd3 --- /dev/null +++ b/Assets/Ink/compiler/Plugins/Plugin.cs @@ -0,0 +1,19 @@ +using System; + +namespace Ink +{ + public interface IPlugin + { + // Hooks: if in doubt use PostExport, since the parsedStory is in a more finalised state. + + // Hook for immediately after the story has been parsed into its basic Parsed hierarchy. + // Could be useful for modifying the story before it's exported. + void PostParse(Parsed.Story parsedStory); + + // Hook for after parsed story has been converted into its runtime equivalent. Note that + // during this process the parsed story will have changed structure too, to take into + // account analysis of the structure of Weave, for example. + void PostExport(Parsed.Story parsedStory, Runtime.Story runtimeStory); + } +} + diff --git a/Assets/Ink/compiler/Plugins/Plugin.cs.meta b/Assets/Ink/compiler/Plugins/Plugin.cs.meta new file mode 100644 index 000000000..02289140d --- /dev/null +++ b/Assets/Ink/compiler/Plugins/Plugin.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: 86d9cdbddbacc9a42863d36046df24df +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/Assets/Ink/compiler/Plugins/PluginManager.cs b/Assets/Ink/compiler/Plugins/PluginManager.cs new file mode 100644 index 000000000..60421c130 --- /dev/null +++ b/Assets/Ink/compiler/Plugins/PluginManager.cs @@ -0,0 +1,40 @@ +using System; +using System.Collections.Generic; + +namespace Ink +{ + public class PluginManager + { + public PluginManager (List pluginNames) + { + _plugins = new List (); + + // TODO: Make these plugin names DLL filenames, and load up their assemblies + foreach (string pluginName in pluginNames) { + //if (pluginName == "ChoiceListPlugin") { + // _plugins.Add (new InkPlugin.ChoiceListPlugin ()); + //}else + { + throw new System.Exception ("Plugin not found"); + } + } + } + + public void PostParse(Parsed.Story parsedStory) + { + foreach (var plugin in _plugins) { + plugin.PostParse (parsedStory); + } + } + + public void PostExport(Parsed.Story parsedStory, Runtime.Story runtimeStory) + { + foreach (var plugin in _plugins) { + plugin.PostExport (parsedStory, runtimeStory); + } + } + + List _plugins; + } +} + diff --git a/Assets/Ink/compiler/Plugins/PluginManager.cs.meta b/Assets/Ink/compiler/Plugins/PluginManager.cs.meta new file mode 100644 index 000000000..3cdaff293 --- /dev/null +++ b/Assets/Ink/compiler/Plugins/PluginManager.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: 84a0e05f4ea45964cb00f7df3f80b52e +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/Assets/Ink/compiler/Stats.cs b/Assets/Ink/compiler/Stats.cs new file mode 100644 index 000000000..2f5d56689 --- /dev/null +++ b/Assets/Ink/compiler/Stats.cs @@ -0,0 +1,68 @@ + +namespace Ink { + public struct Stats { + + public int words; + public int knots; + public int stitches; + public int functions; + public int choices; + public int gathers; + public int diverts; + + public static Stats Generate(Ink.Parsed.Story story) { + var stats = new Stats(); + + var allText = story.FindAll(); + + // Count all the words across all strings + stats.words = 0; + foreach(var text in allText) { + + var wordsInThisStr = 0; + var wasWhiteSpace = true; + foreach(var c in text.text) { + if( c == ' ' || c == '\t' || c == '\n' || c == '\r' ) { + wasWhiteSpace = true; + } else if( wasWhiteSpace ) { + wordsInThisStr++; + wasWhiteSpace = false; + } + } + + stats.words += wordsInThisStr; + } + + var knots = story.FindAll(); + stats.knots = knots.Count; + + stats.functions = 0; + foreach(var knot in knots) + if (knot.isFunction) stats.functions++; + + var stitches = story.FindAll(); + stats.stitches = stitches.Count; + + var choices = story.FindAll(); + stats.choices = choices.Count; + + // Skip implicit gather that's generated at top of story + // (we know which it is because it isn't assigned debug metadata) + var gathers = story.FindAll(g => g.debugMetadata != null); + stats.gathers = gathers.Count; + + // May not be entirely what you expect. + // Does it nevertheless have value? + // Includes: + // - DONE, END + // - Function calls + // - Some implicitly generated weave diverts + // But we subtract one for the implicit DONE + // at the end of the main flow outside of knots. + var diverts = story.FindAll(); + stats.diverts = diverts.Count - 1; + + return stats; + } + } +} \ No newline at end of file diff --git a/Assets/Ink/compiler/Stats.cs.meta b/Assets/Ink/compiler/Stats.cs.meta new file mode 100644 index 000000000..c27c6bc89 --- /dev/null +++ b/Assets/Ink/compiler/Stats.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: 07aecb738f7788b4e94dc7f34fecb4ea +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/Assets/Ink/compiler/StringParser.meta b/Assets/Ink/compiler/StringParser.meta new file mode 100644 index 000000000..2a536ea1e --- /dev/null +++ b/Assets/Ink/compiler/StringParser.meta @@ -0,0 +1,8 @@ +fileFormatVersion: 2 +guid: f8a64abff1ec50e469e2dd81749c6610 +folderAsset: yes +DefaultImporter: + externalObjects: {} + userData: + assetBundleName: + assetBundleVariant: diff --git a/Assets/Ink/compiler/StringParser/StringParser.cs b/Assets/Ink/compiler/StringParser/StringParser.cs new file mode 100644 index 000000000..6feed54cc --- /dev/null +++ b/Assets/Ink/compiler/StringParser/StringParser.cs @@ -0,0 +1,685 @@ +using System; +using System.Collections.Generic; +using System.Reflection; +using System.Diagnostics; +using System.Text; + +namespace Ink +{ + public class StringParser + { + public delegate object ParseRule(); + + public delegate T SpecificParseRule() where T : class; + + public delegate void ErrorHandler(string message, int index, int lineIndex, bool isWarning); + + public StringParser (string str) + { + str = PreProcessInputString (str); + + state = new StringParserState(); + + if (str != null) { + _chars = str.ToCharArray (); + } else { + _chars = new char[0]; + } + + inputString = str; + } + + public class ParseSuccessStruct {}; + public static ParseSuccessStruct ParseSuccess = new ParseSuccessStruct(); + + public static CharacterSet numbersCharacterSet = new CharacterSet("0123456789"); + + protected ErrorHandler errorHandler { get; set; } + + public char currentCharacter + { + get + { + if (index >= 0 && remainingLength > 0) { + return _chars [index]; + } else { + return (char)0; + } + } + } + + public StringParserState state { get; private set; } + + public bool hadError { get; protected set; } + + // Don't do anything by default, but provide ability for subclasses + // to manipulate the string before it's used as input (converted to a char array) + protected virtual string PreProcessInputString(string str) + { + return str; + } + + //-------------------------------- + // Parse state + //-------------------------------- + + protected int BeginRule() + { + return state.Push (); + } + + protected object FailRule(int expectedRuleId) + { + state.Pop (expectedRuleId); + return null; + } + + protected void CancelRule(int expectedRuleId) + { + state.Pop (expectedRuleId); + } + + protected object SucceedRule(int expectedRuleId, object result = null) + { + // Get state at point where this rule stared evaluating + var stateAtSucceedRule = state.Peek(expectedRuleId); + var stateAtBeginRule = state.PeekPenultimate (); + + + // Allow subclass to receive callback + RuleDidSucceed (result, stateAtBeginRule, stateAtSucceedRule); + + // Flatten state stack so that we maintain the same values, + // but remove one level in the stack. + state.Squash(); + + if (result == null) { + result = ParseSuccess; + } + + return result; + } + + protected virtual void RuleDidSucceed(object result, StringParserState.Element startState, StringParserState.Element endState) + { + + } + + protected object Expect(ParseRule rule, string message = null, ParseRule recoveryRule = null) + { + object result = ParseObject(rule); + if (result == null) { + if (message == null) { + message = rule.Method.Name; + } + + string butSaw; + string lineRemainder = LineRemainder (); + if (lineRemainder == null || lineRemainder.Length == 0) { + butSaw = "end of line"; + } else { + butSaw = "'" + lineRemainder + "'"; + } + + Error ("Expected "+message+" but saw "+butSaw); + + if (recoveryRule != null) { + result = recoveryRule (); + } + } + return result; + } + + protected void Error(string message, bool isWarning = false) + { + ErrorOnLine (message, lineIndex + 1, isWarning); + } + + protected void ErrorWithParsedObject(string message, Parsed.Object result, bool isWarning = false) + { + ErrorOnLine (message, result.debugMetadata.startLineNumber, isWarning); + } + + protected void ErrorOnLine(string message, int lineNumber, bool isWarning) + { + if ( !state.errorReportedAlreadyInScope ) { + + var errorType = isWarning ? "Warning" : "Error"; + + if (errorHandler == null) { + throw new System.Exception (errorType+" on line " + lineNumber + ": " + message); + } else { + errorHandler (message, index, lineNumber-1, isWarning); + } + + state.NoteErrorReported (); + } + + if( !isWarning ) + hadError = true; + } + + protected void Warning(string message) + { + Error(message, isWarning:true); + } + + public bool endOfInput + { + get { return index >= _chars.Length; } + } + + public string remainingString + { + get { + return new string(_chars, index, remainingLength); + } + } + + public string LineRemainder() + { + return (string) Peek (() => ParseUntilCharactersFromString ("\n\r")); + } + + public int remainingLength + { + get { + return _chars.Length - index; + } + } + + public string inputString { get; private set; } + + + public int lineIndex + { + set { + state.lineIndex = value; + } + get { + return state.lineIndex; + } + } + + public int characterInLineIndex + { + set { + state.characterInLineIndex = value; + } + get { + return state.characterInLineIndex; + } + } + + public int index + { + // If we want subclass parsers to be able to set the index directly, + // then we would need to know what the lineIndex of the new + // index would be - would we have to step through manually + // counting the newlines to do so? + private set { + state.characterIndex = value; + } + get { + return state.characterIndex; + } + } + + public void SetFlag(uint flag, bool trueOrFalse) { + if (trueOrFalse) { + state.customFlags |= flag; + } else { + state.customFlags &= ~flag; + } + } + + public bool GetFlag(uint flag) { + return (state.customFlags & flag) != 0; + } + + //-------------------------------- + // Structuring + //-------------------------------- + + public object ParseObject(ParseRule rule) + { + int ruleId = BeginRule (); + + var stackHeightBefore = state.stackHeight; + + var result = rule (); + + if (stackHeightBefore != state.stackHeight) { + throw new System.Exception ("Mismatched Begin/Fail/Succeed rules"); + } + + if (result == null) + return FailRule (ruleId); + + SucceedRule (ruleId, result); + return result; + } + + public T Parse(SpecificParseRule rule) where T : class + { + int ruleId = BeginRule (); + + var result = rule () as T; + if (result == null) { + FailRule (ruleId); + return null; + } + + SucceedRule (ruleId, result); + return result; + } + + public object OneOf(params ParseRule[] array) + { + foreach (ParseRule rule in array) { + object result = ParseObject(rule); + if (result != null) + return result; + } + + return null; + } + + public List OneOrMore(ParseRule rule) + { + var results = new List (); + + object result = null; + do { + result = ParseObject(rule); + if( result != null ) { + results.Add(result); + } + } while(result != null); + + if (results.Count > 0) { + return results; + } else { + return null; + } + } + + public ParseRule Optional(ParseRule rule) + { + return () => { + object result = ParseObject(rule); + if( result == null ) { + result = ParseSuccess; + } + return result; + }; + } + + // Return ParseSuccess instead the real result so that it gets excluded + // from result arrays (e.g. Interleave) + public ParseRule Exclude(ParseRule rule) + { + return () => { + object result = ParseObject(rule); + if( result == null ) { + return null; + } + return ParseSuccess; + }; + } + + // Combination of both of the above + public ParseRule OptionalExclude(ParseRule rule) + { + return () => { + ParseObject(rule); + return ParseSuccess; + }; + } + + // Convenience method for creating more readable ParseString rules that can be combined + // in other structuring rules (like OneOf etc) + // e.g. OneOf(String("one"), String("two")) + protected ParseRule String(string str) + { + return () => ParseString (str); + } + + private void TryAddResultToList(object result, List list, bool flatten = true) + { + if (result == ParseSuccess) { + return; + } + + if (flatten) { + var resultCollection = result as System.Collections.ICollection; + if (resultCollection != null) { + foreach (object obj in resultCollection) { + Debug.Assert (obj is T); + list.Add ((T)obj); + } + return; + } + } + + Debug.Assert (result is T); + list.Add ((T)result); + } + + + public List Interleave(ParseRule ruleA, ParseRule ruleB, ParseRule untilTerminator = null, bool flatten = true) + { + int ruleId = BeginRule (); + + var results = new List (); + + // First outer padding + var firstA = ParseObject(ruleA); + if (firstA == null) { + return (List) FailRule(ruleId); + } else { + TryAddResultToList(firstA, results, flatten); + } + + object lastMainResult = null, outerResult = null; + do { + + // "until" condition hit? + if( untilTerminator != null && Peek(untilTerminator) != null ) { + break; + } + + // Main inner + lastMainResult = ParseObject(ruleB); + if( lastMainResult == null ) { + break; + } else { + TryAddResultToList(lastMainResult, results, flatten); + } + + // Outer result (i.e. last A in ABA) + outerResult = null; + if( lastMainResult != null ) { + outerResult = ParseObject(ruleA); + if (outerResult == null) { + break; + } else { + TryAddResultToList(outerResult, results, flatten); + } + } + + // Stop if there are no results, or if both are the placeholder "ParseSuccess" (i.e. Optional success rather than a true value) + } while((lastMainResult != null || outerResult != null) + && !(lastMainResult == ParseSuccess && outerResult == ParseSuccess) && remainingLength > 0); + + if (results.Count == 0) { + return (List) FailRule(ruleId); + } + + return (List) SucceedRule(ruleId, results); + } + + //-------------------------------- + // Basic string parsing + //-------------------------------- + + public string ParseString(string str) + { + if (str.Length > remainingLength) { + return null; + } + + int ruleId = BeginRule (); + + // Optimisation from profiling: + // Store in temporary local variables + // since they're properties that would have to access + // the rule stack every time otherwise. + int i = index; + int cli = characterInLineIndex; + int li = lineIndex; + + bool success = true; + foreach (char c in str) { + if ( _chars[i] != c) { + success = false; + break; + } + if (c == '\n') { + li++; + cli = -1; + } + i++; + cli++; + } + + index = i; + characterInLineIndex = cli; + lineIndex = li; + + if (success) { + return (string) SucceedRule(ruleId, str); + } + else { + return (string) FailRule (ruleId); + } + } + + public char ParseSingleCharacter() + { + if (remainingLength > 0) { + char c = _chars [index]; + if (c == '\n') { + lineIndex++; + characterInLineIndex = -1; + } + index++; + characterInLineIndex++; + return c; + } else { + return (char)0; + } + } + + public string ParseUntilCharactersFromString(string str, int maxCount = -1) + { + return ParseCharactersFromString(str, false, maxCount); + } + + public string ParseUntilCharactersFromCharSet(CharacterSet charSet, int maxCount = -1) + { + return ParseCharactersFromCharSet(charSet, false, maxCount); + } + + public string ParseCharactersFromString(string str, int maxCount = -1) + { + return ParseCharactersFromString(str, true, maxCount); + } + + public string ParseCharactersFromString(string str, bool shouldIncludeStrChars, int maxCount = -1) + { + return ParseCharactersFromCharSet (new CharacterSet(str), shouldIncludeStrChars); + } + + public string ParseCharactersFromCharSet(CharacterSet charSet, bool shouldIncludeChars = true, int maxCount = -1) + { + if (maxCount == -1) { + maxCount = int.MaxValue; + } + + int startIndex = index; + + // Optimisation from profiling: + // Store in temporary local variables + // since they're properties that would have to access + // the rule stack every time otherwise. + int i = index; + int cli = characterInLineIndex; + int li = lineIndex; + + int count = 0; + while ( i < _chars.Length && charSet.Contains (_chars [i]) == shouldIncludeChars && count < maxCount ) { + if (_chars [i] == '\n') { + li++; + cli = -1; + } + i++; + cli++; + count++; + } + + index = i; + characterInLineIndex = cli; + lineIndex = li; + + int lastCharIndex = index; + if (lastCharIndex > startIndex) { + return new string (_chars, startIndex, index - startIndex); + } else { + return null; + } + } + + public object Peek(ParseRule rule) + { + int ruleId = BeginRule (); + object result = rule (); + CancelRule (ruleId); + return result; + } + + public string ParseUntil(ParseRule stopRule, CharacterSet pauseCharacters = null, CharacterSet endCharacters = null) + { + int ruleId = BeginRule (); + + + CharacterSet pauseAndEnd = new CharacterSet (); + if (pauseCharacters != null) { + pauseAndEnd.UnionWith (pauseCharacters); + } + if (endCharacters != null) { + pauseAndEnd.UnionWith (endCharacters); + } + + StringBuilder parsedString = new StringBuilder (); + object ruleResultAtPause = null; + + // Keep attempting to parse strings up to the pause (and end) points. + // - At each of the pause points, attempt to parse according to the rule + // - When the end point is reached (or EOF), we're done + do { + + // TODO: Perhaps if no pause or end characters are passed, we should check *every* character for stopRule? + string partialParsedString = ParseUntilCharactersFromCharSet(pauseAndEnd); + if( partialParsedString != null ) { + parsedString.Append(partialParsedString); + } + + // Attempt to run the parse rule at this pause point + ruleResultAtPause = Peek(stopRule); + + // Rule completed - we're done + if( ruleResultAtPause != null ) { + break; + } else { + + if( endOfInput ) { + break; + } + + // Reached a pause point, but rule failed. Step past and continue parsing string + char pauseCharacter = currentCharacter; + if( pauseCharacters != null && pauseCharacters.Contains(pauseCharacter) ) { + parsedString.Append(pauseCharacter); + if( pauseCharacter == '\n' ) { + lineIndex++; + characterInLineIndex = -1; + } + index++; + characterInLineIndex++; + continue; + } else { + break; + } + } + + } while(true); + + if (parsedString.Length > 0) { + return (string) SucceedRule (ruleId, parsedString.ToString ()); + } else { + return (string) FailRule (ruleId); + } + + } + + // No need to Begin/End rule since we never parse a newline, so keeping oldIndex is good enough + public int? ParseInt() + { + int oldIndex = index; + int oldCharacterInLineIndex = characterInLineIndex; + + bool negative = ParseString ("-") != null; + + // Optional whitespace + ParseCharactersFromString (" \t"); + + var parsedString = ParseCharactersFromCharSet (numbersCharacterSet); + if(parsedString == null) { + // Roll back and fail + index = oldIndex; + characterInLineIndex = oldCharacterInLineIndex; + return null; + } + + int parsedInt; + if (int.TryParse (parsedString, out parsedInt)) { + return negative ? -parsedInt : parsedInt; + } + + Error("Failed to read integer value: " + parsedString + ". Perhaps it's out of the range of acceptable numbers ink supports? (" + int.MinValue + " to " + int.MaxValue + ")"); + return null; + } + + // No need to Begin/End rule since we never parse a newline, so keeping oldIndex is good enough + public float? ParseFloat() + { + int oldIndex = index; + int oldCharacterInLineIndex = characterInLineIndex; + + int? leadingInt = ParseInt (); + if (leadingInt != null) { + + if (ParseString (".") != null) { + + var afterDecimalPointStr = ParseCharactersFromCharSet (numbersCharacterSet); + return float.Parse (leadingInt+"." + afterDecimalPointStr, System.Globalization.CultureInfo.InvariantCulture); + } + } + + // Roll back and fail + index = oldIndex; + characterInLineIndex = oldCharacterInLineIndex; + return null; + } + + // You probably want "endOfLine", since it handles endOfFile too. + protected string ParseNewline() + { + int ruleId = BeginRule(); + + // Optional \r, definite \n to support Windows (\r\n) and Mac/Unix (\n) + // 2nd May 2016: Always collapse \r\n to just \n + ParseString ("\r"); + + if( ParseString ("\n") == null ) { + return (string) FailRule(ruleId); + } else { + return (string) SucceedRule(ruleId, "\n"); + } + } + + private char[] _chars; + } +} + diff --git a/Assets/Ink/compiler/StringParser/StringParser.cs.meta b/Assets/Ink/compiler/StringParser/StringParser.cs.meta new file mode 100644 index 000000000..8d6676495 --- /dev/null +++ b/Assets/Ink/compiler/StringParser/StringParser.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: fe5c87132db4e264d9f3283e6c4f65a0 +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/Assets/Ink/compiler/StringParser/StringParserState.cs b/Assets/Ink/compiler/StringParser/StringParserState.cs new file mode 100644 index 000000000..625d905bc --- /dev/null +++ b/Assets/Ink/compiler/StringParser/StringParserState.cs @@ -0,0 +1,170 @@ + +namespace Ink +{ + public class StringParserState + { + public int lineIndex { + get { return currentElement.lineIndex; } + set { currentElement.lineIndex = value; } + } + + public int characterIndex { + get { return currentElement.characterIndex; } + set { currentElement.characterIndex = value; } + } + + public int characterInLineIndex { + get { return currentElement.characterInLineIndex; } + set { currentElement.characterInLineIndex = value; } + } + + public uint customFlags { + get { return currentElement.customFlags; } + set { currentElement.customFlags = value; } + } + + public bool errorReportedAlreadyInScope { + get { + return currentElement.reportedErrorInScope; + } + } + + public int stackHeight { + get { + return _numElements; + } + } + + public class Element { + public int characterIndex; + public int characterInLineIndex; + public int lineIndex; + public bool reportedErrorInScope; + public int uniqueId; + public uint customFlags; + + public Element() { + + } + + public void CopyFrom(Element fromElement) + { + _uniqueIdCounter++; + this.uniqueId = _uniqueIdCounter; + this.characterIndex = fromElement.characterIndex; + this.characterInLineIndex = fromElement.characterInLineIndex; + this.lineIndex = fromElement.lineIndex; + this.customFlags = fromElement.customFlags; + this.reportedErrorInScope = false; + } + + // Squash is used when succeeding from a rule, + // so only the state information we wanted to carry forward is + // retained. e.g. characterIndex and lineIndex are global, + // however uniqueId is specific to the individual rule, + // and likewise, custom flags are designed for the temporary + // state of the individual rule too. + public void SquashFrom(Element fromElement) + { + this.characterIndex = fromElement.characterIndex; + this.characterInLineIndex = fromElement.characterInLineIndex; + this.lineIndex = fromElement.lineIndex; + this.reportedErrorInScope = fromElement.reportedErrorInScope; + } + + static int _uniqueIdCounter; + } + + public StringParserState () + { + const int kExpectedMaxStackDepth = 200; + _stack = new Element[kExpectedMaxStackDepth]; + + for (int i = 0; i < kExpectedMaxStackDepth; ++i) { + _stack [i] = new Element (); + } + + _numElements = 1; + } + + public int Push() + { + if (_numElements >= _stack.Length) + throw new System.Exception ("Stack overflow in parser state"); + + var prevElement = _stack [_numElements - 1]; + var newElement = _stack[_numElements]; + _numElements++; + + newElement.CopyFrom (prevElement); + + return newElement.uniqueId; + } + + public void Pop(int expectedRuleId) + { + if (_numElements == 1) { + throw new System.Exception ("Attempting to remove final stack element is illegal! Mismatched Begin/Succceed/Fail?"); + } + + if ( currentElement.uniqueId != expectedRuleId) + throw new System.Exception ("Mismatched rule IDs - do you have mismatched Begin/Succeed/Fail?"); + + // Restore state + _numElements--; + } + + public Element Peek(int expectedRuleId) + { + if (currentElement.uniqueId != expectedRuleId) + throw new System.Exception ("Mismatched rule IDs - do you have mismatched Begin/Succeed/Fail?"); + + return _stack[_numElements-1]; + } + + public Element PeekPenultimate() + { + if (_numElements >= 2) { + return _stack [_numElements - 2]; + } else { + return null; + } + } + + // Reduce stack height while maintaining currentElement + // Remove second last element: i.e. "squash last two elements together" + // Used when succeeding from a rule (and ONLY when succeeding, since + // the state of the top element is retained). + public void Squash() + { + if (_numElements < 2) { + throw new System.Exception ("Attempting to remove final stack element is illegal! Mismatched Begin/Succceed/Fail?"); + } + + var penultimateEl = _stack [_numElements - 2]; + var lastEl = _stack [_numElements - 1]; + + penultimateEl.SquashFrom (lastEl); + + _numElements--; + } + + public void NoteErrorReported() + { + foreach (var el in _stack) { + el.reportedErrorInScope = true; + } + } + + protected Element currentElement + { + get { + return _stack [_numElements - 1]; + } + } + + private Element[] _stack; + private int _numElements; + } +} + diff --git a/Assets/Ink/compiler/StringParser/StringParserState.cs.meta b/Assets/Ink/compiler/StringParser/StringParserState.cs.meta new file mode 100644 index 000000000..143fa99b8 --- /dev/null +++ b/Assets/Ink/compiler/StringParser/StringParserState.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: a086715dff4d56d42b1105ca285cd994 +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/Assets/Ink/compiler/ink_compiler.csproj b/Assets/Ink/compiler/ink_compiler.csproj new file mode 100644 index 000000000..7df8a97b7 --- /dev/null +++ b/Assets/Ink/compiler/ink_compiler.csproj @@ -0,0 +1,41 @@ + + + + netstandard2.0 + Ink + ink_compiler + + + + inkle Ltd + InkleStudios + phish + https://github.com/inkle/ink + https://github.com/inkle/ink + https://github.com/inkle/ink/blob/master/LICENSE.txt + git + + + + + + + + + + + + <_Parameter1>inklecate + + + <_Parameter1>ink-tests + + + + diff --git a/Assets/Ink/compiler/ink_compiler.csproj.meta b/Assets/Ink/compiler/ink_compiler.csproj.meta new file mode 100644 index 000000000..b00fb19ce --- /dev/null +++ b/Assets/Ink/compiler/ink_compiler.csproj.meta @@ -0,0 +1,7 @@ +fileFormatVersion: 2 +guid: 2c15838d8ff6de0469062599a553d1e7 +DefaultImporter: + externalObjects: {} + userData: + assetBundleName: + assetBundleVariant: diff --git a/Assets/Ink/ink-engine-runtime.meta b/Assets/Ink/ink-engine-runtime.meta new file mode 100644 index 000000000..65dc511c8 --- /dev/null +++ b/Assets/Ink/ink-engine-runtime.meta @@ -0,0 +1,8 @@ +fileFormatVersion: 2 +guid: 767b3e57f5e52f847b5f3303ad8b1517 +folderAsset: yes +DefaultImporter: + externalObjects: {} + userData: + assetBundleName: + assetBundleVariant: diff --git a/Assets/Ink/ink-engine-runtime/CallStack.cs b/Assets/Ink/ink-engine-runtime/CallStack.cs new file mode 100644 index 000000000..06b5e66d1 --- /dev/null +++ b/Assets/Ink/ink-engine-runtime/CallStack.cs @@ -0,0 +1,443 @@ +using System.Collections.Generic; +using System.Linq; +using System.Diagnostics; + +namespace Ink.Runtime +{ + public class CallStack + { + public class Element + { + public Pointer currentPointer; + + public bool inExpressionEvaluation; + public Dictionary temporaryVariables; + public PushPopType type; + + // When this callstack element is actually a function evaluation called from the game, + // we need to keep track of the size of the evaluation stack when it was called + // so that we know whether there was any return value. + public int evaluationStackHeightWhenPushed; + + // When functions are called, we trim whitespace from the start and end of what + // they generate, so we make sure know where the function's start and end are. + public int functionStartInOuputStream; + + public Element(PushPopType type, Pointer pointer, bool inExpressionEvaluation = false) { + this.currentPointer = pointer; + this.inExpressionEvaluation = inExpressionEvaluation; + this.temporaryVariables = new Dictionary(); + this.type = type; + } + + public Element Copy() + { + var copy = new Element (this.type, currentPointer, this.inExpressionEvaluation); + copy.temporaryVariables = new Dictionary(this.temporaryVariables); + copy.evaluationStackHeightWhenPushed = evaluationStackHeightWhenPushed; + copy.functionStartInOuputStream = functionStartInOuputStream; + return copy; + } + } + + public class Thread + { + public List callstack; + public int threadIndex; + public Pointer previousPointer; + + public Thread() { + callstack = new List(); + } + + public Thread(Dictionary jThreadObj, Story storyContext) : this() { + threadIndex = (int) jThreadObj ["threadIndex"]; + + List jThreadCallstack = (List) jThreadObj ["callstack"]; + foreach (object jElTok in jThreadCallstack) { + + var jElementObj = (Dictionary)jElTok; + + PushPopType pushPopType = (PushPopType)(int)jElementObj ["type"]; + + Pointer pointer = Pointer.Null; + + string currentContainerPathStr = null; + object currentContainerPathStrToken; + if (jElementObj.TryGetValue ("cPath", out currentContainerPathStrToken)) { + currentContainerPathStr = currentContainerPathStrToken.ToString (); + + var threadPointerResult = storyContext.ContentAtPath (new Path (currentContainerPathStr)); + pointer.container = threadPointerResult.container; + pointer.index = (int)jElementObj ["idx"]; + + if (threadPointerResult.obj == null) + throw new System.Exception ("When loading state, internal story location couldn't be found: " + currentContainerPathStr + ". Has the story changed since this save data was created?"); + else if (threadPointerResult.approximate) + storyContext.Warning ("When loading state, exact internal story location couldn't be found: '" + currentContainerPathStr + "', so it was approximated to '"+pointer.container.path.ToString()+"' to recover. Has the story changed since this save data was created?"); + } + + bool inExpressionEvaluation = (bool)jElementObj ["exp"]; + + var el = new Element (pushPopType, pointer, inExpressionEvaluation); + + object temps; + if ( jElementObj.TryGetValue("temp", out temps) ) { + el.temporaryVariables = Json.JObjectToDictionaryRuntimeObjs((Dictionary)temps); + } else { + el.temporaryVariables.Clear(); + } + + callstack.Add (el); + } + + object prevContentObjPath; + if( jThreadObj.TryGetValue("previousContentObject", out prevContentObjPath) ) { + var prevPath = new Path((string)prevContentObjPath); + previousPointer = storyContext.PointerAtPath(prevPath); + } + } + + public Thread Copy() { + var copy = new Thread (); + copy.threadIndex = threadIndex; + foreach(var e in callstack) { + copy.callstack.Add(e.Copy()); + } + copy.previousPointer = previousPointer; + return copy; + } + + public void WriteJson(SimpleJson.Writer writer) + { + writer.WriteObjectStart(); + + // callstack + writer.WritePropertyStart("callstack"); + writer.WriteArrayStart(); + foreach (CallStack.Element el in callstack) + { + writer.WriteObjectStart(); + if(!el.currentPointer.isNull) { + writer.WriteProperty("cPath", el.currentPointer.container.path.componentsString); + writer.WriteProperty("idx", el.currentPointer.index); + } + + writer.WriteProperty("exp", el.inExpressionEvaluation); + writer.WriteProperty("type", (int)el.type); + + if(el.temporaryVariables.Count > 0) { + writer.WritePropertyStart("temp"); + Json.WriteDictionaryRuntimeObjs(writer, el.temporaryVariables); + writer.WritePropertyEnd(); + } + + writer.WriteObjectEnd(); + } + writer.WriteArrayEnd(); + writer.WritePropertyEnd(); + + // threadIndex + writer.WriteProperty("threadIndex", threadIndex); + + if (!previousPointer.isNull) + { + writer.WriteProperty("previousContentObject", previousPointer.Resolve().path.ToString()); + } + + writer.WriteObjectEnd(); + } + } + + public List elements { + get { + return callStack; + } + } + + public int depth { + get { + return elements.Count; + } + } + + public Element currentElement { + get { + var thread = _threads [_threads.Count - 1]; + var cs = thread.callstack; + return cs [cs.Count - 1]; + } + } + + public int currentElementIndex { + get { + return callStack.Count - 1; + } + } + + public Thread currentThread + { + get { + return _threads [_threads.Count - 1]; + } + set { + Debug.Assert (_threads.Count == 1, "Shouldn't be directly setting the current thread when we have a stack of them"); + _threads.Clear (); + _threads.Add (value); + } + } + + public bool canPop { + get { + return callStack.Count > 1; + } + } + + public CallStack (Story storyContext) + { + _startOfRoot = Pointer.StartOf(storyContext.rootContentContainer); + Reset(); + } + + + public CallStack(CallStack toCopy) + { + _threads = new List (); + foreach (var otherThread in toCopy._threads) { + _threads.Add (otherThread.Copy ()); + } + _threadCounter = toCopy._threadCounter; + _startOfRoot = toCopy._startOfRoot; + } + + public void Reset() + { + _threads = new List(); + _threads.Add(new Thread()); + + _threads[0].callstack.Add(new Element(PushPopType.Tunnel, _startOfRoot)); + } + + + // Unfortunately it's not possible to implement jsonToken since + // the setter needs to take a Story as a context in order to + // look up objects from paths for currentContainer within elements. + public void SetJsonToken(Dictionary jObject, Story storyContext) + { + _threads.Clear (); + + var jThreads = (List) jObject ["threads"]; + + foreach (object jThreadTok in jThreads) { + var jThreadObj = (Dictionary)jThreadTok; + var thread = new Thread (jThreadObj, storyContext); + _threads.Add (thread); + } + + _threadCounter = (int)jObject ["threadCounter"]; + _startOfRoot = Pointer.StartOf(storyContext.rootContentContainer); + } + + public void WriteJson(SimpleJson.Writer w) + { + w.WriteObject(writer => + { + writer.WritePropertyStart("threads"); + { + writer.WriteArrayStart(); + + foreach (CallStack.Thread thread in _threads) + { + thread.WriteJson(writer); + } + + writer.WriteArrayEnd(); + } + writer.WritePropertyEnd(); + + writer.WritePropertyStart("threadCounter"); + { + writer.Write(_threadCounter); + } + writer.WritePropertyEnd(); + }); + + } + + public void PushThread() + { + var newThread = currentThread.Copy (); + _threadCounter++; + newThread.threadIndex = _threadCounter; + _threads.Add (newThread); + } + + public Thread ForkThread() + { + var forkedThread = currentThread.Copy(); + _threadCounter++; + forkedThread.threadIndex = _threadCounter; + return forkedThread; + } + + public void PopThread() + { + if (canPopThread) { + _threads.Remove (currentThread); + } else { + throw new System.Exception("Can't pop thread"); + } + } + + public bool canPopThread + { + get { + return _threads.Count > 1 && !elementIsEvaluateFromGame; + } + } + + public bool elementIsEvaluateFromGame + { + get { + return currentElement.type == PushPopType.FunctionEvaluationFromGame; + } + } + + public void Push(PushPopType type, int externalEvaluationStackHeight = 0, int outputStreamLengthWithPushed = 0) + { + // When pushing to callstack, maintain the current content path, but jump out of expressions by default + var element = new Element ( + type, + currentElement.currentPointer, + inExpressionEvaluation: false + ); + + element.evaluationStackHeightWhenPushed = externalEvaluationStackHeight; + element.functionStartInOuputStream = outputStreamLengthWithPushed; + + callStack.Add (element); + } + + public bool CanPop(PushPopType? type = null) { + + if (!canPop) + return false; + + if (type == null) + return true; + + return currentElement.type == type; + } + + public void Pop(PushPopType? type = null) + { + if (CanPop (type)) { + callStack.RemoveAt (callStack.Count - 1); + return; + } else { + throw new System.Exception("Mismatched push/pop in Callstack"); + } + } + + // Get variable value, dereferencing a variable pointer if necessary + public Runtime.Object GetTemporaryVariableWithName(string name, int contextIndex = -1) + { + if (contextIndex == -1) + contextIndex = currentElementIndex+1; + + Runtime.Object varValue = null; + + var contextElement = callStack [contextIndex-1]; + + if (contextElement.temporaryVariables.TryGetValue (name, out varValue)) { + return varValue; + } else { + return null; + } + } + + public void SetTemporaryVariable(string name, Runtime.Object value, bool declareNew, int contextIndex = -1) + { + if (contextIndex == -1) + contextIndex = currentElementIndex+1; + + var contextElement = callStack [contextIndex-1]; + + if (!declareNew && !contextElement.temporaryVariables.ContainsKey(name)) { + throw new System.Exception ("Could not find temporary variable to set: " + name); + } + + Runtime.Object oldValue; + if( contextElement.temporaryVariables.TryGetValue(name, out oldValue) ) + ListValue.RetainListOriginsForAssignment (oldValue, value); + + contextElement.temporaryVariables [name] = value; + } + + // Find the most appropriate context for this variable. + // Are we referencing a temporary or global variable? + // Note that the compiler will have warned us about possible conflicts, + // so anything that happens here should be safe! + public int ContextForVariableNamed(string name) + { + // Current temporary context? + // (Shouldn't attempt to access contexts higher in the callstack.) + if (currentElement.temporaryVariables.ContainsKey (name)) { + return currentElementIndex+1; + } + + // Global + else { + return 0; + } + } + + public Thread ThreadWithIndex(int index) + { + return _threads.Find (t => t.threadIndex == index); + } + + private List callStack + { + get { + return currentThread.callstack; + } + } + + public string callStackTrace { + get { + var sb = new System.Text.StringBuilder(); + + for(int t=0; t<_threads.Count; t++) { + + var thread = _threads[t]; + var isCurrent = (t == _threads.Count-1); + sb.AppendFormat("=== THREAD {0}/{1} {2}===\n", (t+1), _threads.Count, (isCurrent ? "(current) ":"")); + + for(int i=0; i"); + } + } + } + + + return sb.ToString(); + } + } + + List _threads; + int _threadCounter; + Pointer _startOfRoot; + } +} + diff --git a/Assets/Ink/ink-engine-runtime/CallStack.cs.meta b/Assets/Ink/ink-engine-runtime/CallStack.cs.meta new file mode 100644 index 000000000..746813f01 --- /dev/null +++ b/Assets/Ink/ink-engine-runtime/CallStack.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: 3185b8692bdecce479392cd8f1f03ff4 +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/Assets/Ink/ink-engine-runtime/Choice.cs b/Assets/Ink/ink-engine-runtime/Choice.cs new file mode 100644 index 000000000..766a758eb --- /dev/null +++ b/Assets/Ink/ink-engine-runtime/Choice.cs @@ -0,0 +1,54 @@ + +namespace Ink.Runtime +{ + /// + /// A generated Choice from the story. + /// A single ChoicePoint in the Story could potentially generate + /// different Choices dynamically dependent on state, so they're + /// separated. + /// + public class Choice : Runtime.Object + { + /// + /// The main text to presented to the player for this Choice. + /// + public string text { get; set; } + + /// + /// The target path that the Story should be diverted to if + /// this Choice is chosen. + /// + public string pathStringOnChoice { + get { + return targetPath.ToString (); + } + set { + targetPath = new Path (value); + } + } + + /// + /// Get the path to the original choice point - where was this choice defined in the story? + /// + /// A dot separated path into the story data. + public string sourcePath; + + /// + /// The original index into currentChoices list on the Story when + /// this Choice was generated, for convenience. + /// + public int index { get; set; } + + public Path targetPath; + + public CallStack.Thread threadAtGeneration { get; set; } + public int originalThreadIndex; + + public bool isInvisibleDefault; + + public Choice() + { + } + } +} + diff --git a/Assets/Ink/ink-engine-runtime/Choice.cs.meta b/Assets/Ink/ink-engine-runtime/Choice.cs.meta new file mode 100644 index 000000000..6ce59a766 --- /dev/null +++ b/Assets/Ink/ink-engine-runtime/Choice.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: fc74b038b5618ab4db14ac564b2f7376 +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/Assets/Ink/ink-engine-runtime/ChoicePoint.cs b/Assets/Ink/ink-engine-runtime/ChoicePoint.cs new file mode 100644 index 000000000..d212dea5e --- /dev/null +++ b/Assets/Ink/ink-engine-runtime/ChoicePoint.cs @@ -0,0 +1,89 @@ +using System.ComponentModel; + +namespace Ink.Runtime +{ + /// + /// The ChoicePoint represents the point within the Story where + /// a Choice instance gets generated. The distinction is made + /// because the text of the Choice can be dynamically generated. + /// + public class ChoicePoint : Runtime.Object + { + public Path pathOnChoice { + get { + // Resolve any relative paths to global ones as we come across them + if (_pathOnChoice != null && _pathOnChoice.isRelative) { + var choiceTargetObj = choiceTarget; + if (choiceTargetObj) { + _pathOnChoice = choiceTargetObj.path; + } + } + return _pathOnChoice; + } + set { + _pathOnChoice = value; + } + } + Path _pathOnChoice; + + public Container choiceTarget { + get { + return this.ResolvePath (_pathOnChoice).container; + } + } + + public string pathStringOnChoice { + get { + return CompactPathString (pathOnChoice); + } + set { + pathOnChoice = new Path (value); + } + } + + public bool hasCondition { get; set; } + public bool hasStartContent { get; set; } + public bool hasChoiceOnlyContent { get; set; } + public bool onceOnly { get; set; } + public bool isInvisibleDefault { get; set; } + + public int flags { + get { + int flags = 0; + if (hasCondition) flags |= 1; + if (hasStartContent) flags |= 2; + if (hasChoiceOnlyContent) flags |= 4; + if (isInvisibleDefault) flags |= 8; + if (onceOnly) flags |= 16; + return flags; + } + set { + hasCondition = (value & 1) > 0; + hasStartContent = (value & 2) > 0; + hasChoiceOnlyContent = (value & 4) > 0; + isInvisibleDefault = (value & 8) > 0; + onceOnly = (value & 16) > 0; + } + } + + public ChoicePoint (bool onceOnly) + { + this.onceOnly = onceOnly; + } + + public ChoicePoint() : this(true) {} + + public override string ToString () + { + int? targetLineNum = DebugLineNumberOfPath (pathOnChoice); + string targetString = pathOnChoice.ToString (); + + if (targetLineNum != null) { + targetString = " line " + targetLineNum + "("+targetString+")"; + } + + return "Choice: -> " + targetString; + } + } +} + diff --git a/Assets/Ink/ink-engine-runtime/ChoicePoint.cs.meta b/Assets/Ink/ink-engine-runtime/ChoicePoint.cs.meta new file mode 100644 index 000000000..b24051dae --- /dev/null +++ b/Assets/Ink/ink-engine-runtime/ChoicePoint.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: b2ca1b5fdf86c0447a521da44bcd3046 +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/Assets/Ink/ink-engine-runtime/Container.cs b/Assets/Ink/ink-engine-runtime/Container.cs new file mode 100644 index 000000000..a8a122b92 --- /dev/null +++ b/Assets/Ink/ink-engine-runtime/Container.cs @@ -0,0 +1,366 @@ +using System; +using System.Diagnostics; +using System.Collections.Generic; +using System.Linq; +using System.Text; +using System.ComponentModel; + +namespace Ink.Runtime +{ + public class Container : Runtime.Object, INamedContent + { + public string name { get; set; } + + public List content { + get { + return _content; + } + set { + AddContent (value); + } + } + List _content; + + public Dictionary namedContent { get; set; } + + public Dictionary namedOnlyContent { + get { + var namedOnlyContentDict = new Dictionary(); + foreach (var kvPair in namedContent) { + namedOnlyContentDict [kvPair.Key] = (Runtime.Object)kvPair.Value; + } + + foreach (var c in content) { + var named = c as INamedContent; + if (named != null && named.hasValidName) { + namedOnlyContentDict.Remove (named.name); + } + } + + if (namedOnlyContentDict.Count == 0) + namedOnlyContentDict = null; + + return namedOnlyContentDict; + } + set { + var existingNamedOnly = namedOnlyContent; + if (existingNamedOnly != null) { + foreach (var kvPair in existingNamedOnly) { + namedContent.Remove (kvPair.Key); + } + } + + if (value == null) + return; + + foreach (var kvPair in value) { + var named = kvPair.Value as INamedContent; + if( named != null ) + AddToNamedContentOnly (named); + } + } + } + + public bool visitsShouldBeCounted { get; set; } + public bool turnIndexShouldBeCounted { get; set; } + public bool countingAtStartOnly { get; set; } + + [Flags] + public enum CountFlags + { + Visits = 1, + Turns = 2, + CountStartOnly = 4 + } + + public int countFlags + { + get { + CountFlags flags = 0; + if (visitsShouldBeCounted) flags |= CountFlags.Visits; + if (turnIndexShouldBeCounted) flags |= CountFlags.Turns; + if (countingAtStartOnly) flags |= CountFlags.CountStartOnly; + + // If we're only storing CountStartOnly, it serves no purpose, + // since it's dependent on the other two to be used at all. + // (e.g. for setting the fact that *if* a gather or choice's + // content is counted, then is should only be counter at the start) + // So this is just an optimisation for storage. + if (flags == CountFlags.CountStartOnly) { + flags = 0; + } + + return (int)flags; + } + set { + var flag = (CountFlags)value; + if ((flag & CountFlags.Visits) > 0) visitsShouldBeCounted = true; + if ((flag & CountFlags.Turns) > 0) turnIndexShouldBeCounted = true; + if ((flag & CountFlags.CountStartOnly) > 0) countingAtStartOnly = true; + } + } + + public bool hasValidName + { + get { return name != null && name.Length > 0; } + } + + public Path pathToFirstLeafContent + { + get { + if( _pathToFirstLeafContent == null ) + _pathToFirstLeafContent = path.PathByAppendingPath (internalPathToFirstLeafContent); + + return _pathToFirstLeafContent; + } + } + Path _pathToFirstLeafContent; + + Path internalPathToFirstLeafContent + { + get { + var components = new List(); + var container = this; + while (container != null) { + if (container.content.Count > 0) { + components.Add (new Path.Component (0)); + container = container.content [0] as Container; + } + } + return new Path(components); + } + } + + public Container () + { + _content = new List (); + namedContent = new Dictionary (); + } + + public void AddContent(Runtime.Object contentObj) + { + content.Add (contentObj); + + if (contentObj.parent) { + throw new System.Exception ("content is already in " + contentObj.parent); + } + + contentObj.parent = this; + + TryAddNamedContent (contentObj); + } + + public void AddContent(IList contentList) + { + foreach (var c in contentList) { + AddContent (c); + } + } + + public void InsertContent(Runtime.Object contentObj, int index) + { + content.Insert (index, contentObj); + + if (contentObj.parent) { + throw new System.Exception ("content is already in " + contentObj.parent); + } + + contentObj.parent = this; + + TryAddNamedContent (contentObj); + } + + public void TryAddNamedContent(Runtime.Object contentObj) + { + var namedContentObj = contentObj as INamedContent; + if (namedContentObj != null && namedContentObj.hasValidName) { + AddToNamedContentOnly (namedContentObj); + } + } + + public void AddToNamedContentOnly(INamedContent namedContentObj) + { + Debug.Assert (namedContentObj is Runtime.Object, "Can only add Runtime.Objects to a Runtime.Container"); + var runtimeObj = (Runtime.Object)namedContentObj; + runtimeObj.parent = this; + + namedContent [namedContentObj.name] = namedContentObj; + } + + public void AddContentsOfContainer(Container otherContainer) + { + content.AddRange (otherContainer.content); + foreach (var obj in otherContainer.content) { + obj.parent = this; + TryAddNamedContent (obj); + } + } + + protected Runtime.Object ContentWithPathComponent(Path.Component component) + { + if (component.isIndex) { + + if (component.index >= 0 && component.index < content.Count) { + return content [component.index]; + } + + // When path is out of range, quietly return nil + // (useful as we step/increment forwards through content) + else { + return null; + } + + } + + else if (component.isParent) { + return this.parent; + } + + else { + INamedContent foundContent = null; + if (namedContent.TryGetValue (component.name, out foundContent)) { + return (Runtime.Object)foundContent; + } else { + return null; + } + } + } + + public SearchResult ContentAtPath(Path path, int partialPathStart = 0, int partialPathLength = -1) + { + if (partialPathLength == -1) + partialPathLength = path.length; + + var result = new SearchResult (); + result.approximate = false; + + Container currentContainer = this; + Runtime.Object currentObj = this; + + for (int i = partialPathStart; i < partialPathLength; ++i) { + var comp = path.GetComponent(i); + + // Path component was wrong type + if (currentContainer == null) { + result.approximate = true; + break; + } + + var foundObj = currentContainer.ContentWithPathComponent(comp); + + // Couldn't resolve entire path? + if (foundObj == null) { + result.approximate = true; + break; + } + + currentObj = foundObj; + currentContainer = foundObj as Container; + } + + result.obj = currentObj; + + return result; + } + + public void BuildStringOfHierarchy(StringBuilder sb, int indentation, Runtime.Object pointedObj) + { + Action appendIndentation = () => { + const int spacesPerIndent = 4; + for(int i=0; i (); + + foreach (var objKV in namedContent) { + if (content.Contains ((Runtime.Object)objKV.Value)) { + continue; + } else { + onlyNamed.Add (objKV.Key, objKV.Value); + } + } + + if (onlyNamed.Count > 0) { + appendIndentation (); + sb.AppendLine ("-- named: --"); + + foreach (var objKV in onlyNamed) { + + Debug.Assert (objKV.Value is Container, "Can only print out named Containers"); + var container = (Container)objKV.Value; + container.BuildStringOfHierarchy (sb, indentation, pointedObj); + + sb.AppendLine (); + + } + } + + + indentation--; + + appendIndentation (); + sb.Append ("]"); + } + + public virtual string BuildStringOfHierarchy() + { + var sb = new StringBuilder (); + + BuildStringOfHierarchy (sb, 0, null); + + return sb.ToString (); + } + + } +} + diff --git a/Assets/Ink/ink-engine-runtime/Container.cs.meta b/Assets/Ink/ink-engine-runtime/Container.cs.meta new file mode 100644 index 000000000..0b11be30a --- /dev/null +++ b/Assets/Ink/ink-engine-runtime/Container.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: e4c19ec208aa47d42af8759288c76642 +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/Assets/Ink/ink-engine-runtime/ControlCommand.cs b/Assets/Ink/ink-engine-runtime/ControlCommand.cs new file mode 100644 index 000000000..8d3ad092b --- /dev/null +++ b/Assets/Ink/ink-engine-runtime/ControlCommand.cs @@ -0,0 +1,170 @@ +using System; + +namespace Ink.Runtime +{ + public class ControlCommand : Runtime.Object + { + public enum CommandType + { + NotSet = -1, + EvalStart, + EvalOutput, + EvalEnd, + Duplicate, + PopEvaluatedValue, + PopFunction, + PopTunnel, + BeginString, + EndString, + NoOp, + ChoiceCount, + Turns, + TurnsSince, + ReadCount, + Random, + SeedRandom, + VisitIndex, + SequenceShuffleIndex, + StartThread, + Done, + End, + ListFromInt, + ListRange, + ListRandom, + //---- + TOTAL_VALUES + } + + public CommandType commandType { get; protected set; } + + public ControlCommand (CommandType commandType) + { + this.commandType = commandType; + } + + // Require default constructor for serialisation + public ControlCommand() : this(CommandType.NotSet) {} + + public override Object Copy() + { + return new ControlCommand (commandType); + } + + // The following static factory methods are to make generating these objects + // slightly more succinct. Without these, the code gets pretty massive! e.g. + // + // var c = new Runtime.ControlCommand(Runtime.ControlCommand.CommandType.EvalStart) + // + // as opposed to + // + // var c = Runtime.ControlCommand.EvalStart() + + public static ControlCommand EvalStart() { + return new ControlCommand(CommandType.EvalStart); + } + + public static ControlCommand EvalOutput() { + return new ControlCommand(CommandType.EvalOutput); + } + + public static ControlCommand EvalEnd() { + return new ControlCommand(CommandType.EvalEnd); + } + + public static ControlCommand Duplicate() { + return new ControlCommand(CommandType.Duplicate); + } + + public static ControlCommand PopEvaluatedValue() { + return new ControlCommand (CommandType.PopEvaluatedValue); + } + + public static ControlCommand PopFunction() { + return new ControlCommand (CommandType.PopFunction); + } + + public static ControlCommand PopTunnel() { + return new ControlCommand (CommandType.PopTunnel); + } + + public static ControlCommand BeginString() { + return new ControlCommand (CommandType.BeginString); + } + + public static ControlCommand EndString() { + return new ControlCommand (CommandType.EndString); + } + + public static ControlCommand NoOp() { + return new ControlCommand(CommandType.NoOp); + } + + public static ControlCommand ChoiceCount() { + return new ControlCommand(CommandType.ChoiceCount); + } + + public static ControlCommand Turns () + { + return new ControlCommand (CommandType.Turns); + } + + public static ControlCommand TurnsSince() { + return new ControlCommand(CommandType.TurnsSince); + } + + public static ControlCommand ReadCount () + { + return new ControlCommand (CommandType.ReadCount); + } + + public static ControlCommand Random () + { + return new ControlCommand (CommandType.Random); + } + + public static ControlCommand SeedRandom () + { + return new ControlCommand (CommandType.SeedRandom); + } + + public static ControlCommand VisitIndex() { + return new ControlCommand(CommandType.VisitIndex); + } + + public static ControlCommand SequenceShuffleIndex() { + return new ControlCommand(CommandType.SequenceShuffleIndex); + } + + public static ControlCommand StartThread() { + return new ControlCommand (CommandType.StartThread); + } + + public static ControlCommand Done() { + return new ControlCommand (CommandType.Done); + } + + public static ControlCommand End() { + return new ControlCommand (CommandType.End); + } + + public static ControlCommand ListFromInt () { + return new ControlCommand (CommandType.ListFromInt); + } + + public static ControlCommand ListRange () + { + return new ControlCommand (CommandType.ListRange); + } + + public static ControlCommand ListRandom () + { + return new ControlCommand (CommandType.ListRandom); + } + + public override string ToString () + { + return commandType.ToString(); + } + } +} + diff --git a/Assets/Ink/ink-engine-runtime/ControlCommand.cs.meta b/Assets/Ink/ink-engine-runtime/ControlCommand.cs.meta new file mode 100644 index 000000000..2a41559a4 --- /dev/null +++ b/Assets/Ink/ink-engine-runtime/ControlCommand.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: 7be2a2d6c9cf19d4ca5e52f32952b7cc +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/Assets/Ink/ink-engine-runtime/DebugMetadata.cs b/Assets/Ink/ink-engine-runtime/DebugMetadata.cs new file mode 100644 index 000000000..1d06f3096 --- /dev/null +++ b/Assets/Ink/ink-engine-runtime/DebugMetadata.cs @@ -0,0 +1,76 @@ +using System; + +namespace Ink.Runtime +{ + public class DebugMetadata + { + public int startLineNumber = 0; + public int endLineNumber = 0; + public int startCharacterNumber = 0; + public int endCharacterNumber = 0; + public string fileName = null; + public string sourceName = null; + + public DebugMetadata () + { + } + + // Currently only used in VariableReference in order to + // merge the debug metadata of a Path.Of.Indentifiers into + // one single range. + public DebugMetadata Merge(DebugMetadata dm) + { + var newDebugMetadata = new DebugMetadata(); + + // These are not supposed to be differ between 'this' and 'dm'. + newDebugMetadata.fileName = fileName; + newDebugMetadata.sourceName = sourceName; + + if (startLineNumber < dm.startLineNumber) + { + newDebugMetadata.startLineNumber = startLineNumber; + newDebugMetadata.startCharacterNumber = startCharacterNumber; + } + else if (startLineNumber > dm.startLineNumber) + { + newDebugMetadata.startLineNumber = dm.startLineNumber; + newDebugMetadata.startCharacterNumber = dm.startCharacterNumber; + } + else + { + newDebugMetadata.startLineNumber = startLineNumber; + newDebugMetadata.startCharacterNumber = Math.Min(startCharacterNumber, dm.startCharacterNumber); + } + + if (endLineNumber > dm.endLineNumber) + { + newDebugMetadata.endLineNumber = endLineNumber; + newDebugMetadata.endCharacterNumber = endCharacterNumber; + } + else if (endLineNumber < dm.endLineNumber) + { + newDebugMetadata.endLineNumber = dm.endLineNumber; + newDebugMetadata.endCharacterNumber = dm.endCharacterNumber; + } + else + { + newDebugMetadata.endLineNumber = endLineNumber; + newDebugMetadata.endCharacterNumber = Math.Max(endCharacterNumber, dm.endCharacterNumber); + } + + return newDebugMetadata; + } + + public override string ToString () + { + if (fileName != null) { + return string.Format ("line {0} of {1}", startLineNumber, fileName); + } else { + return "line " + startLineNumber; + } + + } + + } +} + diff --git a/Assets/Ink/ink-engine-runtime/DebugMetadata.cs.meta b/Assets/Ink/ink-engine-runtime/DebugMetadata.cs.meta new file mode 100644 index 000000000..ca4e7a775 --- /dev/null +++ b/Assets/Ink/ink-engine-runtime/DebugMetadata.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: e6902c7f2d85ecc4d829ff5463be478b +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/Assets/Ink/ink-engine-runtime/Divert.cs b/Assets/Ink/ink-engine-runtime/Divert.cs new file mode 100644 index 000000000..5c15a6822 --- /dev/null +++ b/Assets/Ink/ink-engine-runtime/Divert.cs @@ -0,0 +1,149 @@ +using System.Text; + +namespace Ink.Runtime +{ + public class Divert : Runtime.Object + { + public Path targetPath { + get { + // Resolve any relative paths to global ones as we come across them + if (_targetPath != null && _targetPath.isRelative) { + var targetObj = targetPointer.Resolve(); + if (targetObj) { + _targetPath = targetObj.path; + } + } + return _targetPath; + } + set { + _targetPath = value; + _targetPointer = Pointer.Null; + } + } + Path _targetPath; + + public Pointer targetPointer { + get { + if (_targetPointer.isNull) { + var targetObj = ResolvePath (_targetPath).obj; + + if (_targetPath.lastComponent.isIndex) { + _targetPointer.container = targetObj.parent as Container; + _targetPointer.index = _targetPath.lastComponent.index; + } else { + _targetPointer = Pointer.StartOf (targetObj as Container); + } + } + return _targetPointer; + } + } + Pointer _targetPointer; + + + public string targetPathString { + get { + if (targetPath == null) + return null; + + return CompactPathString (targetPath); + } + set { + if (value == null) { + targetPath = null; + } else { + targetPath = new Path (value); + } + } + } + + public string variableDivertName { get; set; } + public bool hasVariableTarget { get { return variableDivertName != null; } } + + public bool pushesToStack { get; set; } + public PushPopType stackPushType; + + public bool isExternal { get; set; } + public int externalArgs { get; set; } + + public bool isConditional { get; set; } + + public Divert () + { + pushesToStack = false; + } + + public Divert(PushPopType stackPushType) + { + pushesToStack = true; + this.stackPushType = stackPushType; + } + + public override bool Equals (object obj) + { + var otherDivert = obj as Divert; + if (otherDivert) { + if (this.hasVariableTarget == otherDivert.hasVariableTarget) { + if (this.hasVariableTarget) { + return this.variableDivertName == otherDivert.variableDivertName; + } else { + return this.targetPath.Equals(otherDivert.targetPath); + } + } + } + return false; + } + + public override int GetHashCode () + { + if (hasVariableTarget) { + const int variableTargetSalt = 12345; + return variableDivertName.GetHashCode() + variableTargetSalt; + } else { + const int pathTargetSalt = 54321; + return targetPath.GetHashCode() + pathTargetSalt; + } + } + + public override string ToString () + { + if (hasVariableTarget) { + return "Divert(variable: " + variableDivertName + ")"; + } + else if (targetPath == null) { + return "Divert(null)"; + } else { + + var sb = new StringBuilder (); + + string targetStr = targetPath.ToString (); + int? targetLineNum = DebugLineNumberOfPath (targetPath); + if (targetLineNum != null) { + targetStr = "line " + targetLineNum; + } + + sb.Append ("Divert"); + + if (isConditional) + sb.Append ("?"); + + if (pushesToStack) { + if (stackPushType == PushPopType.Function) { + sb.Append (" function"); + } else { + sb.Append (" tunnel"); + } + } + + sb.Append (" -> "); + sb.Append (targetPathString); + + sb.Append (" ("); + sb.Append (targetStr); + sb.Append (")"); + + return sb.ToString (); + } + } + } +} + diff --git a/Assets/Ink/ink-engine-runtime/Divert.cs.meta b/Assets/Ink/ink-engine-runtime/Divert.cs.meta new file mode 100644 index 000000000..ebde025e0 --- /dev/null +++ b/Assets/Ink/ink-engine-runtime/Divert.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: 0436459191048f841acfdf0d4879d597 +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/Assets/Ink/ink-engine-runtime/Error.cs b/Assets/Ink/ink-engine-runtime/Error.cs new file mode 100644 index 000000000..38a5dc54e --- /dev/null +++ b/Assets/Ink/ink-engine-runtime/Error.cs @@ -0,0 +1,24 @@ +namespace Ink +{ + /// + /// Callback for errors throughout both the ink runtime and compiler. + /// + public delegate void ErrorHandler(string message, ErrorType type); + + /// + /// Author errors will only ever come from the compiler so don't need to be handled + /// by your Story error handler. The "Error" ErrorType is by far the most common + /// for a runtime story error (rather than compiler error), though the Warning type + /// is also possible. + /// + public enum ErrorType + { + /// Generated by a "TODO" note in the ink source + Author, + /// You should probably fix this, but it's not critical + Warning, + /// Critical error that can't be recovered from + Error + } +} + diff --git a/Assets/Ink/ink-engine-runtime/Error.cs.meta b/Assets/Ink/ink-engine-runtime/Error.cs.meta new file mode 100644 index 000000000..65761023b --- /dev/null +++ b/Assets/Ink/ink-engine-runtime/Error.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: 5857ea02573a38b49aee290457791597 +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/Assets/Ink/ink-engine-runtime/Flow.cs b/Assets/Ink/ink-engine-runtime/Flow.cs new file mode 100644 index 000000000..37da8ec26 --- /dev/null +++ b/Assets/Ink/ink-engine-runtime/Flow.cs @@ -0,0 +1,93 @@ +using System.Collections.Generic; + +namespace Ink.Runtime +{ + public class Flow { + public string name; + public CallStack callStack; + public List outputStream; + public List currentChoices; + + public Flow(string name, Story story) { + this.name = name; + this.callStack = new CallStack(story); + this.outputStream = new List(); + this.currentChoices = new List(); + } + + public Flow(string name, Story story, Dictionary jObject) { + this.name = name; + this.callStack = new CallStack(story); + this.callStack.SetJsonToken ((Dictionary < string, object > )jObject ["callstack"], story); + this.outputStream = Json.JArrayToRuntimeObjList ((List)jObject ["outputStream"]); + this.currentChoices = Json.JArrayToRuntimeObjList((List)jObject ["currentChoices"]); + + // choiceThreads is optional + object jChoiceThreadsObj; + jObject.TryGetValue("choiceThreads", out jChoiceThreadsObj); + LoadFlowChoiceThreads((Dictionary)jChoiceThreadsObj, story); + } + + public void WriteJson(SimpleJson.Writer writer) + { + writer.WriteObjectStart(); + + writer.WriteProperty("callstack", callStack.WriteJson); + writer.WriteProperty("outputStream", w => Json.WriteListRuntimeObjs(w, outputStream)); + + // choiceThreads: optional + // Has to come BEFORE the choices themselves are written out + // since the originalThreadIndex of each choice needs to be set + bool hasChoiceThreads = false; + foreach (Choice c in currentChoices) + { + c.originalThreadIndex = c.threadAtGeneration.threadIndex; + + if (callStack.ThreadWithIndex(c.originalThreadIndex) == null) + { + if (!hasChoiceThreads) + { + hasChoiceThreads = true; + writer.WritePropertyStart("choiceThreads"); + writer.WriteObjectStart(); + } + + writer.WritePropertyStart(c.originalThreadIndex); + c.threadAtGeneration.WriteJson(writer); + writer.WritePropertyEnd(); + } + } + + if (hasChoiceThreads) + { + writer.WriteObjectEnd(); + writer.WritePropertyEnd(); + } + + + writer.WriteProperty("currentChoices", w => { + w.WriteArrayStart(); + foreach (var c in currentChoices) + Json.WriteChoice(w, c); + w.WriteArrayEnd(); + }); + + + writer.WriteObjectEnd(); + } + + // Used both to load old format and current + public void LoadFlowChoiceThreads(Dictionary jChoiceThreads, Story story) + { + foreach (var choice in currentChoices) { + var foundActiveThread = callStack.ThreadWithIndex(choice.originalThreadIndex); + if( foundActiveThread != null ) { + choice.threadAtGeneration = foundActiveThread.Copy (); + } else { + var jSavedChoiceThread = (Dictionary ) jChoiceThreads[choice.originalThreadIndex.ToString()]; + choice.threadAtGeneration = new CallStack.Thread(jSavedChoiceThread, story); + } + } + } + } +} \ No newline at end of file diff --git a/Assets/Ink/ink-engine-runtime/Flow.cs.meta b/Assets/Ink/ink-engine-runtime/Flow.cs.meta new file mode 100644 index 000000000..6d567c7ad --- /dev/null +++ b/Assets/Ink/ink-engine-runtime/Flow.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: a358e49bf66f18048a4bbbc19f276eb1 +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/Assets/Ink/ink-engine-runtime/Glue.cs b/Assets/Ink/ink-engine-runtime/Glue.cs new file mode 100644 index 000000000..cfdfb2553 --- /dev/null +++ b/Assets/Ink/ink-engine-runtime/Glue.cs @@ -0,0 +1,13 @@ +namespace Ink.Runtime +{ + public class Glue : Runtime.Object + { + public Glue() { } + + public override string ToString () + { + return "Glue"; + } + } +} + diff --git a/Assets/Ink/ink-engine-runtime/Glue.cs.meta b/Assets/Ink/ink-engine-runtime/Glue.cs.meta new file mode 100644 index 000000000..cc811c76c --- /dev/null +++ b/Assets/Ink/ink-engine-runtime/Glue.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: 5b2f2082eb6b77949aaabd471ee7bfec +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/Assets/Ink/ink-engine-runtime/INamedContent.cs b/Assets/Ink/ink-engine-runtime/INamedContent.cs new file mode 100644 index 000000000..3e4519958 --- /dev/null +++ b/Assets/Ink/ink-engine-runtime/INamedContent.cs @@ -0,0 +1,10 @@ + +namespace Ink.Runtime +{ + public interface INamedContent + { + string name { get; } + bool hasValidName { get; } + } +} + diff --git a/Assets/Ink/ink-engine-runtime/INamedContent.cs.meta b/Assets/Ink/ink-engine-runtime/INamedContent.cs.meta new file mode 100644 index 000000000..d0b622b6f --- /dev/null +++ b/Assets/Ink/ink-engine-runtime/INamedContent.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: 43e32e964e59dac4fb5acbed9cf2a170 +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/Assets/Ink/ink-engine-runtime/InkList.cs b/Assets/Ink/ink-engine-runtime/InkList.cs new file mode 100644 index 000000000..7bc6d66d8 --- /dev/null +++ b/Assets/Ink/ink-engine-runtime/InkList.cs @@ -0,0 +1,584 @@ +using System.Collections.Generic; +using System.Text; + +namespace Ink.Runtime +{ + /// + /// The underlying type for a list item in ink. It stores the original list definition + /// name as well as the item name, but without the value of the item. When the value is + /// stored, it's stored in a KeyValuePair of InkListItem and int. + /// + public struct InkListItem + { + /// + /// The name of the list where the item was originally defined. + /// + public readonly string originName; + + /// + /// The main name of the item as defined in ink. + /// + public readonly string itemName; + + /// + /// Create an item with the given original list definition name, and the name of this + /// item. + /// + public InkListItem (string originName, string itemName) + { + this.originName = originName; + this.itemName = itemName; + } + + /// + /// Create an item from a dot-separted string of the form "listDefinitionName.listItemName". + /// + public InkListItem (string fullName) + { + var nameParts = fullName.Split ('.'); + this.originName = nameParts [0]; + this.itemName = nameParts [1]; + } + + public static InkListItem Null { + get { + return new InkListItem (null, null); + } + } + + public bool isNull { + get { + return originName == null && itemName == null; + } + } + + /// + /// Get the full dot-separated name of the item, in the form "listDefinitionName.itemName". + /// + public string fullName { + get { + return (originName ?? "?") + "." + itemName; + } + } + + /// + /// Get the full dot-separated name of the item, in the form "listDefinitionName.itemName". + /// Calls fullName internally. + /// + public override string ToString () + { + return fullName; + } + + /// + /// Is this item the same as another item? + /// + public override bool Equals (object obj) + { + if (obj is InkListItem) { + var otherItem = (InkListItem)obj; + return otherItem.itemName == itemName + && otherItem.originName == originName; + } + + return false; + } + + /// + /// Get the hashcode for an item. + /// + public override int GetHashCode () + { + int originCode = 0; + int itemCode = itemName.GetHashCode (); + if (originName != null) + originCode = originName.GetHashCode (); + + return originCode + itemCode; + } + } + + /// + /// The InkList is the underlying type that's used to store an instance of a + /// list in ink. It's not used for the *definition* of the list, but for a list + /// value that's stored in a variable. + /// Somewhat confusingly, it's backed by a C# Dictionary, and has nothing to + /// do with a C# List! + /// + public class InkList : Dictionary + { + /// + /// Create a new empty ink list. + /// + public InkList () { } + + /// + /// Create a new ink list that contains the same contents as another list. + /// + public InkList(InkList otherList) : base(otherList) + { + _originNames = otherList.originNames; + if (otherList.origins != null) + { + origins = new List(otherList.origins); + } + } + + /// + /// Create a new empty ink list that's intended to hold items from a particular origin + /// list definition. The origin Story is needed in order to be able to look up that definition. + /// + public InkList (string singleOriginListName, Story originStory) + { + SetInitialOriginName (singleOriginListName); + + ListDefinition def; + if (originStory.listDefinitions.TryListGetDefinition (singleOriginListName, out def)) + origins = new List { def }; + else + throw new System.Exception ("InkList origin could not be found in story when constructing new list: " + singleOriginListName); + } + + public InkList (KeyValuePair singleElement) + { + Add (singleElement.Key, singleElement.Value); + } + + /// + /// Converts a string to an ink list and returns for use in the story. + /// + /// InkList created from string list item + /// Item key. + /// Origin story. + public static InkList FromString(string myListItem, Story originStory) { + var listValue = originStory.listDefinitions.FindSingleItemListWithName (myListItem); + if (listValue) + return new InkList (listValue.value); + else + throw new System.Exception ("Could not find the InkListItem from the string '" + myListItem + "' to create an InkList because it doesn't exist in the original list definition in ink."); + } + + + /// + /// Adds the given item to the ink list. Note that the item must come from a list definition that + /// is already "known" to this list, so that the item's value can be looked up. By "known", we mean + /// that it already has items in it from that source, or it did at one point - it can't be a + /// completely fresh empty list, or a list that only contains items from a different list definition. + /// + public void AddItem (InkListItem item) + { + if (item.originName == null) { + AddItem (item.itemName); + return; + } + + foreach (var origin in origins) { + if (origin.name == item.originName) { + int intVal; + if (origin.TryGetValueForItem (item, out intVal)) { + this [item] = intVal; + return; + } else { + throw new System.Exception ("Could not add the item " + item + " to this list because it doesn't exist in the original list definition in ink."); + } + } + } + + throw new System.Exception ("Failed to add item to list because the item was from a new list definition that wasn't previously known to this list. Only items from previously known lists can be used, so that the int value can be found."); + } + + /// + /// Adds the given item to the ink list, attempting to find the origin list definition that it belongs to. + /// The item must therefore come from a list definition that is already "known" to this list, so that the + /// item's value can be looked up. By "known", we mean that it already has items in it from that source, or + /// it did at one point - it can't be a completely fresh empty list, or a list that only contains items from + /// a different list definition. + /// + public void AddItem (string itemName) + { + ListDefinition foundListDef = null; + + foreach (var origin in origins) { + if (origin.ContainsItemWithName (itemName)) { + if (foundListDef != null) { + throw new System.Exception ("Could not add the item " + itemName + " to this list because it could come from either " + origin.name + " or " + foundListDef.name); + } else { + foundListDef = origin; + } + } + } + + if (foundListDef == null) + throw new System.Exception ("Could not add the item " + itemName + " to this list because it isn't known to any list definitions previously associated with this list."); + + var item = new InkListItem (foundListDef.name, itemName); + var itemVal = foundListDef.ValueForItem(item); + this [item] = itemVal; + } + + /// + /// Returns true if this ink list contains an item with the given short name + /// (ignoring the original list where it was defined). + /// + public bool ContainsItemNamed (string itemName) + { + foreach (var itemWithValue in this) { + if (itemWithValue.Key.itemName == itemName) return true; + } + return false; + } + + // Story has to set this so that the value knows its origin, + // necessary for certain operations (e.g. interacting with ints). + // Only the story has access to the full set of lists, so that + // the origin can be resolved from the originListName. + public List origins; + public ListDefinition originOfMaxItem { + get { + if (origins == null) return null; + + var maxOriginName = maxItem.Key.originName; + foreach (var origin in origins) { + if (origin.name == maxOriginName) + return origin; + } + + return null; + } + } + + // Origin name needs to be serialised when content is empty, + // assuming a name is availble, for list definitions with variable + // that is currently empty. + public List originNames { + get { + if (this.Count > 0) { + if (_originNames == null && this.Count > 0) + _originNames = new List (); + else + _originNames.Clear (); + + foreach (var itemAndValue in this) + _originNames.Add (itemAndValue.Key.originName); + } + + return _originNames; + } + } + List _originNames; + + public void SetInitialOriginName (string initialOriginName) + { + _originNames = new List { initialOriginName }; + } + + public void SetInitialOriginNames (List initialOriginNames) + { + if (initialOriginNames == null) + _originNames = null; + else + _originNames = new List(initialOriginNames); + } + + /// + /// Get the maximum item in the list, equivalent to calling LIST_MAX(list) in ink. + /// + public KeyValuePair maxItem { + get { + KeyValuePair max = new KeyValuePair(); + foreach (var kv in this) { + if (max.Key.isNull || kv.Value > max.Value) + max = kv; + } + return max; + } + } + + /// + /// Get the minimum item in the list, equivalent to calling LIST_MIN(list) in ink. + /// + public KeyValuePair minItem { + get { + var min = new KeyValuePair (); + foreach (var kv in this) { + if (min.Key.isNull || kv.Value < min.Value) + min = kv; + } + return min; + } + } + + /// + /// The inverse of the list, equivalent to calling LIST_INVERSE(list) in ink + /// + public InkList inverse { + get { + var list = new InkList (); + if (origins != null) { + foreach (var origin in origins) { + foreach (var itemAndValue in origin.items) { + if (!this.ContainsKey (itemAndValue.Key)) + list.Add (itemAndValue.Key, itemAndValue.Value); + } + } + + } + return list; + } + } + + /// + /// The list of all items from the original list definition, equivalent to calling + /// LIST_ALL(list) in ink. + /// + public InkList all { + get { + var list = new InkList (); + if (origins != null) { + foreach (var origin in origins) { + foreach (var itemAndValue in origin.items) + list[itemAndValue.Key] = itemAndValue.Value; + } + } + return list; + } + } + + /// + /// Returns a new list that is the combination of the current list and one that's + /// passed in. Equivalent to calling (list1 + list2) in ink. + /// + public InkList Union (InkList otherList) + { + var union = new InkList (this); + foreach (var kv in otherList) { + union [kv.Key] = kv.Value; + } + return union; + } + + /// + /// Returns a new list that is the intersection of the current list with another + /// list that's passed in - i.e. a list of the items that are shared between the + /// two other lists. Equivalent to calling (list1 ^ list2) in ink. + /// + public InkList Intersect (InkList otherList) + { + var intersection = new InkList (); + foreach (var kv in this) { + if (otherList.ContainsKey (kv.Key)) + intersection.Add (kv.Key, kv.Value); + } + return intersection; + } + + /// + /// Returns a new list that's the same as the current one, except with the given items + /// removed that are in the passed in list. Equivalent to calling (list1 - list2) in ink. + /// + /// List to remove. + public InkList Without (InkList listToRemove) + { + var result = new InkList (this); + foreach (var kv in listToRemove) + result.Remove (kv.Key); + return result; + } + + /// + /// Returns true if the current list contains all the items that are in the list that + /// is passed in. Equivalent to calling (list1 ? list2) in ink. + /// + /// Other list. + public bool Contains (InkList otherList) + { + foreach (var kv in otherList) { + if (!this.ContainsKey (kv.Key)) return false; + } + return true; + } + + /// + /// Returns true if all the item values in the current list are greater than all the + /// item values in the passed in list. Equivalent to calling (list1 > list2) in ink. + /// + public bool GreaterThan (InkList otherList) + { + if (Count == 0) return false; + if (otherList.Count == 0) return true; + + // All greater + return minItem.Value > otherList.maxItem.Value; + } + + /// + /// Returns true if the item values in the current list overlap or are all greater than + /// the item values in the passed in list. None of the item values in the current list must + /// fall below the item values in the passed in list. Equivalent to (list1 >= list2) in ink, + /// or LIST_MIN(list1) >= LIST_MIN(list2) && LIST_MAX(list1) >= LIST_MAX(list2). + /// + public bool GreaterThanOrEquals (InkList otherList) + { + if (Count == 0) return false; + if (otherList.Count == 0) return true; + + return minItem.Value >= otherList.minItem.Value + && maxItem.Value >= otherList.maxItem.Value; + } + + /// + /// Returns true if all the item values in the current list are less than all the + /// item values in the passed in list. Equivalent to calling (list1 < list2) in ink. + /// + public bool LessThan (InkList otherList) + { + if (otherList.Count == 0) return false; + if (Count == 0) return true; + + return maxItem.Value < otherList.minItem.Value; + } + + /// + /// Returns true if the item values in the current list overlap or are all less than + /// the item values in the passed in list. None of the item values in the current list must + /// go above the item values in the passed in list. Equivalent to (list1 <= list2) in ink, + /// or LIST_MAX(list1) <= LIST_MAX(list2) && LIST_MIN(list1) <= LIST_MIN(list2). + /// + public bool LessThanOrEquals (InkList otherList) + { + if (otherList.Count == 0) return false; + if (Count == 0) return true; + + return maxItem.Value <= otherList.maxItem.Value + && minItem.Value <= otherList.minItem.Value; + } + + public InkList MaxAsList () + { + if (Count > 0) + return new InkList (maxItem); + else + return new InkList (); + } + + public InkList MinAsList () + { + if (Count > 0) + return new InkList (minItem); + else + return new InkList (); + } + + /// + /// Returns a sublist with the elements given the minimum and maxmimum bounds. + /// The bounds can either be ints which are indices into the entire (sorted) list, + /// or they can be InkLists themselves. These are intended to be single-item lists so + /// you can specify the upper and lower bounds. If you pass in multi-item lists, it'll + /// use the minimum and maximum items in those lists respectively. + /// WARNING: Calling this method requires a full sort of all the elements in the list. + /// + public InkList ListWithSubRange(object minBound, object maxBound) + { + if (this.Count == 0) return new InkList(); + + var ordered = orderedItems; + + int minValue = 0; + int maxValue = int.MaxValue; + + if (minBound is int) + { + minValue = (int)minBound; + } + + else + { + if( minBound is InkList && ((InkList)minBound).Count > 0 ) + minValue = ((InkList)minBound).minItem.Value; + } + + if (maxBound is int) + maxValue = (int)maxBound; + else + { + if (minBound is InkList && ((InkList)minBound).Count > 0) + maxValue = ((InkList)maxBound).maxItem.Value; + } + + var subList = new InkList(); + subList.SetInitialOriginNames(originNames); + foreach(var item in ordered) { + if( item.Value >= minValue && item.Value <= maxValue ) { + subList.Add(item.Key, item.Value); + } + } + + return subList; + } + + /// + /// Returns true if the passed object is also an ink list that contains + /// the same items as the current list, false otherwise. + /// + public override bool Equals (object other) + { + var otherRawList = other as InkList; + if (otherRawList == null) return false; + if (otherRawList.Count != Count) return false; + + foreach (var kv in this) { + if (!otherRawList.ContainsKey (kv.Key)) + return false; + } + + return true; + } + + /// + /// Return the hashcode for this object, used for comparisons and inserting into dictionaries. + /// + public override int GetHashCode () + { + int ownHash = 0; + foreach (var kv in this) + ownHash += kv.Key.GetHashCode (); + return ownHash; + } + + List> orderedItems { + get { + var ordered = new List>(); + ordered.AddRange(this); + ordered.Sort((x, y) => { + // Ensure consistent ordering of mixed lists. + if( x.Value == y.Value ) { + return x.Key.originName.CompareTo(y.Key.originName); + } else { + return x.Value.CompareTo(y.Value); + } + }); + return ordered; + } + } + + /// + /// Returns a string in the form "a, b, c" with the names of the items in the list, without + /// the origin list definition names. Equivalent to writing {list} in ink. + /// + public override string ToString () + { + var ordered = orderedItems; + + var sb = new StringBuilder (); + for (int i = 0; i < ordered.Count; i++) { + if (i > 0) + sb.Append (", "); + + var item = ordered [i].Key; + sb.Append (item.itemName); + } + + return sb.ToString (); + } + } +} diff --git a/Assets/Ink/ink-engine-runtime/InkList.cs.meta b/Assets/Ink/ink-engine-runtime/InkList.cs.meta new file mode 100644 index 000000000..fca74e392 --- /dev/null +++ b/Assets/Ink/ink-engine-runtime/InkList.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: eae430118a663d2468fd2dd014f15032 +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/Assets/Ink/ink-engine-runtime/JsonSerialisation.cs b/Assets/Ink/ink-engine-runtime/JsonSerialisation.cs new file mode 100644 index 000000000..dcde266b4 --- /dev/null +++ b/Assets/Ink/ink-engine-runtime/JsonSerialisation.cs @@ -0,0 +1,720 @@ +using System; +using System.Collections.Generic; +using System.Linq; + +namespace Ink.Runtime +{ + public static class Json + { + public static List JArrayToRuntimeObjList(List jArray, bool skipLast=false) where T : Runtime.Object + { + int count = jArray.Count; + if (skipLast) + count--; + + var list = new List (jArray.Count); + + for (int i = 0; i < count; i++) { + var jTok = jArray [i]; + var runtimeObj = JTokenToRuntimeObject (jTok) as T; + list.Add (runtimeObj); + } + + return list; + } + + public static List JArrayToRuntimeObjList(List jArray, bool skipLast=false) + { + return JArrayToRuntimeObjList (jArray, skipLast); + } + + public static void WriteDictionaryRuntimeObjs(SimpleJson.Writer writer, Dictionary dictionary) + { + writer.WriteObjectStart(); + foreach(var keyVal in dictionary) { + writer.WritePropertyStart(keyVal.Key); + WriteRuntimeObject(writer, keyVal.Value); + writer.WritePropertyEnd(); + } + writer.WriteObjectEnd(); + } + + + public static void WriteListRuntimeObjs(SimpleJson.Writer writer, List list) + { + writer.WriteArrayStart(); + foreach (var val in list) + { + WriteRuntimeObject(writer, val); + } + writer.WriteArrayEnd(); + } + + public static void WriteIntDictionary(SimpleJson.Writer writer, Dictionary dict) + { + writer.WriteObjectStart(); + foreach (var keyVal in dict) + writer.WriteProperty(keyVal.Key, keyVal.Value); + writer.WriteObjectEnd(); + } + + public static void WriteRuntimeObject(SimpleJson.Writer writer, Runtime.Object obj) + { + var container = obj as Container; + if (container) { + WriteRuntimeContainer(writer, container); + return; + } + + var divert = obj as Divert; + if (divert) + { + string divTypeKey = "->"; + if (divert.isExternal) + divTypeKey = "x()"; + else if (divert.pushesToStack) + { + if (divert.stackPushType == PushPopType.Function) + divTypeKey = "f()"; + else if (divert.stackPushType == PushPopType.Tunnel) + divTypeKey = "->t->"; + } + + string targetStr; + if (divert.hasVariableTarget) + targetStr = divert.variableDivertName; + else + targetStr = divert.targetPathString; + + writer.WriteObjectStart(); + + writer.WriteProperty(divTypeKey, targetStr); + + if (divert.hasVariableTarget) + writer.WriteProperty("var", true); + + if (divert.isConditional) + writer.WriteProperty("c", true); + + if (divert.externalArgs > 0) + writer.WriteProperty("exArgs", divert.externalArgs); + + writer.WriteObjectEnd(); + return; + } + + var choicePoint = obj as ChoicePoint; + if (choicePoint) + { + writer.WriteObjectStart(); + writer.WriteProperty("*", choicePoint.pathStringOnChoice); + writer.WriteProperty("flg", choicePoint.flags); + writer.WriteObjectEnd(); + return; + } + + var boolVal = obj as BoolValue; + if (boolVal) { + writer.Write(boolVal.value); + return; + } + + var intVal = obj as IntValue; + if (intVal) { + writer.Write(intVal.value); + return; + } + + var floatVal = obj as FloatValue; + if (floatVal) { + writer.Write(floatVal.value); + return; + } + + var strVal = obj as StringValue; + if (strVal) + { + if (strVal.isNewline) + writer.Write("\\n", escape:false); + else { + writer.WriteStringStart(); + writer.WriteStringInner("^"); + writer.WriteStringInner(strVal.value); + writer.WriteStringEnd(); + } + return; + } + + var listVal = obj as ListValue; + if (listVal) + { + WriteInkList(writer, listVal); + return; + } + + var divTargetVal = obj as DivertTargetValue; + if (divTargetVal) + { + writer.WriteObjectStart(); + writer.WriteProperty("^->", divTargetVal.value.componentsString); + writer.WriteObjectEnd(); + return; + } + + var varPtrVal = obj as VariablePointerValue; + if (varPtrVal) + { + writer.WriteObjectStart(); + writer.WriteProperty("^var", varPtrVal.value); + writer.WriteProperty("ci", varPtrVal.contextIndex); + writer.WriteObjectEnd(); + return; + } + + var glue = obj as Runtime.Glue; + if (glue) { + writer.Write("<>"); + return; + } + + var controlCmd = obj as ControlCommand; + if (controlCmd) + { + writer.Write(_controlCommandNames[(int)controlCmd.commandType]); + return; + } + + var nativeFunc = obj as Runtime.NativeFunctionCall; + if (nativeFunc) + { + var name = nativeFunc.name; + + // Avoid collision with ^ used to indicate a string + if (name == "^") name = "L^"; + + writer.Write(name); + return; + } + + + // Variable reference + var varRef = obj as VariableReference; + if (varRef) + { + writer.WriteObjectStart(); + + string readCountPath = varRef.pathStringForCount; + if (readCountPath != null) + { + writer.WriteProperty("CNT?", readCountPath); + } + else + { + writer.WriteProperty("VAR?", varRef.name); + } + + writer.WriteObjectEnd(); + return; + } + + // Variable assignment + var varAss = obj as VariableAssignment; + if (varAss) + { + writer.WriteObjectStart(); + + string key = varAss.isGlobal ? "VAR=" : "temp="; + writer.WriteProperty(key, varAss.variableName); + + // Reassignment? + if (!varAss.isNewDeclaration) + writer.WriteProperty("re", true); + + writer.WriteObjectEnd(); + + return; + } + + // Void + var voidObj = obj as Void; + if (voidObj) { + writer.Write("void"); + return; + } + + // Tag + var tag = obj as Tag; + if (tag) + { + writer.WriteObjectStart(); + writer.WriteProperty("#", tag.text); + writer.WriteObjectEnd(); + return; + } + + // Used when serialising save state only + var choice = obj as Choice; + if (choice) { + WriteChoice(writer, choice); + return; + } + + throw new System.Exception("Failed to write runtime object to JSON: " + obj); + } + + public static Dictionary JObjectToDictionaryRuntimeObjs(Dictionary jObject) + { + var dict = new Dictionary (jObject.Count); + + foreach (var keyVal in jObject) { + dict [keyVal.Key] = JTokenToRuntimeObject(keyVal.Value); + } + + return dict; + } + + public static Dictionary JObjectToIntDictionary(Dictionary jObject) + { + var dict = new Dictionary (jObject.Count); + foreach (var keyVal in jObject) { + dict [keyVal.Key] = (int)keyVal.Value; + } + return dict; + } + + // ---------------------- + // JSON ENCODING SCHEME + // ---------------------- + // + // Glue: "<>", "G<", "G>" + // + // ControlCommand: "ev", "out", "/ev", "du" "pop", "->->", "~ret", "str", "/str", "nop", + // "choiceCnt", "turns", "visit", "seq", "thread", "done", "end" + // + // NativeFunction: "+", "-", "/", "*", "%" "~", "==", ">", "<", ">=", "<=", "!=", "!"... etc + // + // Void: "void" + // + // Value: "^string value", "^^string value beginning with ^" + // 5, 5.2 + // {"^->": "path.target"} + // {"^var": "varname", "ci": 0} + // + // Container: [...] + // [..., + // { + // "subContainerName": ..., + // "#f": 5, // flags + // "#n": "containerOwnName" // only if not redundant + // } + // ] + // + // Divert: {"->": "path.target", "c": true } + // {"->": "path.target", "var": true} + // {"f()": "path.func"} + // {"->t->": "path.tunnel"} + // {"x()": "externalFuncName", "exArgs": 5} + // + // Var Assign: {"VAR=": "varName", "re": true} // reassignment + // {"temp=": "varName"} + // + // Var ref: {"VAR?": "varName"} + // {"CNT?": "stitch name"} + // + // ChoicePoint: {"*": pathString, + // "flg": 18 } + // + // Choice: Nothing too clever, it's only used in the save state, + // there's not likely to be many of them. + // + // Tag: {"#": "the tag text"} + public static Runtime.Object JTokenToRuntimeObject(object token) + { + if (token is int || token is float || token is bool) { + return Value.Create (token); + } + + if (token is string) { + string str = (string)token; + + // String value + char firstChar = str[0]; + if (firstChar == '^') + return new StringValue (str.Substring (1)); + else if( firstChar == '\n' && str.Length == 1) + return new StringValue ("\n"); + + // Glue + if (str == "<>") return new Runtime.Glue (); + + // Control commands (would looking up in a hash set be faster?) + for (int i = 0; i < _controlCommandNames.Length; ++i) { + string cmdName = _controlCommandNames [i]; + if (str == cmdName) { + return new Runtime.ControlCommand ((ControlCommand.CommandType)i); + } + } + + // Native functions + // "^" conflicts with the way to identify strings, so now + // we know it's not a string, we can convert back to the proper + // symbol for the operator. + if (str == "L^") str = "^"; + if( NativeFunctionCall.CallExistsWithName(str) ) + return NativeFunctionCall.CallWithName (str); + + // Pop + if (str == "->->") + return Runtime.ControlCommand.PopTunnel (); + else if (str == "~ret") + return Runtime.ControlCommand.PopFunction (); + + // Void + if (str == "void") + return new Runtime.Void (); + } + + if (token is Dictionary) { + + var obj = (Dictionary < string, object> )token; + object propValue; + + // Divert target value to path + if (obj.TryGetValue ("^->", out propValue)) + return new DivertTargetValue (new Path ((string)propValue)); + + // VariablePointerValue + if (obj.TryGetValue ("^var", out propValue)) { + var varPtr = new VariablePointerValue ((string)propValue); + if (obj.TryGetValue ("ci", out propValue)) + varPtr.contextIndex = (int)propValue; + return varPtr; + } + + // Divert + bool isDivert = false; + bool pushesToStack = false; + PushPopType divPushType = PushPopType.Function; + bool external = false; + if (obj.TryGetValue ("->", out propValue)) { + isDivert = true; + } + else if (obj.TryGetValue ("f()", out propValue)) { + isDivert = true; + pushesToStack = true; + divPushType = PushPopType.Function; + } + else if (obj.TryGetValue ("->t->", out propValue)) { + isDivert = true; + pushesToStack = true; + divPushType = PushPopType.Tunnel; + } + else if (obj.TryGetValue ("x()", out propValue)) { + isDivert = true; + external = true; + pushesToStack = false; + divPushType = PushPopType.Function; + } + if (isDivert) { + var divert = new Divert (); + divert.pushesToStack = pushesToStack; + divert.stackPushType = divPushType; + divert.isExternal = external; + + string target = propValue.ToString (); + + if (obj.TryGetValue ("var", out propValue)) + divert.variableDivertName = target; + else + divert.targetPathString = target; + + divert.isConditional = obj.TryGetValue("c", out propValue); + + if (external) { + if (obj.TryGetValue ("exArgs", out propValue)) + divert.externalArgs = (int)propValue; + } + + return divert; + } + + // Choice + if (obj.TryGetValue ("*", out propValue)) { + var choice = new ChoicePoint (); + choice.pathStringOnChoice = propValue.ToString(); + + if (obj.TryGetValue ("flg", out propValue)) + choice.flags = (int)propValue; + + return choice; + } + + // Variable reference + if (obj.TryGetValue ("VAR?", out propValue)) { + return new VariableReference (propValue.ToString ()); + } else if (obj.TryGetValue ("CNT?", out propValue)) { + var readCountVarRef = new VariableReference (); + readCountVarRef.pathStringForCount = propValue.ToString (); + return readCountVarRef; + } + + // Variable assignment + bool isVarAss = false; + bool isGlobalVar = false; + if (obj.TryGetValue ("VAR=", out propValue)) { + isVarAss = true; + isGlobalVar = true; + } else if (obj.TryGetValue ("temp=", out propValue)) { + isVarAss = true; + isGlobalVar = false; + } + if (isVarAss) { + var varName = propValue.ToString (); + var isNewDecl = !obj.TryGetValue("re", out propValue); + var varAss = new VariableAssignment (varName, isNewDecl); + varAss.isGlobal = isGlobalVar; + return varAss; + } + + // Tag + if (obj.TryGetValue ("#", out propValue)) { + return new Runtime.Tag ((string)propValue); + } + + // List value + if (obj.TryGetValue ("list", out propValue)) { + var listContent = (Dictionary)propValue; + var rawList = new InkList (); + if (obj.TryGetValue ("origins", out propValue)) { + var namesAsObjs = (List)propValue; + rawList.SetInitialOriginNames (namesAsObjs.Cast().ToList()); + } + foreach (var nameToVal in listContent) { + var item = new InkListItem (nameToVal.Key); + var val = (int)nameToVal.Value; + rawList.Add (item, val); + } + return new ListValue (rawList); + } + + // Used when serialising save state only + if (obj ["originalChoicePath"] != null) + return JObjectToChoice (obj); + } + + // Array is always a Runtime.Container + if (token is List) { + return JArrayToContainer((List)token); + } + + if (token == null) + return null; + + throw new System.Exception ("Failed to convert token to runtime object: " + token); + } + + public static void WriteRuntimeContainer(SimpleJson.Writer writer, Container container, bool withoutName = false) + { + writer.WriteArrayStart(); + + foreach (var c in container.content) + WriteRuntimeObject(writer, c); + + // Container is always an array [...] + // But the final element is always either: + // - a dictionary containing the named content, as well as possibly + // the key "#" with the count flags + // - null, if neither of the above + var namedOnlyContent = container.namedOnlyContent; + var countFlags = container.countFlags; + var hasNameProperty = container.name != null && !withoutName; + + bool hasTerminator = namedOnlyContent != null || countFlags > 0 || hasNameProperty; + + if( hasTerminator ) + writer.WriteObjectStart(); + + if ( namedOnlyContent != null ) { + foreach(var namedContent in namedOnlyContent) { + var name = namedContent.Key; + var namedContainer = namedContent.Value as Container; + writer.WritePropertyStart(name); + WriteRuntimeContainer(writer, namedContainer, withoutName:true); + writer.WritePropertyEnd(); + } + } + + if (countFlags > 0) + writer.WriteProperty("#f", countFlags); + + if (hasNameProperty) + writer.WriteProperty("#n", container.name); + + if (hasTerminator) + writer.WriteObjectEnd(); + else + writer.WriteNull(); + + writer.WriteArrayEnd(); + } + + static Container JArrayToContainer(List jArray) + { + var container = new Container (); + container.content = JArrayToRuntimeObjList (jArray, skipLast:true); + + // Final object in the array is always a combination of + // - named content + // - a "#f" key with the countFlags + // (if either exists at all, otherwise null) + var terminatingObj = jArray [jArray.Count - 1] as Dictionary; + if (terminatingObj != null) { + + var namedOnlyContent = new Dictionary (terminatingObj.Count); + + foreach (var keyVal in terminatingObj) { + if (keyVal.Key == "#f") { + container.countFlags = (int)keyVal.Value; + } else if (keyVal.Key == "#n") { + container.name = keyVal.Value.ToString (); + } else { + var namedContentItem = JTokenToRuntimeObject(keyVal.Value); + var namedSubContainer = namedContentItem as Container; + if (namedSubContainer) + namedSubContainer.name = keyVal.Key; + namedOnlyContent [keyVal.Key] = namedContentItem; + } + } + + container.namedOnlyContent = namedOnlyContent; + } + + return container; + } + + static Choice JObjectToChoice(Dictionary jObj) + { + var choice = new Choice(); + choice.text = jObj ["text"].ToString(); + choice.index = (int)jObj ["index"]; + choice.sourcePath = jObj ["originalChoicePath"].ToString(); + choice.originalThreadIndex = (int)jObj ["originalThreadIndex"]; + choice.pathStringOnChoice = jObj ["targetPath"].ToString(); + return choice; + } + public static void WriteChoice(SimpleJson.Writer writer, Choice choice) + { + writer.WriteObjectStart(); + writer.WriteProperty("text", choice.text); + writer.WriteProperty("index", choice.index); + writer.WriteProperty("originalChoicePath", choice.sourcePath); + writer.WriteProperty("originalThreadIndex", choice.originalThreadIndex); + writer.WriteProperty("targetPath", choice.pathStringOnChoice); + writer.WriteObjectEnd(); + } + + static void WriteInkList(SimpleJson.Writer writer, ListValue listVal) + { + var rawList = listVal.value; + + writer.WriteObjectStart(); + + writer.WritePropertyStart("list"); + + writer.WriteObjectStart(); + + foreach (var itemAndValue in rawList) + { + var item = itemAndValue.Key; + int itemVal = itemAndValue.Value; + + writer.WritePropertyNameStart(); + writer.WritePropertyNameInner(item.originName ?? "?"); + writer.WritePropertyNameInner("."); + writer.WritePropertyNameInner(item.itemName); + writer.WritePropertyNameEnd(); + + writer.Write(itemVal); + + writer.WritePropertyEnd(); + } + + writer.WriteObjectEnd(); + + writer.WritePropertyEnd(); + + if (rawList.Count == 0 && rawList.originNames != null && rawList.originNames.Count > 0) + { + writer.WritePropertyStart("origins"); + writer.WriteArrayStart(); + foreach (var name in rawList.originNames) + writer.Write(name); + writer.WriteArrayEnd(); + writer.WritePropertyEnd(); + } + + writer.WriteObjectEnd(); + } + + public static ListDefinitionsOrigin JTokenToListDefinitions (object obj) + { + var defsObj = (Dictionary)obj; + + var allDefs = new List (); + + foreach (var kv in defsObj) { + var name = (string) kv.Key; + var listDefJson = (Dictionary)kv.Value; + + // Cast (string, object) to (string, int) for items + var items = new Dictionary (); + foreach (var nameValue in listDefJson) + items.Add(nameValue.Key, (int)nameValue.Value); + + var def = new ListDefinition (name, items); + allDefs.Add (def); + } + + return new ListDefinitionsOrigin (allDefs); + } + + static Json() + { + _controlCommandNames = new string[(int)ControlCommand.CommandType.TOTAL_VALUES]; + + _controlCommandNames [(int)ControlCommand.CommandType.EvalStart] = "ev"; + _controlCommandNames [(int)ControlCommand.CommandType.EvalOutput] = "out"; + _controlCommandNames [(int)ControlCommand.CommandType.EvalEnd] = "/ev"; + _controlCommandNames [(int)ControlCommand.CommandType.Duplicate] = "du"; + _controlCommandNames [(int)ControlCommand.CommandType.PopEvaluatedValue] = "pop"; + _controlCommandNames [(int)ControlCommand.CommandType.PopFunction] = "~ret"; + _controlCommandNames [(int)ControlCommand.CommandType.PopTunnel] = "->->"; + _controlCommandNames [(int)ControlCommand.CommandType.BeginString] = "str"; + _controlCommandNames [(int)ControlCommand.CommandType.EndString] = "/str"; + _controlCommandNames [(int)ControlCommand.CommandType.NoOp] = "nop"; + _controlCommandNames [(int)ControlCommand.CommandType.ChoiceCount] = "choiceCnt"; + _controlCommandNames [(int)ControlCommand.CommandType.Turns] = "turn"; + _controlCommandNames [(int)ControlCommand.CommandType.TurnsSince] = "turns"; + _controlCommandNames [(int)ControlCommand.CommandType.ReadCount] = "readc"; + _controlCommandNames [(int)ControlCommand.CommandType.Random] = "rnd"; + _controlCommandNames [(int)ControlCommand.CommandType.SeedRandom] = "srnd"; + _controlCommandNames [(int)ControlCommand.CommandType.VisitIndex] = "visit"; + _controlCommandNames [(int)ControlCommand.CommandType.SequenceShuffleIndex] = "seq"; + _controlCommandNames [(int)ControlCommand.CommandType.StartThread] = "thread"; + _controlCommandNames [(int)ControlCommand.CommandType.Done] = "done"; + _controlCommandNames [(int)ControlCommand.CommandType.End] = "end"; + _controlCommandNames [(int)ControlCommand.CommandType.ListFromInt] = "listInt"; + _controlCommandNames [(int)ControlCommand.CommandType.ListRange] = "range"; + _controlCommandNames [(int)ControlCommand.CommandType.ListRandom] = "lrnd"; + + for (int i = 0; i < (int)ControlCommand.CommandType.TOTAL_VALUES; ++i) { + if (_controlCommandNames [i] == null) + throw new System.Exception ("Control command not accounted for in serialisation"); + } + } + + static string[] _controlCommandNames; + } +} + + diff --git a/Assets/Ink/ink-engine-runtime/JsonSerialisation.cs.meta b/Assets/Ink/ink-engine-runtime/JsonSerialisation.cs.meta new file mode 100644 index 000000000..c96d2baca --- /dev/null +++ b/Assets/Ink/ink-engine-runtime/JsonSerialisation.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: 57b94594766db8247bf7c8cf3be26d0b +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/Assets/Ink/ink-engine-runtime/ListDefinition.cs b/Assets/Ink/ink-engine-runtime/ListDefinition.cs new file mode 100644 index 000000000..94370bd25 --- /dev/null +++ b/Assets/Ink/ink-engine-runtime/ListDefinition.cs @@ -0,0 +1,75 @@ +using System.Collections.Generic; + +namespace Ink.Runtime +{ + public class ListDefinition + { + public string name { get { return _name; } } + + public Dictionary items { + get { + if (_items == null) { + _items = new Dictionary (); + foreach (var itemNameAndValue in _itemNameToValues) { + var item = new InkListItem (name, itemNameAndValue.Key); + _items [item] = itemNameAndValue.Value; + } + } + return _items; + } + } + Dictionary _items; + + public int ValueForItem (InkListItem item) + { + int intVal; + if (_itemNameToValues.TryGetValue (item.itemName, out intVal)) + return intVal; + else + return 0; + } + + public bool ContainsItem (InkListItem item) + { + if (item.originName != name) return false; + + return _itemNameToValues.ContainsKey (item.itemName); + } + + public bool ContainsItemWithName (string itemName) + { + return _itemNameToValues.ContainsKey (itemName); + } + + public bool TryGetItemWithValue (int val, out InkListItem item) + { + foreach (var namedItem in _itemNameToValues) { + if (namedItem.Value == val) { + item = new InkListItem (name, namedItem.Key); + return true; + } + } + + item = InkListItem.Null; + return false; + } + + public bool TryGetValueForItem (InkListItem item, out int intVal) + { + return _itemNameToValues.TryGetValue (item.itemName, out intVal); + } + + public ListDefinition (string name, Dictionary items) + { + _name = name; + _itemNameToValues = items; + } + + string _name; + + // The main representation should be simple item names rather than a RawListItem, + // since we mainly want to access items based on their simple name, since that's + // how they'll be most commonly requested from ink. + Dictionary _itemNameToValues; + } +} diff --git a/Assets/Ink/ink-engine-runtime/ListDefinition.cs.meta b/Assets/Ink/ink-engine-runtime/ListDefinition.cs.meta new file mode 100644 index 000000000..fdb2dea37 --- /dev/null +++ b/Assets/Ink/ink-engine-runtime/ListDefinition.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: e05c4a8ea45103145a70c0222b1cfc41 +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/Assets/Ink/ink-engine-runtime/ListDefinitionsOrigin.cs b/Assets/Ink/ink-engine-runtime/ListDefinitionsOrigin.cs new file mode 100644 index 000000000..9fc33894f --- /dev/null +++ b/Assets/Ink/ink-engine-runtime/ListDefinitionsOrigin.cs @@ -0,0 +1,53 @@ +using System.Collections.Generic; + +namespace Ink.Runtime +{ + public class ListDefinitionsOrigin + { + public List lists { + get { + var listOfLists = new List (); + foreach (var namedList in _lists) { + listOfLists.Add (namedList.Value); + } + return listOfLists; + } + } + + public ListDefinitionsOrigin (List lists) + { + _lists = new Dictionary (); + _allUnambiguousListValueCache = new Dictionary(); + + foreach (var list in lists) { + _lists [list.name] = list; + + foreach(var itemWithValue in list.items) { + var item = itemWithValue.Key; + var val = itemWithValue.Value; + var listValue = new ListValue(item, val); + + // May be ambiguous, but compiler should've caught that, + // so we may be doing some replacement here, but that's okay. + _allUnambiguousListValueCache[item.itemName] = listValue; + _allUnambiguousListValueCache[item.fullName] = listValue; + } + } + } + + public bool TryListGetDefinition (string name, out ListDefinition def) + { + return _lists.TryGetValue (name, out def); + } + + public ListValue FindSingleItemListWithName (string name) + { + ListValue val = null; + _allUnambiguousListValueCache.TryGetValue(name, out val); + return val; + } + + Dictionary _lists; + Dictionary _allUnambiguousListValueCache; + } +} diff --git a/Assets/Ink/ink-engine-runtime/ListDefinitionsOrigin.cs.meta b/Assets/Ink/ink-engine-runtime/ListDefinitionsOrigin.cs.meta new file mode 100644 index 000000000..6b45dcdbb --- /dev/null +++ b/Assets/Ink/ink-engine-runtime/ListDefinitionsOrigin.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: 9364c2f86b5422d4c90cedb25e30a855 +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/Assets/Ink/ink-engine-runtime/NativeFunctionCall.cs b/Assets/Ink/ink-engine-runtime/NativeFunctionCall.cs new file mode 100644 index 000000000..b610651a3 --- /dev/null +++ b/Assets/Ink/ink-engine-runtime/NativeFunctionCall.cs @@ -0,0 +1,508 @@ +using System; +using System.Collections.Generic; + +namespace Ink.Runtime +{ + public class NativeFunctionCall : Runtime.Object + { + public const string Add = "+"; + public const string Subtract = "-"; + public const string Divide = "/"; + public const string Multiply = "*"; + public const string Mod = "%"; + public const string Negate = "_"; // distinguish from "-" for subtraction + + public const string Equal = "=="; + public const string Greater = ">"; + public const string Less = "<"; + public const string GreaterThanOrEquals = ">="; + public const string LessThanOrEquals = "<="; + public const string NotEquals = "!="; + public const string Not = "!"; + + + + public const string And = "&&"; + public const string Or = "||"; + + public const string Min = "MIN"; + public const string Max = "MAX"; + + public const string Pow = "POW"; + public const string Floor = "FLOOR"; + public const string Ceiling = "CEILING"; + public const string Int = "INT"; + public const string Float = "FLOAT"; + + public const string Has = "?"; + public const string Hasnt = "!?"; + public const string Intersect = "^"; + + public const string ListMin = "LIST_MIN"; + public const string ListMax = "LIST_MAX"; + public const string All = "LIST_ALL"; + public const string Count = "LIST_COUNT"; + public const string ValueOfList = "LIST_VALUE"; + public const string Invert = "LIST_INVERT"; + + public static NativeFunctionCall CallWithName(string functionName) + { + return new NativeFunctionCall (functionName); + } + + public static bool CallExistsWithName(string functionName) + { + GenerateNativeFunctionsIfNecessary (); + return _nativeFunctions.ContainsKey (functionName); + } + + public string name { + get { + return _name; + } + protected set { + _name = value; + if( !_isPrototype ) + _prototype = _nativeFunctions [_name]; + } + } + string _name; + + public int numberOfParameters { + get { + if (_prototype) { + return _prototype.numberOfParameters; + } else { + return _numberOfParameters; + } + } + protected set { + _numberOfParameters = value; + } + } + + int _numberOfParameters; + + public Runtime.Object Call(List parameters) + { + if (_prototype) { + return _prototype.Call(parameters); + } + + if (numberOfParameters != parameters.Count) { + throw new System.Exception ("Unexpected number of parameters"); + } + + bool hasList = false; + foreach (var p in parameters) { + if (p is Void) + throw new StoryException ("Attempting to perform operation on a void value. Did you forget to 'return' a value from a function you called here?"); + if (p is ListValue) + hasList = true; + } + + // Binary operations on lists are treated outside of the standard coerscion rules + if( parameters.Count == 2 && hasList ) + return CallBinaryListOperation (parameters); + + var coercedParams = CoerceValuesToSingleType (parameters); + ValueType coercedType = coercedParams[0].valueType; + + if (coercedType == ValueType.Int) { + return Call (coercedParams); + } else if (coercedType == ValueType.Float) { + return Call (coercedParams); + } else if (coercedType == ValueType.String) { + return Call (coercedParams); + } else if (coercedType == ValueType.DivertTarget) { + return Call (coercedParams); + } else if (coercedType == ValueType.List) { + return Call (coercedParams); + } + + return null; + } + + Value Call(List parametersOfSingleType) + { + Value param1 = (Value) parametersOfSingleType [0]; + ValueType valType = param1.valueType; + + var val1 = (Value)param1; + + int paramCount = parametersOfSingleType.Count; + + if (paramCount == 2 || paramCount == 1) { + + object opForTypeObj = null; + if (!_operationFuncs.TryGetValue (valType, out opForTypeObj)) { + throw new StoryException ("Cannot perform operation '"+this.name+"' on "+valType); + } + + // Binary + if (paramCount == 2) { + Value param2 = (Value) parametersOfSingleType [1]; + + var val2 = (Value)param2; + + var opForType = (BinaryOp)opForTypeObj; + + // Return value unknown until it's evaluated + object resultVal = opForType (val1.value, val2.value); + + return Value.Create (resultVal); + } + + // Unary + else { + + var opForType = (UnaryOp)opForTypeObj; + + var resultVal = opForType (val1.value); + + return Value.Create (resultVal); + } + } + + else { + throw new System.Exception ("Unexpected number of parameters to NativeFunctionCall: " + parametersOfSingleType.Count); + } + } + + Value CallBinaryListOperation (List parameters) + { + // List-Int addition/subtraction returns a List (e.g. "alpha" + 1 = "beta") + if ((name == "+" || name == "-") && parameters [0] is ListValue && parameters [1] is IntValue) + return CallListIncrementOperation (parameters); + + var v1 = parameters [0] as Value; + var v2 = parameters [1] as Value; + + // And/or with any other type requires coerscion to bool (int) + if ((name == "&&" || name == "||") && (v1.valueType != ValueType.List || v2.valueType != ValueType.List)) { + var op = _operationFuncs [ValueType.Int] as BinaryOp; + var result = (bool)op (v1.isTruthy ? 1 : 0, v2.isTruthy ? 1 : 0); + return new BoolValue (result); + } + + // Normal (list • list) operation + if (v1.valueType == ValueType.List && v2.valueType == ValueType.List) + return Call (new List { v1, v2 }); + + throw new StoryException ("Can not call use '" + name + "' operation on " + v1.valueType + " and " + v2.valueType); + } + + Value CallListIncrementOperation (List listIntParams) + { + var listVal = (ListValue)listIntParams [0]; + var intVal = (IntValue)listIntParams [1]; + + + var resultRawList = new InkList (); + + foreach (var listItemWithValue in listVal.value) { + var listItem = listItemWithValue.Key; + var listItemValue = listItemWithValue.Value; + + // Find + or - operation + var intOp = (BinaryOp)_operationFuncs [ValueType.Int]; + + // Return value unknown until it's evaluated + int targetInt = (int) intOp (listItemValue, intVal.value); + + // Find this item's origin (linear search should be ok, should be short haha) + ListDefinition itemOrigin = null; + foreach (var origin in listVal.value.origins) { + if (origin.name == listItem.originName) { + itemOrigin = origin; + break; + } + } + if (itemOrigin != null) { + InkListItem incrementedItem; + if (itemOrigin.TryGetItemWithValue (targetInt, out incrementedItem)) + resultRawList.Add (incrementedItem, targetInt); + } + } + + return new ListValue (resultRawList); + } + + List CoerceValuesToSingleType(List parametersIn) + { + ValueType valType = ValueType.Int; + + ListValue specialCaseList = null; + + // Find out what the output type is + // "higher level" types infect both so that binary operations + // use the same type on both sides. e.g. binary operation of + // int and float causes the int to be casted to a float. + foreach (var obj in parametersIn) { + var val = (Value)obj; + if (val.valueType > valType) { + valType = val.valueType; + } + + if (val.valueType == ValueType.List) { + specialCaseList = val as ListValue; + } + } + + // Coerce to this chosen type + var parametersOut = new List (); + + // Special case: Coercing to Ints to Lists + // We have to do it early when we have both parameters + // to hand - so that we can make use of the List's origin + if (valType == ValueType.List) { + + foreach (Value val in parametersIn) { + if (val.valueType == ValueType.List) { + parametersOut.Add (val); + } else if (val.valueType == ValueType.Int) { + int intVal = (int)val.valueObject; + var list = specialCaseList.value.originOfMaxItem; + + InkListItem item; + if (list.TryGetItemWithValue (intVal, out item)) { + var castedValue = new ListValue (item, intVal); + parametersOut.Add (castedValue); + } else + throw new StoryException ("Could not find List item with the value " + intVal + " in " + list.name); + } else + throw new StoryException ("Cannot mix Lists and " + val.valueType + " values in this operation"); + } + + } + + // Normal Coercing (with standard casting) + else { + foreach (Value val in parametersIn) { + var castedValue = val.Cast (valType); + parametersOut.Add (castedValue); + } + } + + return parametersOut; + } + + public NativeFunctionCall(string name) + { + GenerateNativeFunctionsIfNecessary (); + + this.name = name; + } + + // Require default constructor for serialisation + public NativeFunctionCall() { + GenerateNativeFunctionsIfNecessary (); + } + + // Only called internally to generate prototypes + NativeFunctionCall (string name, int numberOfParameters) + { + _isPrototype = true; + this.name = name; + this.numberOfParameters = numberOfParameters; + } + + // For defining operations that do nothing to the specific type + // (but are still supported), such as floor/ceil on int and float + // cast on float. + static object Identity(T t) { + return t; + } + + static void GenerateNativeFunctionsIfNecessary() + { + if (_nativeFunctions == null) { + _nativeFunctions = new Dictionary (); + + // Why no bool operations? + // Before evaluation, all bools are coerced to ints in + // CoerceValuesToSingleType (see default value for valType at top). + // So, no operations are ever directly done in bools themselves. + // This also means that 1 == true works, since true is always converted + // to 1 first. + // However, many operations return a "native" bool (equals, etc). + + // Int operations + AddIntBinaryOp(Add, (x, y) => x + y); + AddIntBinaryOp(Subtract, (x, y) => x - y); + AddIntBinaryOp(Multiply, (x, y) => x * y); + AddIntBinaryOp(Divide, (x, y) => x / y); + AddIntBinaryOp(Mod, (x, y) => x % y); + AddIntUnaryOp (Negate, x => -x); + + AddIntBinaryOp(Equal, (x, y) => x == y); + AddIntBinaryOp(Greater, (x, y) => x > y); + AddIntBinaryOp(Less, (x, y) => x < y); + AddIntBinaryOp(GreaterThanOrEquals, (x, y) => x >= y); + AddIntBinaryOp(LessThanOrEquals, (x, y) => x <= y); + AddIntBinaryOp(NotEquals, (x, y) => x != y); + AddIntUnaryOp (Not, x => x == 0); + + AddIntBinaryOp(And, (x, y) => x != 0 && y != 0); + AddIntBinaryOp(Or, (x, y) => x != 0 || y != 0); + + AddIntBinaryOp(Max, (x, y) => Math.Max(x, y)); + AddIntBinaryOp(Min, (x, y) => Math.Min(x, y)); + + // Have to cast to float since you could do POW(2, -1) + AddIntBinaryOp (Pow, (x, y) => (float) Math.Pow(x, y)); + AddIntUnaryOp(Floor, Identity); + AddIntUnaryOp(Ceiling, Identity); + AddIntUnaryOp(Int, Identity); + AddIntUnaryOp (Float, x => (float)x); + + // Float operations + AddFloatBinaryOp(Add, (x, y) => x + y); + AddFloatBinaryOp(Subtract, (x, y) => x - y); + AddFloatBinaryOp(Multiply, (x, y) => x * y); + AddFloatBinaryOp(Divide, (x, y) => x / y); + AddFloatBinaryOp(Mod, (x, y) => x % y); // TODO: Is this the operation we want for floats? + AddFloatUnaryOp (Negate, x => -x); + + AddFloatBinaryOp(Equal, (x, y) => x == y); + AddFloatBinaryOp(Greater, (x, y) => x > y); + AddFloatBinaryOp(Less, (x, y) => x < y); + AddFloatBinaryOp(GreaterThanOrEquals, (x, y) => x >= y); + AddFloatBinaryOp(LessThanOrEquals, (x, y) => x <= y); + AddFloatBinaryOp(NotEquals, (x, y) => x != y); + AddFloatUnaryOp (Not, x => (x == 0.0f)); + + AddFloatBinaryOp(And, (x, y) => x != 0.0f && y != 0.0f); + AddFloatBinaryOp(Or, (x, y) => x != 0.0f || y != 0.0f); + + AddFloatBinaryOp(Max, (x, y) => Math.Max(x, y)); + AddFloatBinaryOp(Min, (x, y) => Math.Min(x, y)); + + AddFloatBinaryOp (Pow, (x, y) => (float)Math.Pow(x, y)); + AddFloatUnaryOp(Floor, x => (float)Math.Floor(x)); + AddFloatUnaryOp(Ceiling, x => (float)Math.Ceiling(x)); + AddFloatUnaryOp(Int, x => (int)x); + AddFloatUnaryOp(Float, Identity); + + // String operations + AddStringBinaryOp(Add, (x, y) => x + y); // concat + AddStringBinaryOp(Equal, (x, y) => x.Equals(y)); + AddStringBinaryOp (NotEquals, (x, y) => !x.Equals (y)); + AddStringBinaryOp (Has, (x, y) => x.Contains(y)); + AddStringBinaryOp (Hasnt, (x, y) => !x.Contains(y)); + + // List operations + AddListBinaryOp (Add, (x, y) => x.Union (y)); + AddListBinaryOp (Subtract, (x, y) => x.Without(y)); + AddListBinaryOp (Has, (x, y) => x.Contains (y)); + AddListBinaryOp (Hasnt, (x, y) => !x.Contains (y)); + AddListBinaryOp (Intersect, (x, y) => x.Intersect (y)); + + AddListBinaryOp (Equal, (x, y) => x.Equals(y)); + AddListBinaryOp (Greater, (x, y) => x.GreaterThan(y)); + AddListBinaryOp (Less, (x, y) => x.LessThan(y)); + AddListBinaryOp (GreaterThanOrEquals, (x, y) => x.GreaterThanOrEquals(y)); + AddListBinaryOp (LessThanOrEquals, (x, y) => x.LessThanOrEquals(y)); + AddListBinaryOp (NotEquals, (x, y) => !x.Equals(y)); + + AddListBinaryOp (And, (x, y) => x.Count > 0 && y.Count > 0); + AddListBinaryOp (Or, (x, y) => x.Count > 0 || y.Count > 0); + + AddListUnaryOp (Not, x => x.Count == 0 ? (int)1 : (int)0); + + // Placeholders to ensure that these special case functions can exist, + // since these function is never actually run, and is special cased in Call + AddListUnaryOp (Invert, x => x.inverse); + AddListUnaryOp (All, x => x.all); + AddListUnaryOp (ListMin, (x) => x.MinAsList()); + AddListUnaryOp (ListMax, (x) => x.MaxAsList()); + AddListUnaryOp (Count, (x) => x.Count); + AddListUnaryOp (ValueOfList, (x) => x.maxItem.Value); + + // Special case: The only operations you can do on divert target values + BinaryOp divertTargetsEqual = (Path d1, Path d2) => { + return d1.Equals (d2); + }; + BinaryOp divertTargetsNotEqual = (Path d1, Path d2) => { + return !d1.Equals (d2); + }; + AddOpToNativeFunc (Equal, 2, ValueType.DivertTarget, divertTargetsEqual); + AddOpToNativeFunc (NotEquals, 2, ValueType.DivertTarget, divertTargetsNotEqual); + + } + } + + void AddOpFuncForType(ValueType valType, object op) + { + if (_operationFuncs == null) { + _operationFuncs = new Dictionary (); + } + + _operationFuncs [valType] = op; + } + + static void AddOpToNativeFunc(string name, int args, ValueType valType, object op) + { + NativeFunctionCall nativeFunc = null; + if (!_nativeFunctions.TryGetValue (name, out nativeFunc)) { + nativeFunc = new NativeFunctionCall (name, args); + _nativeFunctions [name] = nativeFunc; + } + + nativeFunc.AddOpFuncForType (valType, op); + } + + static void AddIntBinaryOp(string name, BinaryOp op) + { + AddOpToNativeFunc (name, 2, ValueType.Int, op); + } + + static void AddIntUnaryOp(string name, UnaryOp op) + { + AddOpToNativeFunc (name, 1, ValueType.Int, op); + } + + static void AddFloatBinaryOp(string name, BinaryOp op) + { + AddOpToNativeFunc (name, 2, ValueType.Float, op); + } + + static void AddStringBinaryOp(string name, BinaryOp op) + { + AddOpToNativeFunc (name, 2, ValueType.String, op); + } + + static void AddListBinaryOp (string name, BinaryOp op) + { + AddOpToNativeFunc (name, 2, ValueType.List, op); + } + + static void AddListUnaryOp (string name, UnaryOp op) + { + AddOpToNativeFunc (name, 1, ValueType.List, op); + } + + static void AddFloatUnaryOp(string name, UnaryOp op) + { + AddOpToNativeFunc (name, 1, ValueType.Float, op); + } + + public override string ToString () + { + return "Native '" + name + "'"; + } + + delegate object BinaryOp(T left, T right); + delegate object UnaryOp(T val); + + NativeFunctionCall _prototype; + bool _isPrototype; + + // Operations for each data type, for a single operation (e.g. "+") + Dictionary _operationFuncs; + + static Dictionary _nativeFunctions; + + } +} + diff --git a/Assets/Ink/ink-engine-runtime/NativeFunctionCall.cs.meta b/Assets/Ink/ink-engine-runtime/NativeFunctionCall.cs.meta new file mode 100644 index 000000000..377d6c893 --- /dev/null +++ b/Assets/Ink/ink-engine-runtime/NativeFunctionCall.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: 1a912f0d8190780419888b68957cf67a +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/Assets/Ink/ink-engine-runtime/Object.cs b/Assets/Ink/ink-engine-runtime/Object.cs new file mode 100644 index 000000000..8a5c41bd8 --- /dev/null +++ b/Assets/Ink/ink-engine-runtime/Object.cs @@ -0,0 +1,250 @@ +using System; +using System.Collections.Generic; +using System.Diagnostics; + +namespace Ink.Runtime +{ + /// + /// Base class for all ink runtime content. + /// + public /* TODO: abstract */ class Object + { + /// + /// Runtime.Objects can be included in the main Story as a hierarchy. + /// Usually parents are Container objects. (TODO: Always?) + /// + /// The parent. + public Runtime.Object parent { get; set; } + + public Runtime.DebugMetadata debugMetadata { + get { + if (_debugMetadata == null) { + if (parent) { + return parent.debugMetadata; + } + } + + return _debugMetadata; + } + + set { + _debugMetadata = value; + } + } + + public Runtime.DebugMetadata ownDebugMetadata { + get { + return _debugMetadata; + } + } + + // TODO: Come up with some clever solution for not having + // to have debug metadata on the object itself, perhaps + // for serialisation purposes at least. + DebugMetadata _debugMetadata; + + public int? DebugLineNumberOfPath(Path path) + { + if (path == null) + return null; + + // Try to get a line number from debug metadata + var root = this.rootContentContainer; + if (root) { + Runtime.Object targetContent = root.ContentAtPath (path).obj; + if (targetContent) { + var dm = targetContent.debugMetadata; + if (dm != null) { + return dm.startLineNumber; + } + } + } + + return null; + } + + public Path path + { + get + { + if (_path == null) { + + if (parent == null) { + _path = new Path (); + } else { + // Maintain a Stack so that the order of the components + // is reversed when they're added to the Path. + // We're iterating up the hierarchy from the leaves/children to the root. + var comps = new Stack (); + + var child = this; + Container container = child.parent as Container; + + while (container) { + + var namedChild = child as INamedContent; + if (namedChild != null && namedChild.hasValidName) { + comps.Push (new Path.Component (namedChild.name)); + } else { + comps.Push (new Path.Component (container.content.IndexOf(child))); + } + + child = container; + container = container.parent as Container; + } + + _path = new Path (comps); + } + + } + + return _path; + } + } + Path _path; + + public SearchResult ResolvePath(Path path) + { + if (path.isRelative) { + + Container nearestContainer = this as Container; + if (!nearestContainer) { + Debug.Assert (this.parent != null, "Can't resolve relative path because we don't have a parent"); + nearestContainer = this.parent as Container; + Debug.Assert (nearestContainer != null, "Expected parent to be a container"); + Debug.Assert (path.GetComponent(0).isParent); + path = path.tail; + } + + return nearestContainer.ContentAtPath (path); + } else { + return this.rootContentContainer.ContentAtPath (path); + } + } + + public Path ConvertPathToRelative(Path globalPath) + { + // 1. Find last shared ancestor + // 2. Drill up using ".." style (actually represented as "^") + // 3. Re-build downward chain from common ancestor + + var ownPath = this.path; + + int minPathLength = Math.Min (globalPath.length, ownPath.length); + int lastSharedPathCompIndex = -1; + + for (int i = 0; i < minPathLength; ++i) { + var ownComp = ownPath.GetComponent(i); + var otherComp = globalPath.GetComponent(i); + + if (ownComp.Equals (otherComp)) { + lastSharedPathCompIndex = i; + } else { + break; + } + } + + // No shared path components, so just use global path + if (lastSharedPathCompIndex == -1) + return globalPath; + + int numUpwardsMoves = (ownPath.length-1) - lastSharedPathCompIndex; + + var newPathComps = new List (); + + for(int up=0; up(ref T obj, T value) where T : Runtime.Object + { + if (obj) + obj.parent = null; + + obj = value; + + if( obj ) + obj.parent = this; + } + + /// Allow implicit conversion to bool so you don't have to do: + /// if( myObj != null ) ... + public static implicit operator bool (Object obj) + { + var isNull = object.ReferenceEquals (obj, null); + return !isNull; + } + + /// Required for implicit bool comparison + public static bool operator ==(Object a, Object b) + { + return object.ReferenceEquals (a, b); + } + + /// Required for implicit bool comparison + public static bool operator !=(Object a, Object b) + { + return !(a == b); + } + + /// Required for implicit bool comparison + public override bool Equals (object obj) + { + return object.ReferenceEquals (obj, this); + } + + /// Required for implicit bool comparison + public override int GetHashCode () + { + return base.GetHashCode (); + } + } +} + diff --git a/Assets/Ink/ink-engine-runtime/Object.cs.meta b/Assets/Ink/ink-engine-runtime/Object.cs.meta new file mode 100644 index 000000000..0e5200411 --- /dev/null +++ b/Assets/Ink/ink-engine-runtime/Object.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: 94950ad348dccda4ab58771328161324 +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/Assets/Ink/ink-engine-runtime/Path.cs b/Assets/Ink/ink-engine-runtime/Path.cs new file mode 100644 index 000000000..428b2fc76 --- /dev/null +++ b/Assets/Ink/ink-engine-runtime/Path.cs @@ -0,0 +1,277 @@ +using System; +using System.Collections.Generic; +using System.Linq; +using System.Diagnostics; +using Ink.Runtime; + +namespace Ink.Runtime +{ + public class Path : IEquatable + { + static string parentId = "^"; + + // Immutable Component + public class Component : IEquatable + { + public int index { get; private set; } + public string name { get; private set; } + public bool isIndex { get { return index >= 0; } } + public bool isParent { + get { + return name == Path.parentId; + } + } + + public Component(int index) + { + Debug.Assert(index >= 0); + this.index = index; + this.name = null; + } + + public Component(string name) + { + Debug.Assert(name != null && name.Length > 0); + this.name = name; + this.index = -1; + } + + public static Component ToParent() + { + return new Component (parentId); + } + + public override string ToString () + { + if (isIndex) { + return index.ToString (); + } else { + return name; + } + } + + public override bool Equals (object obj) + { + return Equals (obj as Component); + } + + public bool Equals(Component otherComp) + { + if (otherComp != null && otherComp.isIndex == this.isIndex) { + if (isIndex) { + return index == otherComp.index; + } else { + return name == otherComp.name; + } + } + + return false; + } + + public override int GetHashCode () + { + if (isIndex) + return this.index; + else + return this.name.GetHashCode (); + } + } + + public Component GetComponent(int index) + { + return _components[index]; + } + + public bool isRelative { get; private set; } + + public Component head + { + get + { + if (_components.Count > 0) { + return _components.First (); + } else { + return null; + } + } + } + + public Path tail + { + get + { + if (_components.Count >= 2) { + List tailComps = _components.GetRange (1, _components.Count - 1); + return new Path(tailComps); + } + + else { + return Path.self; + } + + } + } + + public int length { get { return _components.Count; } } + + public Component lastComponent + { + get + { + var lastComponentIdx = _components.Count-1; + if( lastComponentIdx >= 0 ) + return _components[lastComponentIdx]; + else + return null; + } + } + + public bool containsNamedComponent { + get { + foreach(var comp in _components) { + if( !comp.isIndex ) { + return true; + } + } + return false; + } + } + + public Path() + { + _components = new List (); + } + + public Path(Component head, Path tail) : this() + { + _components.Add (head); + _components.AddRange (tail._components); + } + + public Path(IEnumerable components, bool relative = false) : this() + { + this._components.AddRange (components); + this.isRelative = relative; + } + + public Path(string componentsString) : this() + { + this.componentsString = componentsString; + } + + public static Path self { + get { + var path = new Path (); + path.isRelative = true; + return path; + } + } + + public Path PathByAppendingPath(Path pathToAppend) + { + Path p = new Path (); + + int upwardMoves = 0; + for (int i = 0; i < pathToAppend._components.Count; ++i) { + if (pathToAppend._components [i].isParent) { + upwardMoves++; + } else { + break; + } + } + + for (int i = 0; i < this._components.Count - upwardMoves; ++i) { + p._components.Add (this._components [i]); + } + + for(int i=upwardMoves; i _components; + } +} + diff --git a/Assets/Ink/ink-engine-runtime/Path.cs.meta b/Assets/Ink/ink-engine-runtime/Path.cs.meta new file mode 100644 index 000000000..8ab3ad0b8 --- /dev/null +++ b/Assets/Ink/ink-engine-runtime/Path.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: 3a78230b594be554b92b2aa00d9ae9bd +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/Assets/Ink/ink-engine-runtime/Pointer.cs b/Assets/Ink/ink-engine-runtime/Pointer.cs new file mode 100644 index 000000000..66fec9a73 --- /dev/null +++ b/Assets/Ink/ink-engine-runtime/Pointer.cs @@ -0,0 +1,70 @@ +using Ink.Runtime; + +namespace Ink.Runtime +{ + /// + /// Internal structure used to point to a particular / current point in the story. + /// Where Path is a set of components that make content fully addressable, this is + /// a reference to the current container, and the index of the current piece of + /// content within that container. This scheme makes it as fast and efficient as + /// possible to increment the pointer (move the story forwards) in a way that's as + /// native to the internal engine as possible. + /// + public struct Pointer + { + public Container container; + public int index; + + public Pointer (Container container, int index) + { + this.container = container; + this.index = index; + } + + public Runtime.Object Resolve () + { + if (index < 0) return container; + if (container == null) return null; + if (container.content.Count == 0) return container; + if (index >= container.content.Count) return null; + return container.content [index]; + + } + + public bool isNull { + get { + return container == null; + } + } + + public Path path { + get { + if( isNull ) return null; + + if (index >= 0) + return container.path.PathByAppendingComponent (new Path.Component(index)); + else + return container.path; + } + } + + public override string ToString () + { + if (container == null) + return "Ink Pointer (null)"; + + return "Ink Pointer -> " + container.path.ToString () + " -- index " + index; + } + + public static Pointer StartOf (Container container) + { + return new Pointer { + container = container, + index = 0 + }; + } + + public static Pointer Null = new Pointer { container = null, index = -1 }; + + } +} \ No newline at end of file diff --git a/Assets/Ink/ink-engine-runtime/Pointer.cs.meta b/Assets/Ink/ink-engine-runtime/Pointer.cs.meta new file mode 100644 index 000000000..98a748a1b --- /dev/null +++ b/Assets/Ink/ink-engine-runtime/Pointer.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: 53427f8720f617140905561c471b1ca7 +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/Assets/Ink/ink-engine-runtime/Profiler.cs b/Assets/Ink/ink-engine-runtime/Profiler.cs new file mode 100644 index 000000000..5de70a144 --- /dev/null +++ b/Assets/Ink/ink-engine-runtime/Profiler.cs @@ -0,0 +1,394 @@ +using System; +using System.Diagnostics; +using System.Collections.Generic; +using System.Text; +using System.Linq; + +namespace Ink.Runtime +{ + /// + /// Simple ink profiler that logs every instruction in the story and counts frequency and timing. + /// To use: + /// + /// var profiler = story.StartProfiling(), + /// + /// (play your story for a bit) + /// + /// var reportStr = profiler.Report(); + /// + /// story.EndProfiling(); + /// + /// + public class Profiler + { + /// + /// The root node in the hierarchical tree of recorded ink timings. + /// + public ProfileNode rootNode { + get { + return _rootNode; + } + } + + public Profiler() { + _rootNode = new ProfileNode(); + } + + /// + /// Generate a printable report based on the data recording during profiling. + /// + public string Report() { + var sb = new StringBuilder(); + sb.AppendFormat("{0} CONTINUES / LINES:\n", _numContinues); + sb.AppendFormat("TOTAL TIME: {0}\n", FormatMillisecs(_continueTotal)); + sb.AppendFormat("SNAPSHOTTING: {0}\n", FormatMillisecs(_snapTotal)); + sb.AppendFormat("OTHER: {0}\n", FormatMillisecs(_continueTotal - (_stepTotal + _snapTotal))); + sb.Append(_rootNode.ToString()); + return sb.ToString(); + } + + public void PreContinue() { + _continueWatch.Reset(); + _continueWatch.Start(); + } + + public void PostContinue() { + _continueWatch.Stop(); + _continueTotal += Millisecs(_continueWatch); + _numContinues++; + } + + public void PreStep() { + _currStepStack = null; + _stepWatch.Reset(); + _stepWatch.Start(); + } + + public void Step(CallStack callstack) + { + _stepWatch.Stop(); + + var stack = new string[callstack.elements.Count]; + for(int i=0; i + /// Generate a printable report specifying the average and maximum times spent + /// stepping over different internal ink instruction types. + /// This report type is primarily used to profile the ink engine itself rather + /// than your own specific ink. + /// + public string StepLengthReport() + { + var sb = new StringBuilder(); + + sb.AppendLine("TOTAL: "+_rootNode.totalMillisecs+"ms"); + + var averageStepTimes = _stepDetails + .GroupBy(s => s.type) + .Select(typeToDetails => new KeyValuePair(typeToDetails.Key, typeToDetails.Average(d => d.time))) + .OrderByDescending(stepTypeToAverage => stepTypeToAverage.Value) + .Select(stepTypeToAverage => { + var typeName = stepTypeToAverage.Key; + var time = stepTypeToAverage.Value; + return typeName + ": " + time + "ms"; + }) + .ToArray(); + + sb.AppendLine("AVERAGE STEP TIMES: "+string.Join(", ", averageStepTimes)); + + var accumStepTimes = _stepDetails + .GroupBy(s => s.type) + .Select(typeToDetails => new KeyValuePair(typeToDetails.Key + " (x"+typeToDetails.Count()+")", typeToDetails.Sum(d => d.time))) + .OrderByDescending(stepTypeToAccum => stepTypeToAccum.Value) + .Select(stepTypeToAccum => { + var typeName = stepTypeToAccum.Key; + var time = stepTypeToAccum.Value; + return typeName + ": " + time; + }) + .ToArray(); + + sb.AppendLine("ACCUMULATED STEP TIMES: "+string.Join(", ", accumStepTimes)); + + return sb.ToString(); + } + + /// + /// Create a large log of all the internal instructions that were evaluated while profiling was active. + /// Log is in a tab-separated format, for easy loading into a spreadsheet application. + /// + public string Megalog() + { + var sb = new StringBuilder(); + + sb.AppendLine("Step type\tDescription\tPath\tTime"); + + foreach(var step in _stepDetails) { + sb.Append(step.type); + sb.Append("\t"); + sb.Append(step.obj.ToString()); + sb.Append("\t"); + sb.Append(step.obj.path); + sb.Append("\t"); + sb.AppendLine(step.time.ToString("F8")); + } + + return sb.ToString(); + } + + public void PreSnapshot() { + _snapWatch.Reset(); + _snapWatch.Start(); + } + + public void PostSnapshot() { + _snapWatch.Stop(); + _snapTotal += Millisecs(_snapWatch); + } + + double Millisecs(Stopwatch watch) + { + var ticks = watch.ElapsedTicks; + return ticks * _millisecsPerTick; + } + + public static string FormatMillisecs(double num) { + if( num > 5000 ) { + return string.Format("{0:N1} secs", num / 1000.0); + } if( num > 1000 ) { + return string.Format("{0:N2} secs", num / 1000.0); + } else if( num > 100 ) { + return string.Format("{0:N0} ms", num); + } else if( num > 1 ) { + return string.Format("{0:N1} ms", num); + } else if( num > 0.01 ) { + return string.Format("{0:N3} ms", num); + } else { + return string.Format("{0:N} ms", num); + } + } + + Stopwatch _continueWatch = new Stopwatch(); + Stopwatch _stepWatch = new Stopwatch(); + Stopwatch _snapWatch = new Stopwatch(); + + double _continueTotal; + double _snapTotal; + double _stepTotal; + + string[] _currStepStack; + StepDetails _currStepDetails; + ProfileNode _rootNode; + int _numContinues; + + struct StepDetails { + public string type; + public Runtime.Object obj; + public double time; + } + List _stepDetails = new List(); + + static double _millisecsPerTick = 1000.0 / Stopwatch.Frequency; + } + + + /// + /// Node used in the hierarchical tree of timings used by the Profiler. + /// Each node corresponds to a single line viewable in a UI-based representation. + /// + public class ProfileNode { + + /// + /// The key for the node corresponds to the printable name of the callstack element. + /// + public readonly string key; + + + #pragma warning disable 0649 + /// + /// Horribly hacky field only used by ink unity integration, + /// but saves constructing an entire data structure that mirrors + /// the one in here purely to store the state of whether each + /// node in the UI has been opened or not /// + public bool openInUI; + #pragma warning restore 0649 + + /// + /// Whether this node contains any sub-nodes - i.e. does it call anything else + /// that has been recorded? + /// + /// true if has children; otherwise, false. + public bool hasChildren { + get { + return _nodes != null && _nodes.Count > 0; + } + } + + /// + /// Total number of milliseconds this node has been active for. + /// + public int totalMillisecs { + get { + return (int)_totalMillisecs; + } + } + + public ProfileNode() { + + } + + public ProfileNode(string key) { + this.key = key; + } + + public void AddSample(string[] stack, double duration) { + AddSample(stack, -1, duration); + } + + void AddSample(string[] stack, int stackIdx, double duration) { + + _totalSampleCount++; + _totalMillisecs += duration; + + if( stackIdx == stack.Length-1 ) { + _selfSampleCount++; + _selfMillisecs += duration; + } + + if( stackIdx+1 < stack.Length ) + AddSampleToNode(stack, stackIdx+1, duration); + } + + void AddSampleToNode(string[] stack, int stackIdx, double duration) + { + var nodeKey = stack[stackIdx]; + if( _nodes == null ) _nodes = new Dictionary(); + + ProfileNode node; + if( !_nodes.TryGetValue(nodeKey, out node) ) { + node = new ProfileNode(nodeKey); + _nodes[nodeKey] = node; + } + + node.AddSample(stack, stackIdx, duration); + } + + /// + /// Returns a sorted enumerable of the nodes in descending order of + /// how long they took to run. + /// + public IEnumerable> descendingOrderedNodes { + get { + if( _nodes == null ) return null; + return _nodes.OrderByDescending(keyNode => keyNode.Value._totalMillisecs); + } + } + + void PrintHierarchy(StringBuilder sb, int indent) + { + Pad(sb, indent); + + sb.Append(key); + sb.Append(": "); + sb.AppendLine(ownReport); + + if( _nodes == null ) return; + + foreach(var keyNode in descendingOrderedNodes) { + keyNode.Value.PrintHierarchy(sb, indent+1); + } + } + + /// + /// Generates a string giving timing information for this single node, including + /// total milliseconds spent on the piece of ink, the time spent within itself + /// (v.s. spent in children), as well as the number of samples (instruction steps) + /// recorded for both too. + /// + /// The own report. + public string ownReport { + get { + var sb = new StringBuilder(); + sb.Append("total "); + sb.Append(Profiler.FormatMillisecs(_totalMillisecs)); + sb.Append(", self "); + sb.Append(Profiler.FormatMillisecs(_selfMillisecs)); + sb.Append(" ("); + sb.Append(_selfSampleCount); + sb.Append(" self samples, "); + sb.Append(_totalSampleCount); + sb.Append(" total)"); + return sb.ToString(); + } + + } + + void Pad(StringBuilder sb, int spaces) + { + for(int i=0; i + /// String is a report of the sub-tree from this node, but without any of the header information + /// that's prepended by the Profiler in its Report() method. + /// + public override string ToString () + { + var sb = new StringBuilder(); + PrintHierarchy(sb, 0); + return sb.ToString(); + } + + Dictionary _nodes; + double _selfMillisecs; + double _totalMillisecs; + int _selfSampleCount; + int _totalSampleCount; + } +} + diff --git a/Assets/Ink/ink-engine-runtime/Profiler.cs.meta b/Assets/Ink/ink-engine-runtime/Profiler.cs.meta new file mode 100644 index 000000000..8a634b527 --- /dev/null +++ b/Assets/Ink/ink-engine-runtime/Profiler.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: 4a0476fcd5f718841ba464f731f2263f +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/Assets/Ink/ink-engine-runtime/PushPop.cs b/Assets/Ink/ink-engine-runtime/PushPop.cs new file mode 100644 index 000000000..42a29bfbd --- /dev/null +++ b/Assets/Ink/ink-engine-runtime/PushPop.cs @@ -0,0 +1,13 @@ +using System; +using System.Collections.Generic; + +namespace Ink.Runtime +{ + public enum PushPopType + { + Tunnel, + Function, + FunctionEvaluationFromGame + } +} + diff --git a/Assets/Ink/ink-engine-runtime/PushPop.cs.meta b/Assets/Ink/ink-engine-runtime/PushPop.cs.meta new file mode 100644 index 000000000..c6e801d73 --- /dev/null +++ b/Assets/Ink/ink-engine-runtime/PushPop.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: e72a7bf0bc13de648abf8411328190a3 +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/Assets/Ink/ink-engine-runtime/SearchResult.cs b/Assets/Ink/ink-engine-runtime/SearchResult.cs new file mode 100644 index 000000000..e3a8c2468 --- /dev/null +++ b/Assets/Ink/ink-engine-runtime/SearchResult.cs @@ -0,0 +1,18 @@ +using System; +namespace Ink.Runtime +{ + // When looking up content within the story (e.g. in Container.ContentAtPath), + // the result is generally found, but if the story is modified, then when loading + // up an old save state, then some old paths may still exist. In this case we + // try to recover by finding an approximate result by working up the story hierarchy + // in the path to find the closest valid container. Instead of crashing horribly, + // we might see some slight oddness in the content, but hopefully it recovers! + public struct SearchResult + { + public Runtime.Object obj; + public bool approximate; + + public Runtime.Object correctObj { get { return approximate ? null : obj; } } + public Container container { get { return obj as Container; } } + } +} diff --git a/Assets/Ink/ink-engine-runtime/SearchResult.cs.meta b/Assets/Ink/ink-engine-runtime/SearchResult.cs.meta new file mode 100644 index 000000000..bff56b907 --- /dev/null +++ b/Assets/Ink/ink-engine-runtime/SearchResult.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: d0d28d3d017b900408b7b901473a5393 +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/Assets/Ink/ink-engine-runtime/SimpleJson.cs b/Assets/Ink/ink-engine-runtime/SimpleJson.cs new file mode 100644 index 000000000..7494410c3 --- /dev/null +++ b/Assets/Ink/ink-engine-runtime/SimpleJson.cs @@ -0,0 +1,647 @@ +using System; +using System.Text; +using System.Collections.Generic; +using System.IO; + +namespace Ink.Runtime +{ + /// + /// Simple custom JSON serialisation implementation that takes JSON-able System.Collections that + /// are produced by the ink engine and converts to and from JSON text. + /// + public static class SimpleJson + { + public static Dictionary TextToDictionary (string text) + { + return new Reader (text).ToDictionary (); + } + + public static List TextToArray(string text) + { + return new Reader(text).ToArray(); + } + + class Reader + { + public Reader (string text) + { + _text = text; + _offset = 0; + + SkipWhitespace (); + + _rootObject = ReadObject (); + } + + public Dictionary ToDictionary () + { + return (Dictionary)_rootObject; + } + + public List ToArray() + { + return (List)_rootObject; + } + + bool IsNumberChar (char c) + { + return c >= '0' && c <= '9' || c == '.' || c == '-' || c == '+' || c == 'E' || c == 'e'; + } + + bool IsFirstNumberChar(char c) + { + return c >= '0' && c <= '9' || c == '-' || c == '+'; + } + + object ReadObject () + { + var currentChar = _text [_offset]; + + if( currentChar == '{' ) + return ReadDictionary (); + + else if (currentChar == '[') + return ReadArray (); + + else if (currentChar == '"') + return ReadString (); + + else if (IsFirstNumberChar(currentChar)) + return ReadNumber (); + + else if (TryRead ("true")) + return true; + + else if (TryRead ("false")) + return false; + + else if (TryRead ("null")) + return null; + + throw new System.Exception ("Unhandled object type in JSON: "+_text.Substring (_offset, 30)); + } + + Dictionary ReadDictionary () + { + var dict = new Dictionary (); + + Expect ("{"); + + SkipWhitespace (); + + // Empty dictionary? + if (TryRead ("}")) + return dict; + + do { + + SkipWhitespace (); + + // Key + var key = ReadString (); + Expect (key != null, "dictionary key"); + + SkipWhitespace (); + + // : + Expect (":"); + + SkipWhitespace (); + + // Value + var val = ReadObject (); + Expect (val != null, "dictionary value"); + + // Add to dictionary + dict [key] = val; + + SkipWhitespace (); + + } while ( TryRead (",") ); + + Expect ("}"); + + return dict; + } + + List ReadArray () + { + var list = new List (); + + Expect ("["); + + SkipWhitespace (); + + // Empty list? + if (TryRead ("]")) + return list; + + do { + + SkipWhitespace (); + + // Value + var val = ReadObject (); + + // Add to array + list.Add (val); + + SkipWhitespace (); + + } while (TryRead (",")); + + Expect ("]"); + + return list; + } + + string ReadString () + { + Expect ("\""); + + var sb = new StringBuilder(); + + for (; _offset < _text.Length; _offset++) { + var c = _text [_offset]; + + if (c == '\\') { + // Escaped character + _offset++; + if (_offset >= _text.Length) { + throw new Exception("Unexpected EOF while reading string"); + } + c = _text[_offset]; + switch (c) + { + case '"': + case '\\': + case '/': // Yes, JSON allows this to be escaped + sb.Append(c); + break; + case 'n': + sb.Append('\n'); + break; + case 't': + sb.Append('\t'); + break; + case 'r': + case 'b': + case 'f': + // Ignore other control characters + break; + case 'u': + // 4-digit Unicode + if (_offset + 4 >=_text.Length) { + throw new Exception("Unexpected EOF while reading string"); + } + var digits = _text.Substring(_offset + 1, 4); + int uchar; + if (int.TryParse(digits, System.Globalization.NumberStyles.AllowHexSpecifier, System.Globalization.CultureInfo.InvariantCulture, out uchar)) { + sb.Append((char)uchar); + _offset += 4; + } else { + throw new Exception("Invalid Unicode escape character at offset " + (_offset - 1)); + } + break; + default: + // The escaped character is invalid per json spec + throw new Exception("Invalid Unicode escape character at offset " + (_offset - 1)); + } + } else if( c == '"' ) { + break; + } else { + sb.Append(c); + } + } + + Expect ("\""); + return sb.ToString(); + } + + object ReadNumber () + { + var startOffset = _offset; + + bool isFloat = false; + for (; _offset < _text.Length; _offset++) { + var c = _text [_offset]; + if (c == '.' || c == 'e' || c == 'E') isFloat = true; + if (IsNumberChar (c)) + continue; + else + break; + } + + string numStr = _text.Substring (startOffset, _offset - startOffset); + + if (isFloat) { + float f; + if (float.TryParse (numStr, System.Globalization.NumberStyles.Float, System.Globalization.CultureInfo.InvariantCulture, out f)) { + return f; + } + } else { + int i; + if (int.TryParse (numStr, out i)) { + return i; + } + } + + throw new System.Exception ("Failed to parse number value: "+numStr); + } + + bool TryRead (string textToRead) + { + if (_offset + textToRead.Length > _text.Length) + return false; + + for (int i = 0; i < textToRead.Length; i++) { + if (textToRead [i] != _text [_offset + i]) + return false; + } + + _offset += textToRead.Length; + + return true; + } + + void Expect (string expectedStr) + { + if (!TryRead (expectedStr)) + Expect (false, expectedStr); + } + + void Expect (bool condition, string message = null) + { + if (!condition) { + if (message == null) { + message = "Unexpected token"; + } else { + message = "Expected " + message; + } + message += " at offset " + _offset; + + throw new System.Exception (message); + } + } + + void SkipWhitespace () + { + while (_offset < _text.Length) { + var c = _text [_offset]; + if (c == ' ' || c == '\t' || c == '\n' || c == '\r') + _offset++; + else + break; + } + } + + string _text; + int _offset; + + object _rootObject; + } + + + public class Writer + { + public Writer() + { + _writer = new StringWriter(); + } + + public Writer(Stream stream) + { + _writer = new System.IO.StreamWriter(stream, Encoding.UTF8); + } + + public void WriteObject(Action inner) + { + WriteObjectStart(); + inner(this); + WriteObjectEnd(); + } + + public void WriteObjectStart() + { + StartNewObject(container: true); + _stateStack.Push(new StateElement { type = State.Object }); + _writer.Write("{"); + } + + public void WriteObjectEnd() + { + Assert(state == State.Object); + _writer.Write("}"); + _stateStack.Pop(); + } + + public void WriteProperty(string name, Action inner) + { + WriteProperty(name, inner); + } + + public void WriteProperty(int id, Action inner) + { + WriteProperty(id, inner); + } + + public void WriteProperty(string name, string content) + { + WritePropertyStart(name); + Write(content); + WritePropertyEnd(); + } + + public void WriteProperty(string name, int content) + { + WritePropertyStart(name); + Write(content); + WritePropertyEnd(); + } + + public void WriteProperty(string name, bool content) + { + WritePropertyStart(name); + Write(content); + WritePropertyEnd(); + } + + public void WritePropertyStart(string name) + { + WritePropertyStart(name); + } + + public void WritePropertyStart(int id) + { + WritePropertyStart(id); + } + + public void WritePropertyEnd() + { + Assert(state == State.Property); + Assert(childCount == 1); + _stateStack.Pop(); + } + + public void WritePropertyNameStart() + { + Assert(state == State.Object); + + if (childCount > 0) + _writer.Write(","); + + _writer.Write("\""); + + IncrementChildCount(); + + _stateStack.Push(new StateElement { type = State.Property }); + _stateStack.Push(new StateElement { type = State.PropertyName }); + } + + public void WritePropertyNameEnd() + { + Assert(state == State.PropertyName); + + _writer.Write("\":"); + + // Pop PropertyName, leaving Property state + _stateStack.Pop(); + } + + public void WritePropertyNameInner(string str) + { + Assert(state == State.PropertyName); + _writer.Write(str); + } + + void WritePropertyStart(T name) + { + Assert(state == State.Object); + + if (childCount > 0) + _writer.Write(","); + + _writer.Write("\""); + _writer.Write(name); + _writer.Write("\":"); + + IncrementChildCount(); + + _stateStack.Push(new StateElement { type = State.Property }); + } + + + // allow name to be string or int + void WriteProperty(T name, Action inner) + { + WritePropertyStart(name); + + inner(this); + + WritePropertyEnd(); + } + + public void WriteArrayStart() + { + StartNewObject(container: true); + _stateStack.Push(new StateElement { type = State.Array }); + _writer.Write("["); + } + + public void WriteArrayEnd() + { + Assert(state == State.Array); + _writer.Write("]"); + _stateStack.Pop(); + } + + public void Write(int i) + { + StartNewObject(container: false); + _writer.Write(i); + } + + public void Write(float f) + { + StartNewObject(container: false); + + // TODO: Find an heap-allocation-free way to do this please! + // _writer.Write(formatStr, obj (the float)) requires boxing + // Following implementation seems to work ok but requires creating temporary garbage string. + string floatStr = f.ToString(System.Globalization.CultureInfo.InvariantCulture); + if( floatStr == "Infinity" ) { + _writer.Write("3.4E+38"); // JSON doesn't support, do our best alternative + } else if (floatStr == "-Infinity") { + _writer.Write("-3.4E+38"); // JSON doesn't support, do our best alternative + } else if ( floatStr == "NaN" ) { + _writer.Write("0.0"); // JSON doesn't support, not much we can do + } else { + _writer.Write(floatStr); + if (!floatStr.Contains(".") && !floatStr.Contains("E")) + _writer.Write(".0"); // ensure it gets read back in as a floating point value + } + } + + public void Write(string str, bool escape = true) + { + StartNewObject(container: false); + + _writer.Write("\""); + if (escape) + WriteEscapedString(str); + else + _writer.Write(str); + _writer.Write("\""); + } + + public void Write(bool b) + { + StartNewObject(container: false); + _writer.Write(b ? "true" : "false"); + } + + public void WriteNull() + { + StartNewObject(container: false); + _writer.Write("null"); + } + + public void WriteStringStart() + { + StartNewObject(container: false); + _stateStack.Push(new StateElement { type = State.String }); + _writer.Write("\""); + } + + public void WriteStringEnd() + { + Assert(state == State.String); + _writer.Write("\""); + _stateStack.Pop(); + } + + public void WriteStringInner(string str, bool escape = true) + { + Assert(state == State.String); + if (escape) + WriteEscapedString(str); + else + _writer.Write(str); + } + + void WriteEscapedString(string str) + { + foreach (var c in str) + { + if (c < ' ') + { + // Don't write any control characters except \n and \t + switch (c) + { + case '\n': + _writer.Write("\\n"); + break; + case '\t': + _writer.Write("\\t"); + break; + } + } + else + { + switch (c) + { + case '\\': + case '"': + _writer.Write("\\"); + _writer.Write(c); + break; + default: + _writer.Write(c); + break; + } + } + } + } + + void StartNewObject(bool container) + { + + if (container) + Assert(state == State.None || state == State.Property || state == State.Array); + else + Assert(state == State.Property || state == State.Array); + + if (state == State.Array && childCount > 0) + _writer.Write(","); + + if (state == State.Property) + Assert(childCount == 0); + + if (state == State.Array || state == State.Property) + IncrementChildCount(); + } + + State state + { + get + { + if (_stateStack.Count > 0) return _stateStack.Peek().type; + else return State.None; + } + } + + int childCount + { + get + { + if (_stateStack.Count > 0) return _stateStack.Peek().childCount; + else return 0; + } + } + + void IncrementChildCount() + { + Assert(_stateStack.Count > 0); + var currEl = _stateStack.Pop(); + currEl.childCount++; + _stateStack.Push(currEl); + } + + // Shouldn't hit this assert outside of initial JSON development, + // so it's save to make it debug-only. + [System.Diagnostics.Conditional("DEBUG")] + void Assert(bool condition) + { + if (!condition) + throw new System.Exception("Assert failed while writing JSON"); + } + + public override string ToString() + { + return _writer.ToString(); + } + + enum State + { + None, + Object, + Array, + Property, + PropertyName, + String + }; + + struct StateElement + { + public State type; + public int childCount; + } + + Stack _stateStack = new Stack(); + TextWriter _writer; + } + + + } +} + diff --git a/Assets/Ink/ink-engine-runtime/SimpleJson.cs.meta b/Assets/Ink/ink-engine-runtime/SimpleJson.cs.meta new file mode 100644 index 000000000..9855b689d --- /dev/null +++ b/Assets/Ink/ink-engine-runtime/SimpleJson.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: c6355a05044c6ba4e94d75116703416e +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/Assets/Ink/ink-engine-runtime/StatePatch.cs b/Assets/Ink/ink-engine-runtime/StatePatch.cs new file mode 100644 index 000000000..2cc56403a --- /dev/null +++ b/Assets/Ink/ink-engine-runtime/StatePatch.cs @@ -0,0 +1,66 @@ +using System.Collections.Generic; + +namespace Ink.Runtime +{ + public class StatePatch + { + public Dictionary globals { get { return _globals; } } + public HashSet changedVariables { get { return _changedVariables; } } + public Dictionary visitCounts { get { return _visitCounts; } } + public Dictionary turnIndices { get { return _turnIndices; } } + + public StatePatch(StatePatch toCopy) + { + if( toCopy != null ) { + _globals = new Dictionary(toCopy._globals); + _changedVariables = new HashSet(toCopy._changedVariables); + _visitCounts = new Dictionary(toCopy._visitCounts); + _turnIndices = new Dictionary(toCopy._turnIndices); + } else { + _globals = new Dictionary(); + _changedVariables = new HashSet(); + _visitCounts = new Dictionary(); + _turnIndices = new Dictionary(); + } + } + + public bool TryGetGlobal(string name, out Runtime.Object value) + { + return _globals.TryGetValue(name, out value); + } + + public void SetGlobal(string name, Runtime.Object value){ + _globals[name] = value; + } + + public void AddChangedVariable(string name) + { + _changedVariables.Add(name); + } + + public bool TryGetVisitCount(Container container, out int count) + { + return _visitCounts.TryGetValue(container, out count); + } + + public void SetVisitCount(Container container, int count) + { + _visitCounts[container] = count; + } + + public void SetTurnIndex(Container container, int index) + { + _turnIndices[container] = index; + } + + public bool TryGetTurnIndex(Container container, out int index) + { + return _turnIndices.TryGetValue(container, out index); + } + + Dictionary _globals; + HashSet _changedVariables = new HashSet(); + Dictionary _visitCounts = new Dictionary(); + Dictionary _turnIndices = new Dictionary(); + } +} diff --git a/Assets/Ink/ink-engine-runtime/StatePatch.cs.meta b/Assets/Ink/ink-engine-runtime/StatePatch.cs.meta new file mode 100644 index 000000000..4c4fa19a9 --- /dev/null +++ b/Assets/Ink/ink-engine-runtime/StatePatch.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: f26c35958c072a440bffd516a609cf86 +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/Assets/Ink/ink-engine-runtime/Story.cs b/Assets/Ink/ink-engine-runtime/Story.cs new file mode 100644 index 000000000..cd9a5cefb --- /dev/null +++ b/Assets/Ink/ink-engine-runtime/Story.cs @@ -0,0 +1,2774 @@ +using System; +using System.Collections.Generic; +using System.Linq; +using System.Text; +using System.IO; +using System.Diagnostics; + +namespace Ink.Runtime +{ + /// + /// A Story is the core class that represents a complete Ink narrative, and + /// manages the evaluation and state of it. + /// + public class Story : Runtime.Object + { + /// + /// The current version of the ink story file format. + /// + public const int inkVersionCurrent = 20; + + // Version numbers are for engine itself and story file, rather + // than the story state save format + // -- old engine, new format: always fail + // -- new engine, old format: possibly cope, based on this number + // When incrementing the version number above, the question you + // should ask yourself is: + // -- Will the engine be able to load an old story file from + // before I made these changes to the engine? + // If possible, you should support it, though it's not as + // critical as loading old save games, since it's an + // in-development problem only. + + /// + /// The minimum legacy version of ink that can be loaded by the current version of the code. + /// + const int inkVersionMinimumCompatible = 18; + + /// + /// The list of Choice objects available at the current point in + /// the Story. This list will be populated as the Story is stepped + /// through with the Continue() method. Once canContinue becomes + /// false, this list will be populated, and is usually + /// (but not always) on the final Continue() step. + /// + public List currentChoices + { + get + { + // Don't include invisible choices for external usage. + var choices = new List(); + foreach (var c in _state.currentChoices) { + if (!c.isInvisibleDefault) { + c.index = choices.Count; + choices.Add (c); + } + } + return choices; + } + } + + /// + /// The latest line of text to be generated from a Continue() call. + /// + public string currentText { + get { + IfAsyncWeCant ("call currentText since it's a work in progress"); + return state.currentText; + } + } + + /// + /// Gets a list of tags as defined with '#' in source that were seen + /// during the latest Continue() call. + /// + public List currentTags { + get { + IfAsyncWeCant ("call currentTags since it's a work in progress"); + return state.currentTags; + } + } + + /// + /// Any errors generated during evaluation of the Story. + /// + public List currentErrors { get { return state.currentErrors; } } + + /// + /// Any warnings generated during evaluation of the Story. + /// + public List currentWarnings { get { return state.currentWarnings; } } + + /// + /// The current flow name if using multi-flow functionality - see SwitchFlow + /// + public string currentFlowName => state.currentFlowName; + + /// + /// Is the default flow currently active? By definition, will also return true if not using multi-flow functionality - see SwitchFlow + /// + public bool currentFlowIsDefaultFlow { get { return state.currentFlowIsDefaultFlow; } } + + /// + /// Names of currently alive flows (not including the default flow) + /// + + public List aliveFlowNames { get { return state.aliveFlowNames; } } + + /// + /// Whether the currentErrors list contains any errors. + /// THIS MAY BE REMOVED - you should be setting an error handler directly + /// using Story.onError. + /// + public bool hasError { get { return state.hasError; } } + + /// + /// Whether the currentWarnings list contains any warnings. + /// + public bool hasWarning { get { return state.hasWarning; } } + + /// + /// The VariablesState object contains all the global variables in the story. + /// However, note that there's more to the state of a Story than just the + /// global variables. This is a convenience accessor to the full state object. + /// + public VariablesState variablesState{ get { return state.variablesState; } } + + public ListDefinitionsOrigin listDefinitions { + get { + return _listDefinitions; + } + } + + /// + /// The entire current state of the story including (but not limited to): + /// + /// * Global variables + /// * Temporary variables + /// * Read/visit and turn counts + /// * The callstack and evaluation stacks + /// * The current threads + /// + /// + public StoryState state { get { return _state; } } + + /// + /// Error handler for all runtime errors in ink - i.e. problems + /// with the source ink itself that are only discovered when playing + /// the story. + /// It's strongly recommended that you assign an error handler to your + /// story instance to avoid getting exceptions for ink errors. + /// + public event Ink.ErrorHandler onError; + + /// + /// Callback for when ContinueInternal is complete + /// + public event Action onDidContinue; + /// + /// Callback for when a choice is about to be executed + /// + public event Action onMakeChoice; + /// + /// Callback for when a function is about to be evaluated + /// + public event Action onEvaluateFunction; + /// + /// Callback for when a function has been evaluated + /// This is necessary because evaluating a function can cause continuing + /// + public event Action onCompleteEvaluateFunction; + /// + /// Callback for when a path string is chosen + /// + public event Action onChoosePathString; + + /// + /// Start recording ink profiling information during calls to Continue on Story. + /// Return a Profiler instance that you can request a report from when you're finished. + /// + public Profiler StartProfiling() { + IfAsyncWeCant ("start profiling"); + _profiler = new Profiler(); + return _profiler; + } + + /// + /// Stop recording ink profiling information during calls to Continue on Story. + /// To generate a report from the profiler, call + /// + public void EndProfiling() { + _profiler = null; + } + + // Warning: When creating a Story using this constructor, you need to + // call ResetState on it before use. Intended for compiler use only. + // For normal use, use the constructor that takes a json string. + public Story (Container contentContainer, List lists = null) + { + _mainContentContainer = contentContainer; + + if (lists != null) + _listDefinitions = new ListDefinitionsOrigin (lists); + + _externals = new Dictionary (); + } + + /// + /// Construct a Story object using a JSON string compiled through inklecate. + /// + public Story(string jsonString) : this((Container)null) + { + Dictionary rootObject = SimpleJson.TextToDictionary (jsonString); + + object versionObj = rootObject ["inkVersion"]; + if (versionObj == null) + throw new System.Exception ("ink version number not found. Are you sure it's a valid .ink.json file?"); + + int formatFromFile = (int)versionObj; + if (formatFromFile > inkVersionCurrent) { + throw new System.Exception ("Version of ink used to build story was newer than the current version of the engine"); + } else if (formatFromFile < inkVersionMinimumCompatible) { + throw new System.Exception ("Version of ink used to build story is too old to be loaded by this version of the engine"); + } else if (formatFromFile != inkVersionCurrent) { + System.Diagnostics.Debug.WriteLine ("WARNING: Version of ink used to build story doesn't match current version of engine. Non-critical, but recommend synchronising."); + } + + var rootToken = rootObject ["root"]; + if (rootToken == null) + throw new System.Exception ("Root node for ink not found. Are you sure it's a valid .ink.json file?"); + + object listDefsObj; + if (rootObject.TryGetValue ("listDefs", out listDefsObj)) { + _listDefinitions = Json.JTokenToListDefinitions (listDefsObj); + } + + _mainContentContainer = Json.JTokenToRuntimeObject (rootToken) as Container; + + ResetState (); + } + + /// + /// The Story itself in JSON representation. + /// + public string ToJson() + { + //return ToJsonOld(); + var writer = new SimpleJson.Writer(); + ToJson(writer); + return writer.ToString(); + } + + /// + /// The Story itself in JSON representation. + /// + public void ToJson(Stream stream) + { + var writer = new SimpleJson.Writer(stream); + ToJson(writer); + } + + void ToJson(SimpleJson.Writer writer) + { + writer.WriteObjectStart(); + + writer.WriteProperty("inkVersion", inkVersionCurrent); + + // Main container content + writer.WriteProperty("root", w => Json.WriteRuntimeContainer(w, _mainContentContainer)); + + // List definitions + if (_listDefinitions != null) { + + writer.WritePropertyStart("listDefs"); + writer.WriteObjectStart(); + + foreach (ListDefinition def in _listDefinitions.lists) + { + writer.WritePropertyStart(def.name); + writer.WriteObjectStart(); + + foreach (var itemToVal in def.items) + { + InkListItem item = itemToVal.Key; + int val = itemToVal.Value; + writer.WriteProperty(item.itemName, val); + } + + writer.WriteObjectEnd(); + writer.WritePropertyEnd(); + } + + writer.WriteObjectEnd(); + writer.WritePropertyEnd(); + } + + writer.WriteObjectEnd(); + } + + /// + /// Reset the Story back to its initial state as it was when it was + /// first constructed. + /// + public void ResetState() + { + // TODO: Could make this possible + IfAsyncWeCant ("ResetState"); + + _state = new StoryState (this); + _state.variablesState.variableChangedEvent += VariableStateDidChangeEvent; + + ResetGlobals (); + } + + void ResetErrors() + { + _state.ResetErrors (); + } + + /// + /// Unwinds the callstack. Useful to reset the Story's evaluation + /// without actually changing any meaningful state, for example if + /// you want to exit a section of story prematurely and tell it to + /// go elsewhere with a call to ChoosePathString(...). + /// Doing so without calling ResetCallstack() could cause unexpected + /// issues if, for example, the Story was in a tunnel already. + /// + public void ResetCallstack() + { + IfAsyncWeCant ("ResetCallstack"); + + _state.ForceEnd (); + } + + void ResetGlobals() + { + if (_mainContentContainer.namedContent.ContainsKey ("global decl")) { + var originalPointer = state.currentPointer; + + ChoosePath (new Path ("global decl"), incrementingTurnIndex: false); + + // Continue, but without validating external bindings, + // since we may be doing this reset at initialisation time. + ContinueInternal (); + + state.currentPointer = originalPointer; + } + + state.variablesState.SnapshotDefaultGlobals (); + } + + public void SwitchFlow(string flowName) + { + IfAsyncWeCant("switch flow"); + if (_asyncSaving) throw new System.Exception("Story is already in background saving mode, can't switch flow to "+flowName); + + state.SwitchFlow_Internal(flowName); + } + + public void RemoveFlow(string flowName) + { + state.RemoveFlow_Internal(flowName); + } + + public void SwitchToDefaultFlow() + { + state.SwitchToDefaultFlow_Internal(); + } + + + /// + /// Continue the story for one line of content, if possible. + /// If you're not sure if there's more content available, for example if you + /// want to check whether you're at a choice point or at the end of the story, + /// you should call canContinue before calling this function. + /// + /// The line of text content. + public string Continue() + { + ContinueAsync(0); + return currentText; + } + + + /// + /// Check whether more content is available if you were to call Continue() - i.e. + /// are we mid story rather than at a choice point or at the end. + /// + /// true if it's possible to call Continue(). + public bool canContinue { + get { + return state.canContinue; + } + } + + /// + /// If ContinueAsync was called (with milliseconds limit > 0) then this property + /// will return false if the ink evaluation isn't yet finished, and you need to call + /// it again in order for the Continue to fully complete. + /// + public bool asyncContinueComplete { + get { + return !_asyncContinueActive; + } + } + + /// + /// An "asnychronous" version of Continue that only partially evaluates the ink, + /// with a budget of a certain time limit. It will exit ink evaluation early if + /// the evaluation isn't complete within the time limit, with the + /// asyncContinueComplete property being false. + /// This is useful if ink evaluation takes a long time, and you want to distribute + /// it over multiple game frames for smoother animation. + /// If you pass a limit of zero, then it will fully evaluate the ink in the same + /// way as calling Continue (and in fact, this exactly what Continue does internally). + /// + public void ContinueAsync (float millisecsLimitAsync) + { + if( !_hasValidatedExternals ) + ValidateExternalBindings (); + + ContinueInternal (millisecsLimitAsync); + } + + void ContinueInternal (float millisecsLimitAsync = 0) + { + if( _profiler != null ) + _profiler.PreContinue(); + + var isAsyncTimeLimited = millisecsLimitAsync > 0; + + _recursiveContinueCount++; + + // Doing either: + // - full run through non-async (so not active and don't want to be) + // - Starting async run-through + if (!_asyncContinueActive) { + _asyncContinueActive = isAsyncTimeLimited; + + if (!canContinue) { + throw new Exception ("Can't continue - should check canContinue before calling Continue"); + } + + _state.didSafeExit = false; + _state.ResetOutput (); + + // It's possible for ink to call game to call ink to call game etc + // In this case, we only want to batch observe variable changes + // for the outermost call. + if (_recursiveContinueCount == 1) + _state.variablesState.batchObservingVariableChanges = true; + } + + // Start timing + var durationStopwatch = new Stopwatch (); + durationStopwatch.Start (); + + bool outputStreamEndsInNewline = false; + _sawLookaheadUnsafeFunctionAfterNewline = false; + do { + + try { + outputStreamEndsInNewline = ContinueSingleStep (); + } catch(StoryException e) { + AddError (e.Message, useEndLineNumber:e.useEndLineNumber); + break; + } + + if (outputStreamEndsInNewline) + break; + + // Run out of async time? + if (_asyncContinueActive && durationStopwatch.ElapsedMilliseconds > millisecsLimitAsync) { + break; + } + + } while(canContinue); + + durationStopwatch.Stop (); + + // 4 outcomes: + // - got newline (so finished this line of text) + // - can't continue (e.g. choices or ending) + // - ran out of time during evaluation + // - error + // + // Successfully finished evaluation in time (or in error) + if (outputStreamEndsInNewline || !canContinue) { + + // Need to rewind, due to evaluating further than we should? + if( _stateSnapshotAtLastNewline != null ) { + RestoreStateSnapshot (); + } + + // Finished a section of content / reached a choice point? + if( !canContinue ) { + if (state.callStack.canPopThread) + AddError ("Thread available to pop, threads should always be flat by the end of evaluation?"); + + if (state.generatedChoices.Count == 0 && !state.didSafeExit && _temporaryEvaluationContainer == null) { + if (state.callStack.CanPop (PushPopType.Tunnel)) + AddError ("unexpectedly reached end of content. Do you need a '->->' to return from a tunnel?"); + else if (state.callStack.CanPop (PushPopType.Function)) + AddError ("unexpectedly reached end of content. Do you need a '~ return'?"); + else if (!state.callStack.canPop) + AddError ("ran out of content. Do you need a '-> DONE' or '-> END'?"); + else + AddError ("unexpectedly reached end of content for unknown reason. Please debug compiler!"); + } + } + + state.didSafeExit = false; + _sawLookaheadUnsafeFunctionAfterNewline = false; + + if (_recursiveContinueCount == 1) + _state.variablesState.batchObservingVariableChanges = false; + + _asyncContinueActive = false; + if(onDidContinue != null) onDidContinue(); + } + + _recursiveContinueCount--; + + if( _profiler != null ) + _profiler.PostContinue(); + + // Report any errors that occured during evaluation. + // This may either have been StoryExceptions that were thrown + // and caught during evaluation, or directly added with AddError. + if( state.hasError || state.hasWarning ) { + if( onError != null ) { + if( state.hasError ) { + foreach(var err in state.currentErrors) { + onError(err, ErrorType.Error); + } + } + if( state.hasWarning ) { + foreach(var err in state.currentWarnings) { + onError(err, ErrorType.Warning); + } + } + ResetErrors(); + } + + // Throw an exception since there's no error handler + else { + var sb = new StringBuilder(); + sb.Append("Ink had "); + if( state.hasError ) { + sb.Append(state.currentErrors.Count); + sb.Append(state.currentErrors.Count == 1 ? " error" : " errors"); + if( state.hasWarning ) sb.Append(" and "); + } + if( state.hasWarning ) { + sb.Append(state.currentWarnings.Count); + sb.Append(state.currentWarnings.Count == 1 ? " warning" : " warnings"); + } + sb.Append(". It is strongly suggested that you assign an error handler to story.onError. The first issue was: "); + sb.Append(state.hasError ? state.currentErrors[0] : state.currentWarnings[0]); + + // If you get this exception, please assign an error handler to your story. + // If you're using Unity, you can do something like this when you create + // your story: + // + // var story = new Ink.Runtime.Story(jsonTxt); + // story.onError = (errorMessage, errorType) => { + // if( errorType == ErrorType.Warning ) + // Debug.LogWarning(errorMessage); + // else + // Debug.LogError(errorMessage); + // }; + // + // + throw new StoryException(sb.ToString()); + } + } + } + + bool ContinueSingleStep () + { + if (_profiler != null) + _profiler.PreStep (); + + // Run main step function (walks through content) + Step (); + + if (_profiler != null) + _profiler.PostStep (); + + // Run out of content and we have a default invisible choice that we can follow? + if (!canContinue && !state.callStack.elementIsEvaluateFromGame) { + TryFollowDefaultInvisibleChoice (); + } + + if (_profiler != null) + _profiler.PreSnapshot (); + + // Don't save/rewind during string evaluation, which is e.g. used for choices + if (!state.inStringEvaluation) { + + // We previously found a newline, but were we just double checking that + // it wouldn't immediately be removed by glue? + if (_stateSnapshotAtLastNewline != null) { + + // Has proper text or a tag been added? Then we know that the newline + // that was previously added is definitely the end of the line. + var change = CalculateNewlineOutputStateChange ( + _stateSnapshotAtLastNewline.currentText, state.currentText, + _stateSnapshotAtLastNewline.currentTags.Count, state.currentTags.Count + ); + + // The last time we saw a newline, it was definitely the end of the line, so we + // want to rewind to that point. + if (change == OutputStateChange.ExtendedBeyondNewline || _sawLookaheadUnsafeFunctionAfterNewline) { + RestoreStateSnapshot (); + + // Hit a newline for sure, we're done + return true; + } + + // Newline that previously existed is no longer valid - e.g. + // glue was encounted that caused it to be removed. + else if (change == OutputStateChange.NewlineRemoved) { + DiscardSnapshot(); + } + } + + // Current content ends in a newline - approaching end of our evaluation + if (state.outputStreamEndsInNewline) { + + // If we can continue evaluation for a bit: + // Create a snapshot in case we need to rewind. + // We're going to continue stepping in case we see glue or some + // non-text content such as choices. + if (canContinue) { + + // Don't bother to record the state beyond the current newline. + // e.g.: + // Hello world\n // record state at the end of here + // ~ complexCalculation() // don't actually need this unless it generates text + if (_stateSnapshotAtLastNewline == null) + StateSnapshot (); + } + + // Can't continue, so we're about to exit - make sure we + // don't have an old state hanging around. + else { + DiscardSnapshot(); + } + + } + + } + + if (_profiler != null) + _profiler.PostSnapshot (); + + // outputStreamEndsInNewline = false + return false; + } + + + + + // Assumption: prevText is the snapshot where we saw a newline, and we're checking whether we're really done + // with that line. Therefore prevText will definitely end in a newline. + // + // We take tags into account too, so that a tag following a content line: + // Content + // # tag + // ... doesn't cause the tag to be wrongly associated with the content above. + enum OutputStateChange + { + NoChange, + ExtendedBeyondNewline, + NewlineRemoved + } + OutputStateChange CalculateNewlineOutputStateChange (string prevText, string currText, int prevTagCount, int currTagCount) + { + // Simple case: nothing's changed, and we still have a newline + // at the end of the current content + var newlineStillExists = currText.Length >= prevText.Length && currText [prevText.Length - 1] == '\n'; + if (prevTagCount == currTagCount && prevText.Length == currText.Length + && newlineStillExists) + return OutputStateChange.NoChange; + + // Old newline has been removed, it wasn't the end of the line after all + if (!newlineStillExists) { + return OutputStateChange.NewlineRemoved; + } + + // Tag added - definitely the start of a new line + if (currTagCount > prevTagCount) + return OutputStateChange.ExtendedBeyondNewline; + + // There must be new content - check whether it's just whitespace + for (int i = prevText.Length; i < currText.Length; i++) { + var c = currText [i]; + if (c != ' ' && c != '\t') { + return OutputStateChange.ExtendedBeyondNewline; + } + } + + // There's new text but it's just spaces and tabs, so there's still the potential + // for glue to kill the newline. + return OutputStateChange.NoChange; + } + + + /// + /// Continue the story until the next choice point or until it runs out of content. + /// This is as opposed to the Continue() method which only evaluates one line of + /// output at a time. + /// + /// The resulting text evaluated by the ink engine, concatenated together. + public string ContinueMaximally() + { + IfAsyncWeCant ("ContinueMaximally"); + + var sb = new StringBuilder (); + + while (canContinue) { + sb.Append (Continue ()); + } + + return sb.ToString (); + } + + public SearchResult ContentAtPath(Path path) + { + return mainContentContainer.ContentAtPath (path); + } + + public Runtime.Container KnotContainerWithName (string name) + { + INamedContent namedContainer; + if (mainContentContainer.namedContent.TryGetValue (name, out namedContainer)) + return namedContainer as Container; + else + return null; + } + + public Pointer PointerAtPath (Path path) + { + if (path.length == 0) + return Pointer.Null; + + var p = new Pointer (); + + int pathLengthToUse = path.length; + + SearchResult result; + if( path.lastComponent.isIndex ) { + pathLengthToUse = path.length - 1; + result = mainContentContainer.ContentAtPath (path, partialPathLength:pathLengthToUse); + p.container = result.container; + p.index = path.lastComponent.index; + } else { + result = mainContentContainer.ContentAtPath (path); + p.container = result.container; + p.index = -1; + } + + if (result.obj == null || result.obj == mainContentContainer && pathLengthToUse > 0) + Error ("Failed to find content at path '" + path + "', and no approximation of it was possible."); + else if (result.approximate) + Warning ("Failed to find content at path '" + path + "', so it was approximated to: '"+result.obj.path+"'."); + + return p; + } + + // Maximum snapshot stack: + // - stateSnapshotDuringSave -- not retained, but returned to game code + // - _stateSnapshotAtLastNewline (has older patch) + // - _state (current, being patched) + + void StateSnapshot() + { + _stateSnapshotAtLastNewline = _state; + _state = _state.CopyAndStartPatching(); + } + + void RestoreStateSnapshot() + { + // Patched state had temporarily hijacked our + // VariablesState and set its own callstack on it, + // so we need to restore that. + // If we're in the middle of saving, we may also + // need to give the VariablesState the old patch. + _stateSnapshotAtLastNewline.RestoreAfterPatch(); + + _state = _stateSnapshotAtLastNewline; + _stateSnapshotAtLastNewline = null; + + // If save completed while the above snapshot was + // active, we need to apply any changes made since + // the save was started but before the snapshot was made. + if( !_asyncSaving ) { + _state.ApplyAnyPatch(); + } + } + + void DiscardSnapshot() + { + // Normally we want to integrate the patch + // into the main global/counts dictionaries. + // However, if we're in the middle of async + // saving, we simply stay in a "patching" state, + // albeit with the newer cloned patch. + if( !_asyncSaving ) + _state.ApplyAnyPatch(); + + // No longer need the snapshot. + _stateSnapshotAtLastNewline = null; + } + + /// + /// Advanced usage! + /// If you have a large story, and saving state to JSON takes too long for your + /// framerate, you can temporarily freeze a copy of the state for saving on + /// a separate thread. Internally, the engine maintains a "diff patch". + /// When you've finished saving your state, call BackgroundSaveComplete() + /// and that diff patch will be applied, allowing the story to continue + /// in its usual mode. + /// + /// The state for background thread save. + public StoryState CopyStateForBackgroundThreadSave() + { + IfAsyncWeCant("start saving on a background thread"); + if (_asyncSaving) throw new System.Exception("Story is already in background saving mode, can't call CopyStateForBackgroundThreadSave again!"); + var stateToSave = _state; + _state = _state.CopyAndStartPatching(); + _asyncSaving = true; + return stateToSave; + } + + /// + /// See CopyStateForBackgroundThreadSave. This method releases the + /// "frozen" save state, applying its patch that it was using internally. + /// + public void BackgroundSaveComplete() + { + // CopyStateForBackgroundThreadSave must be called outside + // of any async ink evaluation, since otherwise you'd be saving + // during an intermediate state. + // However, it's possible to *complete* the save in the middle of + // a glue-lookahead when there's a state stored in _stateSnapshotAtLastNewline. + // This state will have its own patch that is newer than the save patch. + // We hold off on the final apply until the glue-lookahead is finished. + // In that case, the apply is always done, it's just that it may + // apply the looked-ahead changes OR it may simply apply the changes + // made during the save process to the old _stateSnapshotAtLastNewline state. + if ( _stateSnapshotAtLastNewline == null ) { + _state.ApplyAnyPatch(); + } + + _asyncSaving = false; + } + + + + void Step () + { + bool shouldAddToStream = true; + + // Get current content + var pointer = state.currentPointer; + if (pointer.isNull) { + return; + } + + // Step directly to the first element of content in a container (if necessary) + Container containerToEnter = pointer.Resolve () as Container; + while(containerToEnter) { + + // Mark container as being entered + VisitContainer (containerToEnter, atStart:true); + + // No content? the most we can do is step past it + if (containerToEnter.content.Count == 0) + break; + + + pointer = Pointer.StartOf (containerToEnter); + containerToEnter = pointer.Resolve() as Container; + } + state.currentPointer = pointer; + + if( _profiler != null ) { + _profiler.Step(state.callStack); + } + + // Is the current content object: + // - Normal content + // - Or a logic/flow statement - if so, do it + // Stop flow if we hit a stack pop when we're unable to pop (e.g. return/done statement in knot + // that was diverted to rather than called as a function) + var currentContentObj = pointer.Resolve (); + bool isLogicOrFlowControl = PerformLogicAndFlowControl (currentContentObj); + + // Has flow been forced to end by flow control above? + if (state.currentPointer.isNull) { + return; + } + + if (isLogicOrFlowControl) { + shouldAddToStream = false; + } + + // Choice with condition? + var choicePoint = currentContentObj as ChoicePoint; + if (choicePoint) { + var choice = ProcessChoice (choicePoint); + if (choice) { + state.generatedChoices.Add (choice); + } + + currentContentObj = null; + shouldAddToStream = false; + } + + // If the container has no content, then it will be + // the "content" itself, but we skip over it. + if (currentContentObj is Container) { + shouldAddToStream = false; + } + + // Content to add to evaluation stack or the output stream + if (shouldAddToStream) { + + // If we're pushing a variable pointer onto the evaluation stack, ensure that it's specific + // to our current (possibly temporary) context index. And make a copy of the pointer + // so that we're not editing the original runtime object. + var varPointer = currentContentObj as VariablePointerValue; + if (varPointer && varPointer.contextIndex == -1) { + + // Create new object so we're not overwriting the story's own data + var contextIdx = state.callStack.ContextForVariableNamed(varPointer.variableName); + currentContentObj = new VariablePointerValue (varPointer.variableName, contextIdx); + } + + // Expression evaluation content + if (state.inExpressionEvaluation) { + state.PushEvaluationStack (currentContentObj); + } + // Output stream content (i.e. not expression evaluation) + else { + state.PushToOutputStream (currentContentObj); + } + } + + // Increment the content pointer, following diverts if necessary + NextContent (); + + // Starting a thread should be done after the increment to the content pointer, + // so that when returning from the thread, it returns to the content after this instruction. + var controlCmd = currentContentObj as ControlCommand; + if (controlCmd && controlCmd.commandType == ControlCommand.CommandType.StartThread) { + state.callStack.PushThread (); + } + } + + // Mark a container as having been visited + void VisitContainer(Container container, bool atStart) + { + if ( !container.countingAtStartOnly || atStart ) { + if( container.visitsShouldBeCounted ) + state.IncrementVisitCountForContainer (container); + + if (container.turnIndexShouldBeCounted) + state.RecordTurnIndexVisitToContainer (container); + } + } + + List _prevContainers = new List(); + void VisitChangedContainersDueToDivert() + { + var previousPointer = state.previousPointer; + var pointer = state.currentPointer; + + // Unless we're pointing *directly* at a piece of content, we don't do + // counting here. Otherwise, the main stepping function will do the counting. + if (pointer.isNull || pointer.index == -1) + return; + + // First, find the previously open set of containers + _prevContainers.Clear(); + if (!previousPointer.isNull) { + Container prevAncestor = previousPointer.Resolve() as Container ?? previousPointer.container as Container; + while (prevAncestor) { + _prevContainers.Add (prevAncestor); + prevAncestor = prevAncestor.parent as Container; + } + } + + // If the new object is a container itself, it will be visited automatically at the next actual + // content step. However, we need to walk up the new ancestry to see if there are more new containers + Runtime.Object currentChildOfContainer = pointer.Resolve(); + + // Invalid pointer? May happen if attemptingto + if (currentChildOfContainer == null) return; + + Container currentContainerAncestor = currentChildOfContainer.parent as Container; + + bool allChildrenEnteredAtStart = true; + while (currentContainerAncestor && (!_prevContainers.Contains(currentContainerAncestor) || currentContainerAncestor.countingAtStartOnly)) { + + // Check whether this ancestor container is being entered at the start, + // by checking whether the child object is the first. + bool enteringAtStart = currentContainerAncestor.content.Count > 0 + && currentChildOfContainer == currentContainerAncestor.content [0] + && allChildrenEnteredAtStart; + + // Don't count it as entering at start if we're entering random somewhere within + // a container B that happens to be nested at index 0 of container A. It only counts + // if we're diverting directly to the first leaf node. + if (!enteringAtStart) + allChildrenEnteredAtStart = false; + + // Mark a visit to this container + VisitContainer (currentContainerAncestor, enteringAtStart); + + currentChildOfContainer = currentContainerAncestor; + currentContainerAncestor = currentContainerAncestor.parent as Container; + } + } + + Choice ProcessChoice(ChoicePoint choicePoint) + { + bool showChoice = true; + + // Don't create choice if choice point doesn't pass conditional + if (choicePoint.hasCondition) { + var conditionValue = state.PopEvaluationStack (); + if (!IsTruthy (conditionValue)) { + showChoice = false; + } + } + + string startText = ""; + string choiceOnlyText = ""; + + if (choicePoint.hasChoiceOnlyContent) { + var choiceOnlyStrVal = state.PopEvaluationStack () as StringValue; + choiceOnlyText = choiceOnlyStrVal.value; + } + + if (choicePoint.hasStartContent) { + var startStrVal = state.PopEvaluationStack () as StringValue; + startText = startStrVal.value; + } + + // Don't create choice if player has already read this content + if (choicePoint.onceOnly) { + var visitCount = state.VisitCountForContainer (choicePoint.choiceTarget); + if (visitCount > 0) { + showChoice = false; + } + } + + // We go through the full process of creating the choice above so + // that we consume the content for it, since otherwise it'll + // be shown on the output stream. + if (!showChoice) { + return null; + } + + var choice = new Choice (); + choice.targetPath = choicePoint.pathOnChoice; + choice.sourcePath = choicePoint.path.ToString (); + choice.isInvisibleDefault = choicePoint.isInvisibleDefault; + + // We need to capture the state of the callstack at the point where + // the choice was generated, since after the generation of this choice + // we may go on to pop out from a tunnel (possible if the choice was + // wrapped in a conditional), or we may pop out from a thread, + // at which point that thread is discarded. + // Fork clones the thread, gives it a new ID, but without affecting + // the thread stack itself. + choice.threadAtGeneration = state.callStack.ForkThread(); + + // Set final text for the choice + choice.text = (startText + choiceOnlyText).Trim(' ', '\t'); + + return choice; + } + + // Does the expression result represented by this object evaluate to true? + // e.g. is it a Number that's not equal to 1? + bool IsTruthy(Runtime.Object obj) + { + bool truthy = false; + if (obj is Value) { + var val = (Value)obj; + + if (val is DivertTargetValue) { + var divTarget = (DivertTargetValue)val; + Error ("Shouldn't use a divert target (to " + divTarget.targetPath + ") as a conditional value. Did you intend a function call 'likeThis()' or a read count check 'likeThis'? (no arrows)"); + return false; + } + + return val.isTruthy; + } + return truthy; + } + + /// + /// Checks whether contentObj is a control or flow object rather than a piece of content, + /// and performs the required command if necessary. + /// + /// true if object was logic or flow control, false if it's normal content. + /// Content object. + bool PerformLogicAndFlowControl(Runtime.Object contentObj) + { + if( contentObj == null ) { + return false; + } + + // Divert + if (contentObj is Divert) { + + Divert currentDivert = (Divert)contentObj; + + if (currentDivert.isConditional) { + var conditionValue = state.PopEvaluationStack (); + + // False conditional? Cancel divert + if (!IsTruthy (conditionValue)) + return true; + } + + if (currentDivert.hasVariableTarget) { + var varName = currentDivert.variableDivertName; + + var varContents = state.variablesState.GetVariableWithName (varName); + + if (varContents == null) { + Error ("Tried to divert using a target from a variable that could not be found (" + varName + ")"); + } + else if (!(varContents is DivertTargetValue)) { + + var intContent = varContents as IntValue; + + string errorMessage = "Tried to divert to a target from a variable, but the variable (" + varName + ") didn't contain a divert target, it "; + if (intContent && intContent.value == 0) { + errorMessage += "was empty/null (the value 0)."; + } else { + errorMessage += "contained '" + varContents + "'."; + } + + Error (errorMessage); + } + + var target = (DivertTargetValue)varContents; + state.divertedPointer = PointerAtPath(target.targetPath); + + } else if (currentDivert.isExternal) { + CallExternalFunction (currentDivert.targetPathString, currentDivert.externalArgs); + return true; + } else { + state.divertedPointer = currentDivert.targetPointer; + } + + if (currentDivert.pushesToStack) { + state.callStack.Push ( + currentDivert.stackPushType, + outputStreamLengthWithPushed:state.outputStream.Count + ); + } + + if (state.divertedPointer.isNull && !currentDivert.isExternal) { + + // Human readable name available - runtime divert is part of a hard-written divert that to missing content + if (currentDivert && currentDivert.debugMetadata.sourceName != null) { + Error ("Divert target doesn't exist: " + currentDivert.debugMetadata.sourceName); + } else { + Error ("Divert resolution failed: " + currentDivert); + } + } + + return true; + } + + // Start/end an expression evaluation? Or print out the result? + else if( contentObj is ControlCommand ) { + var evalCommand = (ControlCommand) contentObj; + + switch (evalCommand.commandType) { + + case ControlCommand.CommandType.EvalStart: + Assert (state.inExpressionEvaluation == false, "Already in expression evaluation?"); + state.inExpressionEvaluation = true; + break; + + case ControlCommand.CommandType.EvalEnd: + Assert (state.inExpressionEvaluation == true, "Not in expression evaluation mode"); + state.inExpressionEvaluation = false; + break; + + case ControlCommand.CommandType.EvalOutput: + + // If the expression turned out to be empty, there may not be anything on the stack + if (state.evaluationStack.Count > 0) { + + var output = state.PopEvaluationStack (); + + // Functions may evaluate to Void, in which case we skip output + if (!(output is Void)) { + // TODO: Should we really always blanket convert to string? + // It would be okay to have numbers in the output stream the + // only problem is when exporting text for viewing, it skips over numbers etc. + var text = new StringValue (output.ToString ()); + + state.PushToOutputStream (text); + } + + } + break; + + case ControlCommand.CommandType.NoOp: + break; + + case ControlCommand.CommandType.Duplicate: + state.PushEvaluationStack (state.PeekEvaluationStack ()); + break; + + case ControlCommand.CommandType.PopEvaluatedValue: + state.PopEvaluationStack (); + break; + + case ControlCommand.CommandType.PopFunction: + case ControlCommand.CommandType.PopTunnel: + + var popType = evalCommand.commandType == ControlCommand.CommandType.PopFunction ? + PushPopType.Function : PushPopType.Tunnel; + + // Tunnel onwards is allowed to specify an optional override + // divert to go to immediately after returning: ->-> target + DivertTargetValue overrideTunnelReturnTarget = null; + if (popType == PushPopType.Tunnel) { + var popped = state.PopEvaluationStack (); + overrideTunnelReturnTarget = popped as DivertTargetValue; + if (overrideTunnelReturnTarget == null) { + Assert (popped is Void, "Expected void if ->-> doesn't override target"); + } + } + + if (state.TryExitFunctionEvaluationFromGame ()) { + break; + } + else if (state.callStack.currentElement.type != popType || !state.callStack.canPop) { + + var names = new Dictionary (); + names [PushPopType.Function] = "function return statement (~ return)"; + names [PushPopType.Tunnel] = "tunnel onwards statement (->->)"; + + string expected = names [state.callStack.currentElement.type]; + if (!state.callStack.canPop) { + expected = "end of flow (-> END or choice)"; + } + + var errorMsg = string.Format ("Found {0}, when expected {1}", names [popType], expected); + + Error (errorMsg); + } + + else { + state.PopCallstack (); + + // Does tunnel onwards override by diverting to a new ->-> target? + if( overrideTunnelReturnTarget ) + state.divertedPointer = PointerAtPath (overrideTunnelReturnTarget.targetPath); + } + + break; + + case ControlCommand.CommandType.BeginString: + state.PushToOutputStream (evalCommand); + + Assert (state.inExpressionEvaluation == true, "Expected to be in an expression when evaluating a string"); + state.inExpressionEvaluation = false; + break; + + case ControlCommand.CommandType.EndString: + + // Since we're iterating backward through the content, + // build a stack so that when we build the string, + // it's in the right order + var contentStackForString = new Stack (); + + int outputCountConsumed = 0; + for (int i = state.outputStream.Count - 1; i >= 0; --i) { + var obj = state.outputStream [i]; + + outputCountConsumed++; + + var command = obj as ControlCommand; + if (command != null && command.commandType == ControlCommand.CommandType.BeginString) { + break; + } + + if( obj is StringValue ) + contentStackForString.Push (obj); + } + + // Consume the content that was produced for this string + state.PopFromOutputStream (outputCountConsumed); + + // Build string out of the content we collected + var sb = new StringBuilder (); + foreach (var c in contentStackForString) { + sb.Append (c.ToString ()); + } + + // Return to expression evaluation (from content mode) + state.inExpressionEvaluation = true; + state.PushEvaluationStack (new StringValue (sb.ToString ())); + break; + + case ControlCommand.CommandType.ChoiceCount: + var choiceCount = state.generatedChoices.Count; + state.PushEvaluationStack (new Runtime.IntValue (choiceCount)); + break; + + case ControlCommand.CommandType.Turns: + state.PushEvaluationStack (new IntValue (state.currentTurnIndex+1)); + break; + + case ControlCommand.CommandType.TurnsSince: + case ControlCommand.CommandType.ReadCount: + var target = state.PopEvaluationStack(); + if( !(target is DivertTargetValue) ) { + string extraNote = ""; + if( target is IntValue ) + extraNote = ". Did you accidentally pass a read count ('knot_name') instead of a target ('-> knot_name')?"; + Error("TURNS_SINCE expected a divert target (knot, stitch, label name), but saw "+target+extraNote); + break; + } + + var divertTarget = target as DivertTargetValue; + var container = ContentAtPath (divertTarget.targetPath).correctObj as Container; + + int eitherCount; + if (container != null) { + if (evalCommand.commandType == ControlCommand.CommandType.TurnsSince) + eitherCount = state.TurnsSinceForContainer (container); + else + eitherCount = state.VisitCountForContainer (container); + } else { + if (evalCommand.commandType == ControlCommand.CommandType.TurnsSince) + eitherCount = -1; // turn count, default to never/unknown + else + eitherCount = 0; // visit count, assume 0 to default to allowing entry + + Warning ("Failed to find container for " + evalCommand.ToString () + " lookup at " + divertTarget.targetPath.ToString ()); + } + + state.PushEvaluationStack (new IntValue (eitherCount)); + break; + + + case ControlCommand.CommandType.Random: { + var maxInt = state.PopEvaluationStack () as IntValue; + var minInt = state.PopEvaluationStack () as IntValue; + + if (minInt == null) + Error ("Invalid value for minimum parameter of RANDOM(min, max)"); + + if (maxInt == null) + Error ("Invalid value for maximum parameter of RANDOM(min, max)"); + + // +1 because it's inclusive of min and max, for e.g. RANDOM(1,6) for a dice roll. + int randomRange; + try { + randomRange = checked(maxInt.value - minInt.value + 1); + } catch (System.OverflowException) { + randomRange = int.MaxValue; + Error("RANDOM was called with a range that exceeds the size that ink numbers can use."); + } + if (randomRange <= 0) + Error ("RANDOM was called with minimum as " + minInt.value + " and maximum as " + maxInt.value + ". The maximum must be larger"); + + var resultSeed = state.storySeed + state.previousRandom; + var random = new Random (resultSeed); + + var nextRandom = random.Next (); + var chosenValue = (nextRandom % randomRange) + minInt.value; + state.PushEvaluationStack (new IntValue (chosenValue)); + + // Next random number (rather than keeping the Random object around) + state.previousRandom = nextRandom; + break; + } + + case ControlCommand.CommandType.SeedRandom: + var seed = state.PopEvaluationStack () as IntValue; + if (seed == null) + Error ("Invalid value passed to SEED_RANDOM"); + + // Story seed affects both RANDOM and shuffle behaviour + state.storySeed = seed.value; + state.previousRandom = 0; + + // SEED_RANDOM returns nothing. + state.PushEvaluationStack (new Runtime.Void ()); + break; + + case ControlCommand.CommandType.VisitIndex: + var count = state.VisitCountForContainer(state.currentPointer.container) - 1; // index not count + state.PushEvaluationStack (new IntValue (count)); + break; + + case ControlCommand.CommandType.SequenceShuffleIndex: + var shuffleIndex = NextSequenceShuffleIndex (); + state.PushEvaluationStack (new IntValue (shuffleIndex)); + break; + + case ControlCommand.CommandType.StartThread: + // Handled in main step function + break; + + case ControlCommand.CommandType.Done: + + // We may exist in the context of the initial + // act of creating the thread, or in the context of + // evaluating the content. + if (state.callStack.canPopThread) { + state.callStack.PopThread (); + } + + // In normal flow - allow safe exit without warning + else { + state.didSafeExit = true; + + // Stop flow in current thread + state.currentPointer = Pointer.Null; + } + + break; + + // Force flow to end completely + case ControlCommand.CommandType.End: + state.ForceEnd (); + break; + + case ControlCommand.CommandType.ListFromInt: + var intVal = state.PopEvaluationStack () as IntValue; + var listNameVal = state.PopEvaluationStack () as StringValue; + + if (intVal == null) { + throw new StoryException ("Passed non-integer when creating a list element from a numerical value."); + } + + ListValue generatedListValue = null; + + ListDefinition foundListDef; + if (listDefinitions.TryListGetDefinition (listNameVal.value, out foundListDef)) { + InkListItem foundItem; + if (foundListDef.TryGetItemWithValue (intVal.value, out foundItem)) { + generatedListValue = new ListValue (foundItem, intVal.value); + } + } else { + throw new StoryException ("Failed to find LIST called " + listNameVal.value); + } + + if (generatedListValue == null) + generatedListValue = new ListValue (); + + state.PushEvaluationStack (generatedListValue); + break; + + case ControlCommand.CommandType.ListRange: { + var max = state.PopEvaluationStack () as Value; + var min = state.PopEvaluationStack () as Value; + + var targetList = state.PopEvaluationStack () as ListValue; + + if (targetList == null || min == null || max == null) + throw new StoryException ("Expected list, minimum and maximum for LIST_RANGE"); + + var result = targetList.value.ListWithSubRange(min.valueObject, max.valueObject); + + state.PushEvaluationStack (new ListValue(result)); + break; + } + + case ControlCommand.CommandType.ListRandom: { + + var listVal = state.PopEvaluationStack () as ListValue; + if (listVal == null) + throw new StoryException ("Expected list for LIST_RANDOM"); + + var list = listVal.value; + + InkList newList = null; + + // List was empty: return empty list + if (list.Count == 0) { + newList = new InkList (); + } + + // Non-empty source list + else { + // Generate a random index for the element to take + var resultSeed = state.storySeed + state.previousRandom; + var random = new Random (resultSeed); + + var nextRandom = random.Next (); + var listItemIndex = nextRandom % list.Count; + + // Iterate through to get the random element + var listEnumerator = list.GetEnumerator (); + for (int i = 0; i <= listItemIndex; i++) { + listEnumerator.MoveNext (); + } + var randomItem = listEnumerator.Current; + + // Origin list is simply the origin of the one element + newList = new InkList (randomItem.Key.originName, this); + newList.Add (randomItem.Key, randomItem.Value); + + state.previousRandom = nextRandom; + } + + state.PushEvaluationStack (new ListValue(newList)); + break; + } + + default: + Error ("unhandled ControlCommand: " + evalCommand); + break; + } + + return true; + } + + // Variable assignment + else if( contentObj is VariableAssignment ) { + var varAss = (VariableAssignment) contentObj; + var assignedVal = state.PopEvaluationStack(); + + // When in temporary evaluation, don't create new variables purely within + // the temporary context, but attempt to create them globally + //var prioritiseHigherInCallStack = _temporaryEvaluationContainer != null; + + state.variablesState.Assign (varAss, assignedVal); + + return true; + } + + // Variable reference + else if( contentObj is VariableReference ) { + var varRef = (VariableReference)contentObj; + Runtime.Object foundValue = null; + + + // Explicit read count value + if (varRef.pathForCount != null) { + + var container = varRef.containerForCount; + int count = state.VisitCountForContainer (container); + foundValue = new IntValue (count); + } + + // Normal variable reference + else { + + foundValue = state.variablesState.GetVariableWithName (varRef.name); + + if (foundValue == null) { + Warning ("Variable not found: '" + varRef.name + "'. Using default value of 0 (false). This can happen with temporary variables if the declaration hasn't yet been hit. Globals are always given a default value on load if a value doesn't exist in the save state."); + foundValue = new IntValue (0); + } + } + + state.PushEvaluationStack (foundValue); + + return true; + } + + // Native function call + else if (contentObj is NativeFunctionCall) { + var func = (NativeFunctionCall)contentObj; + var funcParams = state.PopEvaluationStack (func.numberOfParameters); + var result = func.Call (funcParams); + state.PushEvaluationStack (result); + return true; + } + + // No control content, must be ordinary content + return false; + } + + /// + /// Change the current position of the story to the given path. From here you can + /// call Continue() to evaluate the next line. + /// + /// The path string is a dot-separated path as used internally by the engine. + /// These examples should work: + /// + /// myKnot + /// myKnot.myStitch + /// + /// Note however that this won't necessarily work: + /// + /// myKnot.myStitch.myLabelledChoice + /// + /// ...because of the way that content is nested within a weave structure. + /// + /// By default this will reset the callstack beforehand, which means that any + /// tunnels, threads or functions you were in at the time of calling will be + /// discarded. This is different from the behaviour of ChooseChoiceIndex, which + /// will always keep the callstack, since the choices are known to come from the + /// correct state, and known their source thread. + /// + /// You have the option of passing false to the resetCallstack parameter if you + /// don't want this behaviour, and will leave any active threads, tunnels or + /// function calls in-tact. + /// + /// This is potentially dangerous! If you're in the middle of a tunnel, + /// it'll redirect only the inner-most tunnel, meaning that when you tunnel-return + /// using '->->', it'll return to where you were before. This may be what you + /// want though. However, if you're in the middle of a function, ChoosePathString + /// will throw an exception. + /// + /// + /// A dot-separted path string, as specified above. + /// Whether to reset the callstack first (see summary description). + /// Optional set of arguments to pass, if path is to a knot that takes them. + public void ChoosePathString (string path, bool resetCallstack = true, params object [] arguments) + { + IfAsyncWeCant ("call ChoosePathString right now"); + if(onChoosePathString != null) onChoosePathString(path, arguments); + if (resetCallstack) { + ResetCallstack (); + } else { + // ChoosePathString is potentially dangerous since you can call it when the stack is + // pretty much in any state. Let's catch one of the worst offenders. + if (state.callStack.currentElement.type == PushPopType.Function) { + string funcDetail = ""; + var container = state.callStack.currentElement.currentPointer.container; + if (container != null) { + funcDetail = "("+container.path.ToString ()+") "; + } + throw new System.Exception ("Story was running a function "+funcDetail+"when you called ChoosePathString("+path+") - this is almost certainly not not what you want! Full stack trace: \n"+state.callStack.callStackTrace); + } + } + + state.PassArgumentsToEvaluationStack (arguments); + ChoosePath (new Path (path)); + } + + void IfAsyncWeCant (string activityStr) + { + if (_asyncContinueActive) + throw new System.Exception ("Can't " + activityStr + ". Story is in the middle of a ContinueAsync(). Make more ContinueAsync() calls or a single Continue() call beforehand."); + } + + public void ChoosePath(Path p, bool incrementingTurnIndex = true) + { + state.SetChosenPath (p, incrementingTurnIndex); + + // Take a note of newly visited containers for read counts etc + VisitChangedContainersDueToDivert (); + } + + /// + /// Chooses the Choice from the currentChoices list with the given + /// index. Internally, this sets the current content path to that + /// pointed to by the Choice, ready to continue story evaluation. + /// + public void ChooseChoiceIndex(int choiceIdx) + { + var choices = currentChoices; + Assert (choiceIdx >= 0 && choiceIdx < choices.Count, "choice out of range"); + + // Replace callstack with the one from the thread at the choosing point, + // so that we can jump into the right place in the flow. + // This is important in case the flow was forked by a new thread, which + // can create multiple leading edges for the story, each of + // which has its own context. + var choiceToChoose = choices [choiceIdx]; + if(onMakeChoice != null) onMakeChoice(choiceToChoose); + state.callStack.currentThread = choiceToChoose.threadAtGeneration; + + ChoosePath (choiceToChoose.targetPath); + } + + /// + /// Checks if a function exists. + /// + /// True if the function exists, else false. + /// The name of the function as declared in ink. + public bool HasFunction (string functionName) + { + try { + return KnotContainerWithName (functionName) != null; + } catch { + return false; + } + } + + /// + /// Evaluates a function defined in ink. + /// + /// The return value as returned from the ink function with `~ return myValue`, or null if nothing is returned. + /// The name of the function as declared in ink. + /// The arguments that the ink function takes, if any. Note that we don't (can't) do any validation on the number of arguments right now, so make sure you get it right! + public object EvaluateFunction (string functionName, params object [] arguments) + { + string _; + return EvaluateFunction (functionName, out _, arguments); + } + + /// + /// Evaluates a function defined in ink, and gathers the possibly multi-line text as generated by the function. + /// This text output is any text written as normal content within the function, as opposed to the return value, as returned with `~ return`. + /// + /// The return value as returned from the ink function with `~ return myValue`, or null if nothing is returned. + /// The name of the function as declared in ink. + /// The text content produced by the function via normal ink, if any. + /// The arguments that the ink function takes, if any. Note that we don't (can't) do any validation on the number of arguments right now, so make sure you get it right! + public object EvaluateFunction (string functionName, out string textOutput, params object [] arguments) + { + if(onEvaluateFunction != null) onEvaluateFunction(functionName, arguments); + IfAsyncWeCant ("evaluate a function"); + + if(functionName == null) { + throw new System.Exception ("Function is null"); + } else if(functionName == string.Empty || functionName.Trim() == string.Empty) { + throw new System.Exception ("Function is empty or white space."); + } + + // Get the content that we need to run + var funcContainer = KnotContainerWithName (functionName); + if( funcContainer == null ) + throw new System.Exception ("Function doesn't exist: '" + functionName + "'"); + + // Snapshot the output stream + var outputStreamBefore = new List(state.outputStream); + _state.ResetOutput (); + + // State will temporarily replace the callstack in order to evaluate + state.StartFunctionEvaluationFromGame (funcContainer, arguments); + + // Evaluate the function, and collect the string output + var stringOutput = new StringBuilder (); + while (canContinue) { + stringOutput.Append (Continue ()); + } + textOutput = stringOutput.ToString (); + + // Restore the output stream in case this was called + // during main story evaluation. + _state.ResetOutput (outputStreamBefore); + + // Finish evaluation, and see whether anything was produced + var result = state.CompleteFunctionEvaluationFromGame (); + if(onCompleteEvaluateFunction != null) onCompleteEvaluateFunction(functionName, arguments, textOutput, result); + return result; + } + + // Evaluate a "hot compiled" piece of ink content, as used by the REPL-like + // CommandLinePlayer. + public Runtime.Object EvaluateExpression(Runtime.Container exprContainer) + { + int startCallStackHeight = state.callStack.elements.Count; + + state.callStack.Push (PushPopType.Tunnel); + + _temporaryEvaluationContainer = exprContainer; + + state.GoToStart (); + + int evalStackHeight = state.evaluationStack.Count; + + Continue (); + + _temporaryEvaluationContainer = null; + + // Should have fallen off the end of the Container, which should + // have auto-popped, but just in case we didn't for some reason, + // manually pop to restore the state (including currentPath). + if (state.callStack.elements.Count > startCallStackHeight) { + state.PopCallstack (); + } + + int endStackHeight = state.evaluationStack.Count; + if (endStackHeight > evalStackHeight) { + return state.PopEvaluationStack (); + } else { + return null; + } + + } + + /// + /// An ink file can provide a fallback functions for when when an EXTERNAL has been left + /// unbound by the client, and the fallback function will be called instead. Useful when + /// testing a story in playmode, when it's not possible to write a client-side C# external + /// function, but you don't want it to fail to run. + /// + public bool allowExternalFunctionFallbacks { get; set; } + + public void CallExternalFunction(string funcName, int numberOfArguments) + { + ExternalFunctionDef funcDef; + Container fallbackFunctionContainer = null; + + var foundExternal = _externals.TryGetValue (funcName, out funcDef); + + // Should this function break glue? Abort run if we've already seen a newline. + // Set a bool to tell it to restore the snapshot at the end of this instruction. + if( foundExternal && !funcDef.lookaheadSafe && _stateSnapshotAtLastNewline != null ) { + _sawLookaheadUnsafeFunctionAfterNewline = true; + return; + } + + // Try to use fallback function? + if (!foundExternal) { + if (allowExternalFunctionFallbacks) { + fallbackFunctionContainer = KnotContainerWithName (funcName); + Assert (fallbackFunctionContainer != null, "Trying to call EXTERNAL function '" + funcName + "' which has not been bound, and fallback ink function could not be found."); + + // Divert direct into fallback function and we're done + state.callStack.Push ( + PushPopType.Function, + outputStreamLengthWithPushed:state.outputStream.Count + ); + state.divertedPointer = Pointer.StartOf(fallbackFunctionContainer); + return; + + } else { + Assert (false, "Trying to call EXTERNAL function '" + funcName + "' which has not been bound (and ink fallbacks disabled)."); + } + } + + // Pop arguments + var arguments = new List(); + for (int i = 0; i < numberOfArguments; ++i) { + var poppedObj = state.PopEvaluationStack () as Value; + var valueObj = poppedObj.valueObject; + arguments.Add (valueObj); + } + + // Reverse arguments from the order they were popped, + // so they're the right way round again. + arguments.Reverse (); + + // Run the function! + object funcResult = funcDef.function (arguments.ToArray()); + + // Convert return value (if any) to the a type that the ink engine can use + Runtime.Object returnObj = null; + if (funcResult != null) { + returnObj = Value.Create (funcResult); + Assert (returnObj != null, "Could not create ink value from returned object of type " + funcResult.GetType()); + } else { + returnObj = new Runtime.Void (); + } + + state.PushEvaluationStack (returnObj); + } + + /// + /// General purpose delegate definition for bound EXTERNAL function definitions + /// from ink. Note that this version isn't necessary if you have a function + /// with three arguments or less - see the overloads of BindExternalFunction. + /// + public delegate object ExternalFunction(object[] args); + + /// + /// Most general form of function binding that returns an object + /// and takes an array of object parameters. + /// The only way to bind a function with more than 3 arguments. + /// + /// EXTERNAL ink function name to bind to. + /// The C# function to bind. + /// The ink engine often evaluates further + /// than you might expect beyond the current line just in case it sees + /// glue that will cause the two lines to become one. In this case it's + /// possible that a function can appear to be called twice instead of + /// just once, and earlier than you expect. If it's safe for your + /// function to be called in this way (since the result and side effect + /// of the function will not change), then you can pass 'true'. + /// Usually, you want to pass 'false', especially if you want some action + /// to be performed in game code when this function is called. + public void BindExternalFunctionGeneral(string funcName, ExternalFunction func, bool lookaheadSafe = true) + { + IfAsyncWeCant ("bind an external function"); + Assert (!_externals.ContainsKey (funcName), "Function '" + funcName + "' has already been bound."); + _externals [funcName] = new ExternalFunctionDef { + function = func, + lookaheadSafe = lookaheadSafe + }; + } + + object TryCoerce(object value) + { + if (value == null) + return null; + + if (value is T) + return (T) value; + + if (value is float && typeof(T) == typeof(int)) { + int intVal = (int)Math.Round ((float)value); + return intVal; + } + + if (value is int && typeof(T) == typeof(float)) { + float floatVal = (float)(int)value; + return floatVal; + } + + if (value is int && typeof(T) == typeof(bool)) { + int intVal = (int)value; + return intVal == 0 ? false : true; + } + + if (value is bool && typeof(T) == typeof(int)) { + bool boolVal = (bool)value; + return boolVal ? 1 : 0; + } + + if (typeof(T) == typeof(string)) { + return value.ToString (); + } + + Assert (false, "Failed to cast " + value.GetType ().Name + " to " + typeof(T).Name); + + return null; + } + + // Convenience overloads for standard functions and actions of various arities + // Is there a better way of doing this?! + + /// + /// Bind a C# function to an ink EXTERNAL function declaration. + /// + /// EXTERNAL ink function name to bind to. + /// The C# function to bind. + /// The ink engine often evaluates further + /// than you might expect beyond the current line just in case it sees + /// glue that will cause the two lines to become one. In this case it's + /// possible that a function can appear to be called twice instead of + /// just once, and earlier than you expect. If it's safe for your + /// function to be called in this way (since the result and side effect + /// of the function will not change), then you can pass 'true'. + /// Usually, you want to pass 'false', especially if you want some action + /// to be performed in game code when this function is called. + public void BindExternalFunction(string funcName, Func func, bool lookaheadSafe=false) + { + Assert(func != null, "Can't bind a null function"); + + BindExternalFunctionGeneral (funcName, (object[] args) => { + Assert(args.Length == 0, "External function expected no arguments"); + return func(); + }, lookaheadSafe); + } + + /// + /// Bind a C# Action to an ink EXTERNAL function declaration. + /// + /// EXTERNAL ink function name to bind to. + /// The C# action to bind. + /// The ink engine often evaluates further + /// than you might expect beyond the current line just in case it sees + /// glue that will cause the two lines to become one. In this case it's + /// possible that a function can appear to be called twice instead of + /// just once, and earlier than you expect. If it's safe for your + /// function to be called in this way (since the result and side effect + /// of the function will not change), then you can pass 'true'. + /// Usually, you want to pass 'false', especially if you want some action + /// to be performed in game code when this function is called. + public void BindExternalFunction(string funcName, Action act, bool lookaheadSafe=false) + { + Assert(act != null, "Can't bind a null function"); + + BindExternalFunctionGeneral (funcName, (object[] args) => { + Assert(args.Length == 0, "External function expected no arguments"); + act(); + return null; + }, lookaheadSafe); + } + + /// + /// Bind a C# function to an ink EXTERNAL function declaration. + /// + /// EXTERNAL ink function name to bind to. + /// The C# function to bind. + /// The ink engine often evaluates further + /// than you might expect beyond the current line just in case it sees + /// glue that will cause the two lines to become one. In this case it's + /// possible that a function can appear to be called twice instead of + /// just once, and earlier than you expect. If it's safe for your + /// function to be called in this way (since the result and side effect + /// of the function will not change), then you can pass 'true'. + /// Usually, you want to pass 'false', especially if you want some action + /// to be performed in game code when this function is called. + public void BindExternalFunction(string funcName, Func func, bool lookaheadSafe=false) + { + Assert(func != null, "Can't bind a null function"); + + BindExternalFunctionGeneral (funcName, (object[] args) => { + Assert(args.Length == 1, "External function expected one argument"); + return func( (T)TryCoerce(args[0]) ); + }, lookaheadSafe); + } + + /// + /// Bind a C# action to an ink EXTERNAL function declaration. + /// + /// EXTERNAL ink function name to bind to. + /// The C# action to bind. + /// The ink engine often evaluates further + /// than you might expect beyond the current line just in case it sees + /// glue that will cause the two lines to become one. In this case it's + /// possible that a function can appear to be called twice instead of + /// just once, and earlier than you expect. If it's safe for your + /// function to be called in this way (since the result and side effect + /// of the function will not change), then you can pass 'true'. + /// Usually, you want to pass 'false', especially if you want some action + /// to be performed in game code when this function is called. + public void BindExternalFunction(string funcName, Action act, bool lookaheadSafe=false) + { + Assert(act != null, "Can't bind a null function"); + + BindExternalFunctionGeneral (funcName, (object[] args) => { + Assert(args.Length == 1, "External function expected one argument"); + act( (T)TryCoerce(args[0]) ); + return null; + }, lookaheadSafe); + } + + + /// + /// Bind a C# function to an ink EXTERNAL function declaration. + /// + /// EXTERNAL ink function name to bind to. + /// The C# function to bind. + /// The ink engine often evaluates further + /// than you might expect beyond the current line just in case it sees + /// glue that will cause the two lines to become one. In this case it's + /// possible that a function can appear to be called twice instead of + /// just once, and earlier than you expect. If it's safe for your + /// function to be called in this way (since the result and side effect + /// of the function will not change), then you can pass 'true'. + /// Usually, you want to pass 'false', especially if you want some action + /// to be performed in game code when this function is called. + public void BindExternalFunction(string funcName, Func func, bool lookaheadSafe = false) + { + Assert(func != null, "Can't bind a null function"); + + BindExternalFunctionGeneral (funcName, (object[] args) => { + Assert(args.Length == 2, "External function expected two arguments"); + return func( + (T1)TryCoerce(args[0]), + (T2)TryCoerce(args[1]) + ); + }, lookaheadSafe); + } + + /// + /// Bind a C# action to an ink EXTERNAL function declaration. + /// + /// EXTERNAL ink function name to bind to. + /// The C# action to bind. + /// The ink engine often evaluates further + /// than you might expect beyond the current line just in case it sees + /// glue that will cause the two lines to become one. In this case it's + /// possible that a function can appear to be called twice instead of + /// just once, and earlier than you expect. If it's safe for your + /// function to be called in this way (since the result and side effect + /// of the function will not change), then you can pass 'true'. + /// Usually, you want to pass 'false', especially if you want some action + /// to be performed in game code when this function is called. + public void BindExternalFunction(string funcName, Action act, bool lookaheadSafe=false) + { + Assert(act != null, "Can't bind a null function"); + + BindExternalFunctionGeneral (funcName, (object[] args) => { + Assert(args.Length == 2, "External function expected two arguments"); + act( + (T1)TryCoerce(args[0]), + (T2)TryCoerce(args[1]) + ); + return null; + }, lookaheadSafe); + } + + /// + /// Bind a C# function to an ink EXTERNAL function declaration. + /// + /// EXTERNAL ink function name to bind to. + /// The C# function to bind. + /// The ink engine often evaluates further + /// than you might expect beyond the current line just in case it sees + /// glue that will cause the two lines to become one. In this case it's + /// possible that a function can appear to be called twice instead of + /// just once, and earlier than you expect. If it's safe for your + /// function to be called in this way (since the result and side effect + /// of the function will not change), then you can pass 'true'. + /// Usually, you want to pass 'false', especially if you want some action + /// to be performed in game code when this function is called. + public void BindExternalFunction(string funcName, Func func, bool lookaheadSafe=false) + { + Assert(func != null, "Can't bind a null function"); + + BindExternalFunctionGeneral (funcName, (object[] args) => { + Assert(args.Length == 3, "External function expected three arguments"); + return func( + (T1)TryCoerce(args[0]), + (T2)TryCoerce(args[1]), + (T3)TryCoerce(args[2]) + ); + }, lookaheadSafe); + } + + /// + /// Bind a C# action to an ink EXTERNAL function declaration. + /// + /// EXTERNAL ink function name to bind to. + /// The C# action to bind. + /// The ink engine often evaluates further + /// than you might expect beyond the current line just in case it sees + /// glue that will cause the two lines to become one. In this case it's + /// possible that a function can appear to be called twice instead of + /// just once, and earlier than you expect. If it's safe for your + /// function to be called in this way (since the result and side effect + /// of the function will not change), then you can pass 'true'. + /// Usually, you want to pass 'false', especially if you want some action + /// to be performed in game code when this function is called. + public void BindExternalFunction(string funcName, Action act, bool lookaheadSafe=false) + { + Assert(act != null, "Can't bind a null function"); + + BindExternalFunctionGeneral (funcName, (object[] args) => { + Assert(args.Length == 3, "External function expected three arguments"); + act( + (T1)TryCoerce(args[0]), + (T2)TryCoerce(args[1]), + (T3)TryCoerce(args[2]) + ); + return null; + }, lookaheadSafe); + } + + /// + /// Bind a C# function to an ink EXTERNAL function declaration. + /// + /// EXTERNAL ink function name to bind to. + /// The C# function to bind. + /// The ink engine often evaluates further + /// than you might expect beyond the current line just in case it sees + /// glue that will cause the two lines to become one. In this case it's + /// possible that a function can appear to be called twice instead of + /// just once, and earlier than you expect. If it's safe for your + /// function to be called in this way (since the result and side effect + /// of the function will not change), then you can pass 'true'. + /// Usually, you want to pass 'false', especially if you want some action + /// to be performed in game code when this function is called. + public void BindExternalFunction(string funcName, Func func, bool lookaheadSafe=false) + { + Assert(func != null, "Can't bind a null function"); + + BindExternalFunctionGeneral (funcName, (object[] args) => { + Assert(args.Length == 4, "External function expected four arguments"); + return func( + (T1)TryCoerce(args[0]), + (T2)TryCoerce(args[1]), + (T3)TryCoerce(args[2]), + (T4)TryCoerce(args[3]) + ); + }, lookaheadSafe); + } + + /// + /// Bind a C# action to an ink EXTERNAL function declaration. + /// + /// EXTERNAL ink function name to bind to. + /// The C# action to bind. + /// The ink engine often evaluates further + /// than you might expect beyond the current line just in case it sees + /// glue that will cause the two lines to become one. In this case it's + /// possible that a function can appear to be called twice instead of + /// just once, and earlier than you expect. If it's safe for your + /// function to be called in this way (since the result and side effect + /// of the function will not change), then you can pass 'true'. + /// Usually, you want to pass 'false', especially if you want some action + /// to be performed in game code when this function is called. + public void BindExternalFunction(string funcName, Action act, bool lookaheadSafe=false) + { + Assert(act != null, "Can't bind a null function"); + + BindExternalFunctionGeneral (funcName, (object[] args) => { + Assert(args.Length == 4, "External function expected four arguments"); + act( + (T1)TryCoerce(args[0]), + (T2)TryCoerce(args[1]), + (T3)TryCoerce(args[2]), + (T4)TryCoerce(args[3]) + ); + return null; + }, lookaheadSafe); + } + + /// + /// Remove a binding for a named EXTERNAL ink function. + /// + public void UnbindExternalFunction(string funcName) + { + IfAsyncWeCant ("unbind an external a function"); + Assert (_externals.ContainsKey (funcName), "Function '" + funcName + "' has not been bound."); + _externals.Remove (funcName); + } + + /// + /// Check that all EXTERNAL ink functions have a valid bound C# function. + /// Note that this is automatically called on the first call to Continue(). + /// + public void ValidateExternalBindings() + { + var missingExternals = new HashSet(); + + ValidateExternalBindings (_mainContentContainer, missingExternals); + _hasValidatedExternals = true; + + // No problem! Validation complete + if( missingExternals.Count == 0 ) { + _hasValidatedExternals = true; + } + + // Error for all missing externals + else { + var message = string.Format("ERROR: Missing function binding for external{0}: '{1}' {2}", + missingExternals.Count > 1 ? "s" : string.Empty, + string.Join("', '", missingExternals.ToArray()), + allowExternalFunctionFallbacks ? ", and no fallback ink function found." : " (ink fallbacks disabled)" + ); + + Error(message); + } + } + + void ValidateExternalBindings(Container c, HashSet missingExternals) + { + foreach (var innerContent in c.content) { + var container = innerContent as Container; + if( container == null || !container.hasValidName ) + ValidateExternalBindings (innerContent, missingExternals); + } + foreach (var innerKeyValue in c.namedContent) { + ValidateExternalBindings (innerKeyValue.Value as Runtime.Object, missingExternals); + } + } + + void ValidateExternalBindings(Runtime.Object o, HashSet missingExternals) + { + var container = o as Container; + if (container) { + ValidateExternalBindings (container, missingExternals); + return; + } + + var divert = o as Divert; + if (divert && divert.isExternal) { + var name = divert.targetPathString; + + if (!_externals.ContainsKey (name)) { + if( allowExternalFunctionFallbacks ) { + bool fallbackFound = mainContentContainer.namedContent.ContainsKey(name); + if( !fallbackFound ) { + missingExternals.Add(name); + } + } else { + missingExternals.Add(name); + } + } + } + } + + /// + /// Delegate definition for variable observation - see ObserveVariable. + /// + public delegate void VariableObserver(string variableName, object newValue); + + /// + /// When the named global variable changes it's value, the observer will be + /// called to notify it of the change. Note that if the value changes multiple + /// times within the ink, the observer will only be called once, at the end + /// of the ink's evaluation. If, during the evaluation, it changes and then + /// changes back again to its original value, it will still be called. + /// Note that the observer will also be fired if the value of the variable + /// is changed externally to the ink, by directly setting a value in + /// story.variablesState. + /// + /// The name of the global variable to observe. + /// A delegate function to call when the variable changes. + public void ObserveVariable(string variableName, VariableObserver observer) + { + IfAsyncWeCant ("observe a new variable"); + + if (_variableObservers == null) + _variableObservers = new Dictionary (); + + if( !state.variablesState.GlobalVariableExistsWithName(variableName) ) + throw new Exception("Cannot observe variable '"+variableName+"' because it wasn't declared in the ink story."); + + if (_variableObservers.ContainsKey (variableName)) { + _variableObservers[variableName] += observer; + } else { + _variableObservers[variableName] = observer; + } + } + + /// + /// Convenience function to allow multiple variables to be observed with the same + /// observer delegate function. See the singular ObserveVariable for details. + /// The observer will get one call for every variable that has changed. + /// + /// The set of variables to observe. + /// The delegate function to call when any of the named variables change. + public void ObserveVariables(IList variableNames, VariableObserver observer) + { + foreach (var varName in variableNames) { + ObserveVariable (varName, observer); + } + } + + /// + /// Removes the variable observer, to stop getting variable change notifications. + /// If you pass a specific variable name, it will stop observing that particular one. If you + /// pass null (or leave it blank, since it's optional), then the observer will be removed + /// from all variables that it's subscribed to. If you pass in a specific variable name and + /// null for the the observer, all observers for that variable will be removed. + /// + /// (Optional) The observer to stop observing. + /// (Optional) Specific variable name to stop observing. + public void RemoveVariableObserver(VariableObserver observer = null, string specificVariableName = null) + { + IfAsyncWeCant ("remove a variable observer"); + + if (_variableObservers == null) + return; + + // Remove observer for this specific variable + if (specificVariableName != null) { + if (_variableObservers.ContainsKey (specificVariableName)) { + if( observer != null) { + _variableObservers [specificVariableName] -= observer; + if (_variableObservers[specificVariableName] == null) { + _variableObservers.Remove(specificVariableName); + } + } + else { + _variableObservers.Remove(specificVariableName); + } + } + } + + // Remove observer for all variables + else if( observer != null) { + var keys = new List(_variableObservers.Keys); + foreach (var varName in keys) { + _variableObservers[varName] -= observer; + if (_variableObservers[varName] == null) { + _variableObservers.Remove(varName); + } + } + } + } + + void VariableStateDidChangeEvent(string variableName, Runtime.Object newValueObj) + { + if (_variableObservers == null) + return; + + VariableObserver observers = null; + if (_variableObservers.TryGetValue (variableName, out observers)) { + + if (!(newValueObj is Value)) { + throw new System.Exception ("Tried to get the value of a variable that isn't a standard type"); + } + var val = newValueObj as Value; + + observers (variableName, val.valueObject); + } + } + + /// + /// Get any global tags associated with the story. These are defined as + /// hash tags defined at the very top of the story. + /// + public List globalTags { + get { + return TagsAtStartOfFlowContainerWithPathString (""); + } + } + + /// + /// Gets any tags associated with a particular knot or knot.stitch. + /// These are defined as hash tags defined at the very top of a + /// knot or stitch. + /// + /// The path of the knot or stitch, in the form "knot" or "knot.stitch". + public List TagsForContentAtPath (string path) + { + return TagsAtStartOfFlowContainerWithPathString (path); + } + + List TagsAtStartOfFlowContainerWithPathString (string pathString) + { + var path = new Runtime.Path (pathString); + + // Expected to be global story, knot or stitch + var flowContainer = ContentAtPath (path).container; + while(true) { + var firstContent = flowContainer.content [0]; + if (firstContent is Container) + flowContainer = (Container)firstContent; + else break; + } + + // Any initial tag objects count as the "main tags" associated with that story/knot/stitch + List tags = null; + foreach (var c in flowContainer.content) { + var tag = c as Runtime.Tag; + if (tag) { + if (tags == null) tags = new List (); + tags.Add (tag.text); + } else break; + } + + return tags; + } + + /// + /// Useful when debugging a (very short) story, to visualise the state of the + /// story. Add this call as a watch and open the extended text. A left-arrow mark + /// will denote the current point of the story. + /// It's only recommended that this is used on very short debug stories, since + /// it can end up generate a large quantity of text otherwise. + /// + public virtual string BuildStringOfHierarchy() + { + var sb = new StringBuilder (); + + mainContentContainer.BuildStringOfHierarchy (sb, 0, state.currentPointer.Resolve()); + + return sb.ToString (); + } + + string BuildStringOfContainer (Container container) + { + var sb = new StringBuilder (); + + container.BuildStringOfHierarchy (sb, 0, state.currentPointer.Resolve()); + + return sb.ToString(); + } + + private void NextContent() + { + // Setting previousContentObject is critical for VisitChangedContainersDueToDivert + state.previousPointer = state.currentPointer; + + // Divert step? + if (!state.divertedPointer.isNull) { + + state.currentPointer = state.divertedPointer; + state.divertedPointer = Pointer.Null; + + // Internally uses state.previousContentObject and state.currentContentObject + VisitChangedContainersDueToDivert (); + + // Diverted location has valid content? + if (!state.currentPointer.isNull) { + return; + } + + // Otherwise, if diverted location doesn't have valid content, + // drop down and attempt to increment. + // This can happen if the diverted path is intentionally jumping + // to the end of a container - e.g. a Conditional that's re-joining + } + + bool successfulPointerIncrement = IncrementContentPointer (); + + // Ran out of content? Try to auto-exit from a function, + // or finish evaluating the content of a thread + if (!successfulPointerIncrement) { + + bool didPop = false; + + if (state.callStack.CanPop (PushPopType.Function)) { + + // Pop from the call stack + state.PopCallstack (PushPopType.Function); + + // This pop was due to dropping off the end of a function that didn't return anything, + // so in this case, we make sure that the evaluator has something to chomp on if it needs it + if (state.inExpressionEvaluation) { + state.PushEvaluationStack (new Runtime.Void ()); + } + + didPop = true; + } else if (state.callStack.canPopThread) { + state.callStack.PopThread (); + + didPop = true; + } else { + state.TryExitFunctionEvaluationFromGame (); + } + + // Step past the point where we last called out + if (didPop && !state.currentPointer.isNull) { + NextContent (); + } + } + } + + bool IncrementContentPointer() + { + bool successfulIncrement = true; + + var pointer = state.callStack.currentElement.currentPointer; + pointer.index++; + + // Each time we step off the end, we fall out to the next container, all the + // while we're in indexed rather than named content + while (pointer.index >= pointer.container.content.Count) { + + successfulIncrement = false; + + Container nextAncestor = pointer.container.parent as Container; + if (!nextAncestor) { + break; + } + + var indexInAncestor = nextAncestor.content.IndexOf (pointer.container); + if (indexInAncestor == -1) { + break; + } + + pointer = new Pointer (nextAncestor, indexInAncestor); + + // Increment to next content in outer container + pointer.index++; + + successfulIncrement = true; + } + + if (!successfulIncrement) pointer = Pointer.Null; + + state.callStack.currentElement.currentPointer = pointer; + + return successfulIncrement; + } + + bool TryFollowDefaultInvisibleChoice() + { + var allChoices = _state.currentChoices; + + // Is a default invisible choice the ONLY choice? + var invisibleChoices = allChoices.Where (c => c.isInvisibleDefault).ToList(); + if (invisibleChoices.Count == 0 || allChoices.Count > invisibleChoices.Count) + return false; + + var choice = invisibleChoices [0]; + + // Invisible choice may have been generated on a different thread, + // in which case we need to restore it before we continue + state.callStack.currentThread = choice.threadAtGeneration; + + // If there's a chance that this state will be rolled back to before + // the invisible choice then make sure that the choice thread is + // left intact, and it isn't re-entered in an old state. + if ( _stateSnapshotAtLastNewline != null ) + state.callStack.currentThread = state.callStack.ForkThread(); + + ChoosePath (choice.targetPath, incrementingTurnIndex: false); + + return true; + } + + + // Note that this is O(n), since it re-evaluates the shuffle indices + // from a consistent seed each time. + // TODO: Is this the best algorithm it can be? + int NextSequenceShuffleIndex() + { + var numElementsIntVal = state.PopEvaluationStack () as IntValue; + if (numElementsIntVal == null) { + Error ("expected number of elements in sequence for shuffle index"); + return 0; + } + + var seqContainer = state.currentPointer.container; + + int numElements = numElementsIntVal.value; + + var seqCountVal = state.PopEvaluationStack () as IntValue; + var seqCount = seqCountVal.value; + var loopIndex = seqCount / numElements; + var iterationIndex = seqCount % numElements; + + // Generate the same shuffle based on: + // - The hash of this container, to make sure it's consistent + // each time the runtime returns to the sequence + // - How many times the runtime has looped around this full shuffle + var seqPathStr = seqContainer.path.ToString(); + int sequenceHash = 0; + foreach (char c in seqPathStr) { + sequenceHash += c; + } + var randomSeed = sequenceHash + loopIndex + state.storySeed; + var random = new Random (randomSeed); + + var unpickedIndices = new List (); + for (int i = 0; i < numElements; ++i) { + unpickedIndices.Add (i); + } + + for (int i = 0; i <= iterationIndex; ++i) { + var chosen = random.Next () % unpickedIndices.Count; + var chosenIndex = unpickedIndices [chosen]; + unpickedIndices.RemoveAt (chosen); + + if (i == iterationIndex) { + return chosenIndex; + } + } + + throw new System.Exception ("Should never reach here"); + } + + // Throw an exception that gets caught and causes AddError to be called, + // then exits the flow. + public void Error(string message, bool useEndLineNumber = false) + { + var e = new StoryException (message); + e.useEndLineNumber = useEndLineNumber; + throw e; + } + + public void Warning (string message) + { + AddError (message, isWarning:true); + } + + void AddError (string message, bool isWarning = false, bool useEndLineNumber = false) + { + var dm = currentDebugMetadata; + + var errorTypeStr = isWarning ? "WARNING" : "ERROR"; + + if (dm != null) { + int lineNum = useEndLineNumber ? dm.endLineNumber : dm.startLineNumber; + message = string.Format ("RUNTIME {0}: '{1}' line {2}: {3}", errorTypeStr, dm.fileName, lineNum, message); + } else if( !state.currentPointer.isNull ) { + message = string.Format ("RUNTIME {0}: ({1}): {2}", errorTypeStr, state.currentPointer.path, message); + } else { + message = "RUNTIME "+errorTypeStr+": " + message; + } + + state.AddError (message, isWarning); + + // In a broken state don't need to know about any other errors. + if( !isWarning ) + state.ForceEnd (); + } + + void Assert(bool condition, string message = null, params object[] formatParams) + { + if (condition == false) { + if (message == null) { + message = "Story assert"; + } + if (formatParams != null && formatParams.Count() > 0) { + message = string.Format (message, formatParams); + } + + throw new System.Exception (message + " " + currentDebugMetadata); + } + } + + DebugMetadata currentDebugMetadata + { + get { + DebugMetadata dm; + + // Try to get from the current path first + var pointer = state.currentPointer; + if (!pointer.isNull) { + dm = pointer.Resolve().debugMetadata; + if (dm != null) { + return dm; + } + } + + // Move up callstack if possible + for (int i = state.callStack.elements.Count - 1; i >= 0; --i) { + pointer = state.callStack.elements [i].currentPointer; + if (!pointer.isNull && pointer.Resolve() != null) { + dm = pointer.Resolve().debugMetadata; + if (dm != null) { + return dm; + } + } + } + + // Current/previous path may not be valid if we've just had an error, + // or if we've simply run out of content. + // As a last resort, try to grab something from the output stream + for (int i = state.outputStream.Count - 1; i >= 0; --i) { + var outputObj = state.outputStream [i]; + dm = outputObj.debugMetadata; + if (dm != null) { + return dm; + } + } + + return null; + } + } + + int currentLineNumber + { + get { + var dm = currentDebugMetadata; + if (dm != null) { + return dm.startLineNumber; + } + return 0; + } + } + + public Container mainContentContainer { + get { + if (_temporaryEvaluationContainer) { + return _temporaryEvaluationContainer; + } else { + return _mainContentContainer; + } + } + } + + Container _mainContentContainer; + ListDefinitionsOrigin _listDefinitions; + + struct ExternalFunctionDef { + public ExternalFunction function; + public bool lookaheadSafe; + } + Dictionary _externals; + Dictionary _variableObservers; + bool _hasValidatedExternals; + + Container _temporaryEvaluationContainer; + + StoryState _state; + + bool _asyncContinueActive; + StoryState _stateSnapshotAtLastNewline = null; + bool _sawLookaheadUnsafeFunctionAfterNewline = false; + + int _recursiveContinueCount = 0; + + bool _asyncSaving; + + Profiler _profiler; + } +} + diff --git a/Assets/Ink/ink-engine-runtime/Story.cs.meta b/Assets/Ink/ink-engine-runtime/Story.cs.meta new file mode 100644 index 000000000..d340b0fc0 --- /dev/null +++ b/Assets/Ink/ink-engine-runtime/Story.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: c760358be233814429b379327f313356 +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/Assets/Ink/ink-engine-runtime/StoryException.cs b/Assets/Ink/ink-engine-runtime/StoryException.cs new file mode 100644 index 000000000..5b0a20fb5 --- /dev/null +++ b/Assets/Ink/ink-engine-runtime/StoryException.cs @@ -0,0 +1,24 @@ +namespace Ink.Runtime +{ + /// + /// Exception that represents an error when running a Story at runtime. + /// An exception being thrown of this type is typically when there's + /// a bug in your ink, rather than in the ink engine itself! + /// + public class StoryException : System.Exception + { + public bool useEndLineNumber; + + /// + /// Constructs a default instance of a StoryException without a message. + /// + public StoryException () { } + + /// + /// Constructs an instance of a StoryException with a message. + /// + /// The error message. + public StoryException(string message) : base(message) {} + } +} + diff --git a/Assets/Ink/ink-engine-runtime/StoryException.cs.meta b/Assets/Ink/ink-engine-runtime/StoryException.cs.meta new file mode 100644 index 000000000..5a19601ce --- /dev/null +++ b/Assets/Ink/ink-engine-runtime/StoryException.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: 5a9a53e9ccf45e746ba505f037b637e5 +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/Assets/Ink/ink-engine-runtime/StoryState.cs b/Assets/Ink/ink-engine-runtime/StoryState.cs new file mode 100644 index 000000000..ebcd353f5 --- /dev/null +++ b/Assets/Ink/ink-engine-runtime/StoryState.cs @@ -0,0 +1,1286 @@ +using System; +using System.Collections.Generic; +using System.Text; +using System.Diagnostics; +using System.IO; + +namespace Ink.Runtime +{ + /// + /// All story state information is included in the StoryState class, + /// including global variables, read counts, the pointer to the current + /// point in the story, the call stack (for tunnels, functions, etc), + /// and a few other smaller bits and pieces. You can save the current + /// state using the json serialisation functions ToJson and LoadJson. + /// + public class StoryState + { + /// + /// The current version of the state save file JSON-based format. + /// + public const int kInkSaveStateVersion = 9; // new: multi-flows, but backward compatible + const int kMinCompatibleLoadVersion = 8; + + /// + /// Callback for when a state is loaded + /// + public event Action onDidLoadState; + + /// + /// Exports the current state to json format, in order to save the game. + /// + /// The save state in json format. + public string ToJson() { + var writer = new SimpleJson.Writer(); + WriteJson(writer); + return writer.ToString(); + } + + /// + /// Exports the current state to json format, in order to save the game. + /// For this overload you can pass in a custom stream, such as a FileStream. + /// + public void ToJson(Stream stream) { + var writer = new SimpleJson.Writer(stream); + WriteJson(writer); + } + + /// + /// Loads a previously saved state in JSON format. + /// + /// The JSON string to load. + public void LoadJson(string json) + { + var jObject = SimpleJson.TextToDictionary (json); + LoadJsonObj(jObject); + if(onDidLoadState != null) onDidLoadState(); + } + + /// + /// Gets the visit/read count of a particular Container at the given path. + /// For a knot or stitch, that path string will be in the form: + /// + /// knot + /// knot.stitch + /// + /// + /// The number of times the specific knot or stitch has + /// been enountered by the ink engine. + /// The dot-separated path string of + /// the specific knot or stitch. + public int VisitCountAtPathString(string pathString) + { + int visitCountOut; + + if ( _patch != null ) { + var container = story.ContentAtPath(new Path(pathString)).container; + if (container == null) + throw new Exception("Content at path not found: " + pathString); + + if( _patch.TryGetVisitCount(container, out visitCountOut) ) + return visitCountOut; + } + + if (_visitCounts.TryGetValue(pathString, out visitCountOut)) + return visitCountOut; + + return 0; + } + + public int VisitCountForContainer(Container container) + { + if (!container.visitsShouldBeCounted) + { + story.Error("Read count for target (" + container.name + " - on " + container.debugMetadata + ") unknown."); + return 0; + } + + int count = 0; + if (_patch != null && _patch.TryGetVisitCount(container, out count)) + return count; + + var containerPathStr = container.path.ToString(); + _visitCounts.TryGetValue(containerPathStr, out count); + return count; + } + + public void IncrementVisitCountForContainer(Container container) + { + if( _patch != null ) { + var currCount = VisitCountForContainer(container); + currCount++; + _patch.SetVisitCount(container, currCount); + return; + } + + int count = 0; + var containerPathStr = container.path.ToString(); + _visitCounts.TryGetValue(containerPathStr, out count); + count++; + _visitCounts[containerPathStr] = count; + } + + public void RecordTurnIndexVisitToContainer(Container container) + { + if( _patch != null ) { + _patch.SetTurnIndex(container, currentTurnIndex); + return; + } + + var containerPathStr = container.path.ToString(); + _turnIndices[containerPathStr] = currentTurnIndex; + } + + public int TurnsSinceForContainer(Container container) + { + if (!container.turnIndexShouldBeCounted) + { + story.Error("TURNS_SINCE() for target (" + container.name + " - on " + container.debugMetadata + ") unknown."); + } + + int index = 0; + + if ( _patch != null && _patch.TryGetTurnIndex(container, out index) ) { + return currentTurnIndex - index; + } + + var containerPathStr = container.path.ToString(); + if (_turnIndices.TryGetValue(containerPathStr, out index)) + { + return currentTurnIndex - index; + } + else + { + return -1; + } + } + + public int callstackDepth { + get { + return callStack.depth; + } + } + + // REMEMBER! REMEMBER! REMEMBER! + // When adding state, update the Copy method, and serialisation. + // REMEMBER! REMEMBER! REMEMBER! + + public List outputStream { + get { + return _currentFlow.outputStream; + } + } + + + + public List currentChoices { + get { + // If we can continue generating text content rather than choices, + // then we reflect the choice list as being empty, since choices + // should always come at the end. + if( canContinue ) return new List(); + return _currentFlow.currentChoices; + } + } + public List generatedChoices { + get { + return _currentFlow.currentChoices; + } + } + + // TODO: Consider removing currentErrors / currentWarnings altogether + // and relying on client error handler code immediately handling StoryExceptions etc + // Or is there a specific reason we need to collect potentially multiple + // errors before throwing/exiting? + public List currentErrors { get; private set; } + public List currentWarnings { get; private set; } + public VariablesState variablesState { get; private set; } + public CallStack callStack { + get { + return _currentFlow.callStack; + } + // set { + // _currentFlow.callStack = value; + // } + } + + public List evaluationStack { get; private set; } + public Pointer divertedPointer { get; set; } + + public int currentTurnIndex { get; private set; } + public int storySeed { get; set; } + public int previousRandom { get; set; } + public bool didSafeExit { get; set; } + + public Story story { get; set; } + + /// + /// String representation of the location where the story currently is. + /// + public string currentPathString { + get { + var pointer = currentPointer; + if (pointer.isNull) + return null; + else + return pointer.path.ToString(); + } + } + + public Runtime.Pointer currentPointer { + get { + return callStack.currentElement.currentPointer; + } + set { + callStack.currentElement.currentPointer = value; + } + } + + public Pointer previousPointer { + get { + return callStack.currentThread.previousPointer; + } + set { + callStack.currentThread.previousPointer = value; + } + } + + public bool canContinue { + get { + return !currentPointer.isNull && !hasError; + } + } + + public bool hasError + { + get { + return currentErrors != null && currentErrors.Count > 0; + } + } + + public bool hasWarning { + get { + return currentWarnings != null && currentWarnings.Count > 0; + } + } + + public string currentText + { + get + { + if( _outputStreamTextDirty ) { + var sb = new StringBuilder (); + + foreach (var outputObj in outputStream) { + var textContent = outputObj as StringValue; + if (textContent != null) { + sb.Append(textContent.value); + } + } + + _currentText = CleanOutputWhitespace (sb.ToString ()); + + _outputStreamTextDirty = false; + } + + return _currentText; + } + } + string _currentText; + + // Cleans inline whitespace in the following way: + // - Removes all whitespace from the start and end of line (including just before a \n) + // - Turns all consecutive space and tab runs into single spaces (HTML style) + string CleanOutputWhitespace(string str) + { + var sb = new StringBuilder(str.Length); + + int currentWhitespaceStart = -1; + int startOfLine = 0; + + for (int i = 0; i < str.Length; i++) { + var c = str[i]; + + bool isInlineWhitespace = c == ' ' || c == '\t'; + + if (isInlineWhitespace && currentWhitespaceStart == -1) + currentWhitespaceStart = i; + + if (!isInlineWhitespace) { + if (c != '\n' && currentWhitespaceStart > 0 && currentWhitespaceStart != startOfLine) { + sb.Append(' '); + } + currentWhitespaceStart = -1; + } + + if (c == '\n') + startOfLine = i + 1; + + if (!isInlineWhitespace) + sb.Append(c); + } + + return sb.ToString(); + } + + public List currentTags + { + get + { + if( _outputStreamTagsDirty ) { + _currentTags = new List(); + + foreach (var outputObj in outputStream) { + var tag = outputObj as Tag; + if (tag != null) { + _currentTags.Add (tag.text); + } + } + + _outputStreamTagsDirty = false; + } + + return _currentTags; + } + } + List _currentTags; + + public string currentFlowName { + get { + return _currentFlow.name; + } + } + + public bool currentFlowIsDefaultFlow { + get { + return _currentFlow.name == kDefaultFlowName; + } + } + + public List aliveFlowNames { + get { + + if( _aliveFlowNamesDirty ) { + _aliveFlowNames = new List(); + + if (_namedFlows != null) + { + foreach (string flowName in _namedFlows.Keys) { + if (flowName != kDefaultFlowName) { + _aliveFlowNames.Add(flowName); + } + } + } + + _aliveFlowNamesDirty = false; + } + + return _aliveFlowNames; + } + } + + List _aliveFlowNames; + + public bool inExpressionEvaluation { + get { + return callStack.currentElement.inExpressionEvaluation; + } + set { + callStack.currentElement.inExpressionEvaluation = value; + } + } + + public StoryState (Story story) + { + this.story = story; + + _currentFlow = new Flow(kDefaultFlowName, story); + + OutputStreamDirty(); + _aliveFlowNamesDirty = true; + + evaluationStack = new List (); + + variablesState = new VariablesState (callStack, story.listDefinitions); + + _visitCounts = new Dictionary (); + _turnIndices = new Dictionary (); + + currentTurnIndex = -1; + + // Seed the shuffle random numbers + int timeSeed = DateTime.Now.Millisecond; + storySeed = (new Random (timeSeed)).Next () % 100; + previousRandom = 0; + + + + GoToStart(); + } + + public void GoToStart() + { + callStack.currentElement.currentPointer = Pointer.StartOf (story.mainContentContainer); + } + + internal void SwitchFlow_Internal(string flowName) + { + if(flowName == null) throw new System.Exception("Must pass a non-null string to Story.SwitchFlow"); + + if( _namedFlows == null ) { + _namedFlows = new Dictionary(); + _namedFlows[kDefaultFlowName] = _currentFlow; + } + + if( flowName == _currentFlow.name ) { + return; + } + + Flow flow; + if( !_namedFlows.TryGetValue(flowName, out flow) ) { + flow = new Flow(flowName, story); + _namedFlows[flowName] = flow; + _aliveFlowNamesDirty = true; + } + + _currentFlow = flow; + variablesState.callStack = _currentFlow.callStack; + + // Cause text to be regenerated from output stream if necessary + OutputStreamDirty(); + } + + internal void SwitchToDefaultFlow_Internal() + { + if( _namedFlows == null ) return; + SwitchFlow_Internal(kDefaultFlowName); + } + + internal void RemoveFlow_Internal(string flowName) + { + if(flowName == null) throw new System.Exception("Must pass a non-null string to Story.DestroyFlow"); + if(flowName == kDefaultFlowName) throw new System.Exception("Cannot destroy default flow"); + + // If we're currently in the flow that's being removed, switch back to default + if( _currentFlow.name == flowName ) { + SwitchToDefaultFlow_Internal(); + } + + _namedFlows.Remove(flowName); + _aliveFlowNamesDirty = true; + } + + // Warning: Any Runtime.Object content referenced within the StoryState will + // be re-referenced rather than cloned. This is generally okay though since + // Runtime.Objects are treated as immutable after they've been set up. + // (e.g. we don't edit a Runtime.StringValue after it's been created an added.) + // I wonder if there's a sensible way to enforce that..?? + public StoryState CopyAndStartPatching() + { + var copy = new StoryState(story); + + copy._patch = new StatePatch(_patch); + + // Hijack the new default flow to become a copy of our current one + // If the patch is applied, then this new flow will replace the old one in _namedFlows + copy._currentFlow.name = _currentFlow.name; + copy._currentFlow.callStack = new CallStack (_currentFlow.callStack); + copy._currentFlow.currentChoices.AddRange(_currentFlow.currentChoices); + copy._currentFlow.outputStream.AddRange(_currentFlow.outputStream); + copy.OutputStreamDirty(); + + // The copy of the state has its own copy of the named flows dictionary, + // except with the current flow replaced with the copy above + // (Assuming we're in multi-flow mode at all. If we're not then + // the above copy is simply the default flow copy and we're done) + if( _namedFlows != null ) { + copy._namedFlows = new Dictionary(); + foreach(var namedFlow in _namedFlows) + copy._namedFlows[namedFlow.Key] = namedFlow.Value; + copy._namedFlows[_currentFlow.name] = copy._currentFlow; + copy._aliveFlowNamesDirty = true; + } + + if (hasError) { + copy.currentErrors = new List (); + copy.currentErrors.AddRange (currentErrors); + } + if (hasWarning) { + copy.currentWarnings = new List (); + copy.currentWarnings.AddRange (currentWarnings); + } + + + // ref copy - exactly the same variables state! + // we're expecting not to read it only while in patch mode + // (though the callstack will be modified) + copy.variablesState = variablesState; + copy.variablesState.callStack = copy.callStack; + copy.variablesState.patch = copy._patch; + + copy.evaluationStack.AddRange (evaluationStack); + + if (!divertedPointer.isNull) + copy.divertedPointer = divertedPointer; + + copy.previousPointer = previousPointer; + + // visit counts and turn indicies will be read only, not modified + // while in patch mode + copy._visitCounts = _visitCounts; + copy._turnIndices = _turnIndices; + + copy.currentTurnIndex = currentTurnIndex; + copy.storySeed = storySeed; + copy.previousRandom = previousRandom; + + copy.didSafeExit = didSafeExit; + + return copy; + } + + public void RestoreAfterPatch() + { + // VariablesState was being borrowed by the patched + // state, so restore it with our own callstack. + // _patch will be null normally, but if you're in the + // middle of a save, it may contain a _patch for save purpsoes. + variablesState.callStack = callStack; + variablesState.patch = _patch; // usually null + } + + public void ApplyAnyPatch() + { + if (_patch == null) return; + + variablesState.ApplyPatch(); + + foreach(var pathToCount in _patch.visitCounts) + ApplyCountChanges(pathToCount.Key, pathToCount.Value, isVisit:true); + + foreach (var pathToIndex in _patch.turnIndices) + ApplyCountChanges(pathToIndex.Key, pathToIndex.Value, isVisit:false); + + _patch = null; + } + + void ApplyCountChanges(Container container, int newCount, bool isVisit) + { + var counts = isVisit ? _visitCounts : _turnIndices; + counts[container.path.ToString()] = newCount; + } + + void WriteJson(SimpleJson.Writer writer) + { + writer.WriteObjectStart(); + + // Flows + writer.WritePropertyStart("flows"); + writer.WriteObjectStart(); + + // Multi-flow + if( _namedFlows != null ) { + foreach(var namedFlow in _namedFlows) { + writer.WriteProperty(namedFlow.Key, namedFlow.Value.WriteJson); + } + } + + // Single flow + else { + writer.WriteProperty(_currentFlow.name, _currentFlow.WriteJson); + } + + writer.WriteObjectEnd(); + writer.WritePropertyEnd(); // end of flows + + writer.WriteProperty("currentFlowName", _currentFlow.name); + + writer.WriteProperty("variablesState", variablesState.WriteJson); + + writer.WriteProperty("evalStack", w => Json.WriteListRuntimeObjs(w, evaluationStack)); + + + if (!divertedPointer.isNull) + writer.WriteProperty("currentDivertTarget", divertedPointer.path.componentsString); + + writer.WriteProperty("visitCounts", w => Json.WriteIntDictionary(w, _visitCounts)); + writer.WriteProperty("turnIndices", w => Json.WriteIntDictionary(w, _turnIndices)); + + + writer.WriteProperty("turnIdx", currentTurnIndex); + writer.WriteProperty("storySeed", storySeed); + writer.WriteProperty("previousRandom", previousRandom); + + writer.WriteProperty("inkSaveVersion", kInkSaveStateVersion); + + // Not using this right now, but could do in future. + writer.WriteProperty("inkFormatVersion", Story.inkVersionCurrent); + + writer.WriteObjectEnd(); + } + + + void LoadJsonObj(Dictionary jObject) + { + object jSaveVersion = null; + if (!jObject.TryGetValue("inkSaveVersion", out jSaveVersion)) { + throw new Exception ("ink save format incorrect, can't load."); + } + else if ((int)jSaveVersion < kMinCompatibleLoadVersion) { + throw new Exception("Ink save format isn't compatible with the current version (saw '"+jSaveVersion+"', but minimum is "+kMinCompatibleLoadVersion+"), so can't load."); + } + + // Flows: Always exists in latest format (even if there's just one default) + // but this dictionary doesn't exist in prev format + object flowsObj = null; + if (jObject.TryGetValue("flows", out flowsObj)) { + var flowsObjDict = (Dictionary)flowsObj; + + // Single default flow + if( flowsObjDict.Count == 1 ) + _namedFlows = null; + + // Multi-flow, need to create flows dict + else if( _namedFlows == null ) + _namedFlows = new Dictionary(); + + // Multi-flow, already have a flows dict + else + _namedFlows.Clear(); + + // Load up each flow (there may only be one) + foreach(var namedFlowObj in flowsObjDict) { + var name = namedFlowObj.Key; + var flowObj = (Dictionary)namedFlowObj.Value; + + // Load up this flow using JSON data + var flow = new Flow(name, story, flowObj); + + if( flowsObjDict.Count == 1 ) { + _currentFlow = new Flow(name, story, flowObj); + } else { + _namedFlows[name] = flow; + } + } + + if( _namedFlows != null && _namedFlows.Count > 1 ) { + var currFlowName = (string)jObject["currentFlowName"]; + _currentFlow = _namedFlows[currFlowName]; + } + } + + // Old format: individually load up callstack, output stream, choices in current/default flow + else { + _namedFlows = null; + _currentFlow.name = kDefaultFlowName; + _currentFlow.callStack.SetJsonToken ((Dictionary < string, object > )jObject ["callstackThreads"], story); + _currentFlow.outputStream = Json.JArrayToRuntimeObjList ((List)jObject ["outputStream"]); + _currentFlow.currentChoices = Json.JArrayToRuntimeObjList((List)jObject ["currentChoices"]); + + object jChoiceThreadsObj = null; + jObject.TryGetValue("choiceThreads", out jChoiceThreadsObj); + _currentFlow.LoadFlowChoiceThreads((Dictionary)jChoiceThreadsObj, story); + } + + OutputStreamDirty(); + _aliveFlowNamesDirty = true; + + variablesState.SetJsonToken((Dictionary < string, object> )jObject["variablesState"]); + variablesState.callStack = _currentFlow.callStack; + + evaluationStack = Json.JArrayToRuntimeObjList ((List)jObject ["evalStack"]); + + + object currentDivertTargetPath; + if (jObject.TryGetValue("currentDivertTarget", out currentDivertTargetPath)) { + var divertPath = new Path (currentDivertTargetPath.ToString ()); + divertedPointer = story.PointerAtPath (divertPath); + } + + _visitCounts = Json.JObjectToIntDictionary((Dictionary)jObject["visitCounts"]); + _turnIndices = Json.JObjectToIntDictionary((Dictionary)jObject["turnIndices"]); + + currentTurnIndex = (int)jObject ["turnIdx"]; + storySeed = (int)jObject ["storySeed"]; + + // Not optional, but bug in inkjs means it's actually missing in inkjs saves + object previousRandomObj = null; + if( jObject.TryGetValue("previousRandom", out previousRandomObj) ) { + previousRandom = (int)previousRandomObj; + } else { + previousRandom = 0; + } + } + + public void ResetErrors() + { + currentErrors = null; + currentWarnings = null; + } + + public void ResetOutput(List objs = null) + { + outputStream.Clear (); + if( objs != null ) outputStream.AddRange (objs); + OutputStreamDirty(); + } + + // Push to output stream, but split out newlines in text for consistency + // in dealing with them later. + public void PushToOutputStream(Runtime.Object obj) + { + var text = obj as StringValue; + if (text) { + var listText = TrySplittingHeadTailWhitespace (text); + if (listText != null) { + foreach (var textObj in listText) { + PushToOutputStreamIndividual (textObj); + } + OutputStreamDirty(); + return; + } + } + + PushToOutputStreamIndividual (obj); + + OutputStreamDirty(); + } + + public void PopFromOutputStream (int count) + { + outputStream.RemoveRange (outputStream.Count - count, count); + OutputStreamDirty (); + } + + + // At both the start and the end of the string, split out the new lines like so: + // + // " \n \n \n the string \n is awesome \n \n " + // ^-----------^ ^-------^ + // + // Excess newlines are converted into single newlines, and spaces discarded. + // Outside spaces are significant and retained. "Interior" newlines within + // the main string are ignored, since this is for the purpose of gluing only. + // + // - If no splitting is necessary, null is returned. + // - A newline on its own is returned in a list for consistency. + List TrySplittingHeadTailWhitespace(Runtime.StringValue single) + { + string str = single.value; + + int headFirstNewlineIdx = -1; + int headLastNewlineIdx = -1; + for (int i = 0; i < str.Length; i++) { + char c = str [i]; + if (c == '\n') { + if (headFirstNewlineIdx == -1) + headFirstNewlineIdx = i; + headLastNewlineIdx = i; + } + else if (c == ' ' || c == '\t') + continue; + else + break; + } + + int tailLastNewlineIdx = -1; + int tailFirstNewlineIdx = -1; + for (int i = str.Length-1; i >= 0; i--) { + char c = str [i]; + if (c == '\n') { + if (tailLastNewlineIdx == -1) + tailLastNewlineIdx = i; + tailFirstNewlineIdx = i; + } + else if (c == ' ' || c == '\t') + continue; + else + break; + } + + // No splitting to be done? + if (headFirstNewlineIdx == -1 && tailLastNewlineIdx == -1) + return null; + + var listTexts = new List (); + int innerStrStart = 0; + int innerStrEnd = str.Length; + + if (headFirstNewlineIdx != -1) { + if (headFirstNewlineIdx > 0) { + var leadingSpaces = new StringValue (str.Substring (0, headFirstNewlineIdx)); + listTexts.Add(leadingSpaces); + } + listTexts.Add (new StringValue ("\n")); + innerStrStart = headLastNewlineIdx + 1; + } + + if (tailLastNewlineIdx != -1) { + innerStrEnd = tailFirstNewlineIdx; + } + + if (innerStrEnd > innerStrStart) { + var innerStrText = str.Substring (innerStrStart, innerStrEnd - innerStrStart); + listTexts.Add (new StringValue (innerStrText)); + } + + if (tailLastNewlineIdx != -1 && tailFirstNewlineIdx > headLastNewlineIdx) { + listTexts.Add (new StringValue ("\n")); + if (tailLastNewlineIdx < str.Length - 1) { + int numSpaces = (str.Length - tailLastNewlineIdx) - 1; + var trailingSpaces = new StringValue (str.Substring (tailLastNewlineIdx + 1, numSpaces)); + listTexts.Add(trailingSpaces); + } + } + + return listTexts; + } + + void PushToOutputStreamIndividual(Runtime.Object obj) + { + var glue = obj as Runtime.Glue; + var text = obj as Runtime.StringValue; + + bool includeInOutput = true; + + // New glue, so chomp away any whitespace from the end of the stream + if (glue) { + TrimNewlinesFromOutputStream(); + includeInOutput = true; + } + + // New text: do we really want to append it, if it's whitespace? + // Two different reasons for whitespace to be thrown away: + // - Function start/end trimming + // - User defined glue: <> + // We also need to know when to stop trimming, when there's non-whitespace. + else if( text ) { + + // Where does the current function call begin? + var functionTrimIndex = -1; + var currEl = callStack.currentElement; + if (currEl.type == PushPopType.Function) { + functionTrimIndex = currEl.functionStartInOuputStream; + } + + // Do 2 things: + // - Find latest glue + // - Check whether we're in the middle of string evaluation + // If we're in string eval within the current function, we + // don't want to trim back further than the length of the current string. + int glueTrimIndex = -1; + for (int i = outputStream.Count - 1; i >= 0; i--) { + var o = outputStream [i]; + var c = o as ControlCommand; + var g = o as Glue; + + // Find latest glue + if (g) { + glueTrimIndex = i; + break; + } + + // Don't function-trim past the start of a string evaluation section + else if (c && c.commandType == ControlCommand.CommandType.BeginString) { + if (i >= functionTrimIndex) { + functionTrimIndex = -1; + } + break; + } + } + + // Where is the most agressive (earliest) trim point? + var trimIndex = -1; + if (glueTrimIndex != -1 && functionTrimIndex != -1) + trimIndex = Math.Min (functionTrimIndex, glueTrimIndex); + else if (glueTrimIndex != -1) + trimIndex = glueTrimIndex; + else + trimIndex = functionTrimIndex; + + // So, are we trimming then? + if (trimIndex != -1) { + + // While trimming, we want to throw all newlines away, + // whether due to glue or the start of a function + if (text.isNewline) { + includeInOutput = false; + } + + // Able to completely reset when normal text is pushed + else if (text.isNonWhitespace) { + + if( glueTrimIndex > -1 ) + RemoveExistingGlue (); + + // Tell all functions in callstack that we have seen proper text, + // so trimming whitespace at the start is done. + if (functionTrimIndex > -1) { + var callstackElements = callStack.elements; + for (int i = callstackElements.Count - 1; i >= 0; i--) { + var el = callstackElements [i]; + if (el.type == PushPopType.Function) { + el.functionStartInOuputStream = -1; + } else { + break; + } + } + } + } + } + + // De-duplicate newlines, and don't ever lead with a newline + else if (text.isNewline) { + if (outputStreamEndsInNewline || !outputStreamContainsContent) + includeInOutput = false; + } + } + + if (includeInOutput) { + outputStream.Add (obj); + OutputStreamDirty(); + } + } + + void TrimNewlinesFromOutputStream() + { + int removeWhitespaceFrom = -1; + + // Work back from the end, and try to find the point where + // we need to start removing content. + // - Simply work backwards to find the first newline in a string of whitespace + // e.g. This is the content \n \n\n + // ^---------^ whitespace to remove + // ^--- first while loop stops here + int i = outputStream.Count-1; + while (i >= 0) { + var obj = outputStream [i]; + var cmd = obj as ControlCommand; + var txt = obj as StringValue; + + if (cmd || (txt && txt.isNonWhitespace)) { + break; + } + else if (txt && txt.isNewline) { + removeWhitespaceFrom = i; + } + i--; + } + + // Remove the whitespace + if (removeWhitespaceFrom >= 0) { + i=removeWhitespaceFrom; + while(i < outputStream.Count) { + var text = outputStream [i] as StringValue; + if (text) { + outputStream.RemoveAt (i); + } else { + i++; + } + } + } + + OutputStreamDirty(); + } + + // Only called when non-whitespace is appended + void RemoveExistingGlue() + { + for (int i = outputStream.Count - 1; i >= 0; i--) { + var c = outputStream [i]; + if (c is Glue) { + outputStream.RemoveAt (i); + } else if( c is ControlCommand ) { // e.g. BeginString + break; + } + } + + OutputStreamDirty(); + } + + public bool outputStreamEndsInNewline { + get { + if (outputStream.Count > 0) { + + for (int i = outputStream.Count - 1; i >= 0; i--) { + var obj = outputStream [i]; + if (obj is ControlCommand) // e.g. BeginString + break; + var text = outputStream [i] as StringValue; + if (text) { + if (text.isNewline) + return true; + else if (text.isNonWhitespace) + break; + } + } + } + + return false; + } + } + + public bool outputStreamContainsContent { + get { + foreach (var content in outputStream) { + if (content is StringValue) + return true; + } + return false; + } + } + + public bool inStringEvaluation { + get { + for (int i = outputStream.Count - 1; i >= 0; i--) { + var cmd = outputStream [i] as ControlCommand; + if (cmd && cmd.commandType == ControlCommand.CommandType.BeginString) { + return true; + } + } + + return false; + } + } + + public void PushEvaluationStack(Runtime.Object obj) + { + // Include metadata about the origin List for list values when + // they're used, so that lower level functions can make use + // of the origin list to get related items, or make comparisons + // with the integer values etc. + var listValue = obj as ListValue; + if (listValue) { + + // Update origin when list is has something to indicate the list origin + var rawList = listValue.value; + if (rawList.originNames != null) { + if( rawList.origins == null ) rawList.origins = new List(); + rawList.origins.Clear(); + + foreach (var n in rawList.originNames) { + ListDefinition def = null; + story.listDefinitions.TryListGetDefinition (n, out def); + if( !rawList.origins.Contains(def) ) + rawList.origins.Add (def); + } + } + } + + evaluationStack.Add(obj); + } + + public Runtime.Object PopEvaluationStack() + { + var obj = evaluationStack [evaluationStack.Count - 1]; + evaluationStack.RemoveAt (evaluationStack.Count - 1); + return obj; + } + + public Runtime.Object PeekEvaluationStack() + { + return evaluationStack [evaluationStack.Count - 1]; + } + + public List PopEvaluationStack(int numberOfObjects) + { + if(numberOfObjects > evaluationStack.Count) { + throw new System.Exception ("trying to pop too many objects"); + } + + var popped = evaluationStack.GetRange (evaluationStack.Count - numberOfObjects, numberOfObjects); + evaluationStack.RemoveRange (evaluationStack.Count - numberOfObjects, numberOfObjects); + return popped; + } + + /// + /// Ends the current ink flow, unwrapping the callstack but without + /// affecting any variables. Useful if the ink is (say) in the middle + /// a nested tunnel, and you want it to reset so that you can divert + /// elsewhere using ChoosePathString(). Otherwise, after finishing + /// the content you diverted to, it would continue where it left off. + /// Calling this is equivalent to calling -> END in ink. + /// + public void ForceEnd() + { + callStack.Reset(); + + _currentFlow.currentChoices.Clear(); + + currentPointer = Pointer.Null; + previousPointer = Pointer.Null; + + didSafeExit = true; + } + + // Add the end of a function call, trim any whitespace from the end. + // We always trim the start and end of the text that a function produces. + // The start whitespace is discard as it is generated, and the end + // whitespace is trimmed in one go here when we pop the function. + void TrimWhitespaceFromFunctionEnd () + { + Debug.Assert (callStack.currentElement.type == PushPopType.Function); + + var functionStartPoint = callStack.currentElement.functionStartInOuputStream; + + // If the start point has become -1, it means that some non-whitespace + // text has been pushed, so it's safe to go as far back as we're able. + if (functionStartPoint == -1) { + functionStartPoint = 0; + } + + // Trim whitespace from END of function call + for (int i = outputStream.Count - 1; i >= functionStartPoint; i--) { + var obj = outputStream [i]; + var txt = obj as StringValue; + var cmd = obj as ControlCommand; + if (!txt) continue; + if (cmd) break; + + if (txt.isNewline || txt.isInlineWhitespace) { + outputStream.RemoveAt (i); + OutputStreamDirty (); + } else { + break; + } + } + } + + public void PopCallstack (PushPopType? popType = null) + { + // Add the end of a function call, trim any whitespace from the end. + if (callStack.currentElement.type == PushPopType.Function) + TrimWhitespaceFromFunctionEnd (); + + callStack.Pop (popType); + } + + // Don't make public since the method need to be wrapped in Story for visit counting + public void SetChosenPath(Path path, bool incrementingTurnIndex) + { + // Changing direction, assume we need to clear current set of choices + _currentFlow.currentChoices.Clear (); + + var newPointer = story.PointerAtPath (path); + if (!newPointer.isNull && newPointer.index == -1) + newPointer.index = 0; + + currentPointer = newPointer; + + if( incrementingTurnIndex ) + currentTurnIndex++; + } + + public void StartFunctionEvaluationFromGame (Container funcContainer, params object[] arguments) + { + callStack.Push (PushPopType.FunctionEvaluationFromGame, evaluationStack.Count); + callStack.currentElement.currentPointer = Pointer.StartOf (funcContainer); + + PassArgumentsToEvaluationStack (arguments); + } + + public void PassArgumentsToEvaluationStack (params object [] arguments) + { + // Pass arguments onto the evaluation stack + if (arguments != null) { + for (int i = 0; i < arguments.Length; i++) { + if (!(arguments [i] is int || arguments [i] is float || arguments [i] is string || arguments [i] is bool || arguments [i] is InkList)) { + throw new System.ArgumentException ("ink arguments when calling EvaluateFunction / ChoosePathStringWithParameters must be int, float, string, bool or InkList. Argument was "+(arguments [i] == null ? "null" : arguments [i].GetType().Name)); + } + + PushEvaluationStack (Runtime.Value.Create (arguments [i])); + } + } + } + + public bool TryExitFunctionEvaluationFromGame () + { + if( callStack.currentElement.type == PushPopType.FunctionEvaluationFromGame ) { + currentPointer = Pointer.Null; + didSafeExit = true; + return true; + } + + return false; + } + + public object CompleteFunctionEvaluationFromGame () + { + if (callStack.currentElement.type != PushPopType.FunctionEvaluationFromGame) { + throw new Exception ("Expected external function evaluation to be complete. Stack trace: "+callStack.callStackTrace); + } + + int originalEvaluationStackHeight = callStack.currentElement.evaluationStackHeightWhenPushed; + + // Do we have a returned value? + // Potentially pop multiple values off the stack, in case we need + // to clean up after ourselves (e.g. caller of EvaluateFunction may + // have passed too many arguments, and we currently have no way to check for that) + Runtime.Object returnedObj = null; + while (evaluationStack.Count > originalEvaluationStackHeight) { + var poppedObj = PopEvaluationStack (); + if (returnedObj == null) + returnedObj = poppedObj; + } + + // Finally, pop the external function evaluation + PopCallstack (PushPopType.FunctionEvaluationFromGame); + + // What did we get back? + if (returnedObj) { + if (returnedObj is Runtime.Void) + return null; + + // Some kind of value, if not void + var returnVal = returnedObj as Runtime.Value; + + // DivertTargets get returned as the string of components + // (rather than a Path, which isn't public) + if (returnVal.valueType == ValueType.DivertTarget) { + return returnVal.valueObject.ToString (); + } + + // Other types can just have their exact object type: + // int, float, string. VariablePointers get returned as strings. + return returnVal.valueObject; + } + + return null; + } + + public void AddError(string message, bool isWarning) + { + if (!isWarning) { + if (currentErrors == null) currentErrors = new List (); + currentErrors.Add (message); + } else { + if (currentWarnings == null) currentWarnings = new List (); + currentWarnings.Add (message); + } + } + + void OutputStreamDirty() + { + _outputStreamTextDirty = true; + _outputStreamTagsDirty = true; + } + + // REMEMBER! REMEMBER! REMEMBER! + // When adding state, update the Copy method and serialisation + // REMEMBER! REMEMBER! REMEMBER! + + + Dictionary _visitCounts; + Dictionary _turnIndices; + bool _outputStreamTextDirty = true; + bool _outputStreamTagsDirty = true; + + StatePatch _patch; + + Flow _currentFlow; + Dictionary _namedFlows; + const string kDefaultFlowName = "DEFAULT_FLOW"; + bool _aliveFlowNamesDirty = true; + } +} + diff --git a/Assets/Ink/ink-engine-runtime/StoryState.cs.meta b/Assets/Ink/ink-engine-runtime/StoryState.cs.meta new file mode 100644 index 000000000..b77f3fab0 --- /dev/null +++ b/Assets/Ink/ink-engine-runtime/StoryState.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: 8816be301249d394aa164fda4373ae76 +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/Assets/Ink/ink-engine-runtime/StringJoinExtension.cs b/Assets/Ink/ink-engine-runtime/StringJoinExtension.cs new file mode 100644 index 000000000..d650fae6b --- /dev/null +++ b/Assets/Ink/ink-engine-runtime/StringJoinExtension.cs @@ -0,0 +1,28 @@ +using System; +using System.Collections.Generic; +using System.Text; + +namespace Ink.Runtime +{ + public static class StringExt + { + public static string Join(string separator, List objects) + { + var sb = new StringBuilder (); + + var isFirst = true; + foreach (var o in objects) { + + if (!isFirst) + sb.Append (separator); + + sb.Append (o.ToString ()); + + isFirst = false; + } + + return sb.ToString (); + } + } +} + diff --git a/Assets/Ink/ink-engine-runtime/StringJoinExtension.cs.meta b/Assets/Ink/ink-engine-runtime/StringJoinExtension.cs.meta new file mode 100644 index 000000000..f065bdb37 --- /dev/null +++ b/Assets/Ink/ink-engine-runtime/StringJoinExtension.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: 679e8c87fcbf03940bfcf18b75fdaed8 +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/Assets/Ink/ink-engine-runtime/Tag.cs b/Assets/Ink/ink-engine-runtime/Tag.cs new file mode 100644 index 000000000..04c31fd5b --- /dev/null +++ b/Assets/Ink/ink-engine-runtime/Tag.cs @@ -0,0 +1,20 @@ +using System; + +namespace Ink.Runtime +{ + public class Tag : Runtime.Object + { + public string text { get; private set; } + + public Tag (string tagText) + { + this.text = tagText; + } + + public override string ToString () + { + return "# " + text; + } + } +} + diff --git a/Assets/Ink/ink-engine-runtime/Tag.cs.meta b/Assets/Ink/ink-engine-runtime/Tag.cs.meta new file mode 100644 index 000000000..2ba9401ef --- /dev/null +++ b/Assets/Ink/ink-engine-runtime/Tag.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: eaa366b4a14665d45a0c50e75f0a3400 +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/Assets/Ink/ink-engine-runtime/Value.cs b/Assets/Ink/ink-engine-runtime/Value.cs new file mode 100644 index 000000000..f870dffac --- /dev/null +++ b/Assets/Ink/ink-engine-runtime/Value.cs @@ -0,0 +1,405 @@ +using System.ComponentModel; +using System.Collections.Generic; + +namespace Ink.Runtime +{ + // Order is significant for type coersion. + // If types aren't directly compatible for an operation, + // they're coerced to the same type, downward. + // Higher value types "infect" an operation. + // (This may not be the most sensible thing to do, but it's worked so far!) + public enum ValueType + { + // Bool is new addition, keep enum values the same, with Int==0, Float==1 etc, + // but for coersion rules, we want to keep bool with a lower value than Int + // so that it converts in the right direction + Bool = -1, + // Used in coersion + Int, + Float, + List, + String, + + // Not used for coersion described above + DivertTarget, + VariablePointer + } + + public abstract class Value : Runtime.Object + { + public abstract ValueType valueType { get; } + public abstract bool isTruthy { get; } + + public abstract Value Cast(ValueType newType); + + public abstract object valueObject { get; } + + public static Value Create(object val) + { + // Implicitly lose precision from any doubles we get passed in + if (val is double) { + double doub = (double)val; + val = (float)doub; + } + + if( val is bool ) { + return new BoolValue((bool)val); + } else if (val is int) { + return new IntValue ((int)val); + } else if (val is long) { + return new IntValue ((int)(long)val); + } else if (val is float) { + return new FloatValue ((float)val); + } else if (val is double) { + return new FloatValue ((float)(double)val); + } else if (val is string) { + return new StringValue ((string)val); + } else if (val is Path) { + return new DivertTargetValue ((Path)val); + } else if (val is InkList) { + return new ListValue ((InkList)val); + } + + return null; + } + + public override Object Copy() + { + return Create (valueObject); + } + + protected StoryException BadCastException (ValueType targetType) + { + return new StoryException ("Can't cast "+this.valueObject+" from " + this.valueType+" to "+targetType); + } + } + + public abstract class Value : Value + { + public T value { get; set; } + + public override object valueObject { + get { + return (object)value; + } + } + + public Value (T val) + { + value = val; + } + + public override string ToString () + { + return value.ToString(); + } + } + + public class BoolValue : Value + { + public override ValueType valueType { get { return ValueType.Bool; } } + public override bool isTruthy { get { return value; } } + + public BoolValue(bool boolVal) : base(boolVal) + { + } + + public BoolValue() : this(false) {} + + public override Value Cast(ValueType newType) + { + if (newType == valueType) { + return this; + } + + if (newType == ValueType.Int) { + return new IntValue (this.value ? 1 : 0); + } + + if (newType == ValueType.Float) { + return new FloatValue (this.value ? 1.0f : 0.0f); + } + + if (newType == ValueType.String) { + return new StringValue(this.value ? "true" : "false"); + } + + throw BadCastException (newType); + } + + public override string ToString () + { + // Instead of C# "True" / "False" + return value ? "true" : "false"; + } + } + + public class IntValue : Value + { + public override ValueType valueType { get { return ValueType.Int; } } + public override bool isTruthy { get { return value != 0; } } + + public IntValue(int intVal) : base(intVal) + { + } + + public IntValue() : this(0) {} + + public override Value Cast(ValueType newType) + { + if (newType == valueType) { + return this; + } + + if (newType == ValueType.Bool) { + return new BoolValue (this.value == 0 ? false : true); + } + + if (newType == ValueType.Float) { + return new FloatValue ((float)this.value); + } + + if (newType == ValueType.String) { + return new StringValue("" + this.value); + } + + throw BadCastException (newType); + } + } + + public class FloatValue : Value + { + public override ValueType valueType { get { return ValueType.Float; } } + public override bool isTruthy { get { return value != 0.0f; } } + + public FloatValue(float val) : base(val) + { + } + + public FloatValue() : this(0.0f) {} + + public override Value Cast(ValueType newType) + { + if (newType == valueType) { + return this; + } + + if (newType == ValueType.Bool) { + return new BoolValue (this.value == 0.0f ? false : true); + } + + if (newType == ValueType.Int) { + return new IntValue ((int)this.value); + } + + if (newType == ValueType.String) { + return new StringValue("" + this.value.ToString(System.Globalization.CultureInfo.InvariantCulture)); + } + + throw BadCastException (newType); + } + } + + public class StringValue : Value + { + public override ValueType valueType { get { return ValueType.String; } } + public override bool isTruthy { get { return value.Length > 0; } } + + public bool isNewline { get; private set; } + public bool isInlineWhitespace { get; private set; } + public bool isNonWhitespace { + get { + return !isNewline && !isInlineWhitespace; + } + } + + public StringValue(string str) : base(str) + { + // Classify whitespace status + isNewline = value == "\n"; + isInlineWhitespace = true; + foreach (var c in value) { + if (c != ' ' && c != '\t') { + isInlineWhitespace = false; + break; + } + } + } + + public StringValue() : this("") {} + + public override Value Cast(ValueType newType) + { + if (newType == valueType) { + return this; + } + + if (newType == ValueType.Int) { + + int parsedInt; + if (int.TryParse (value, out parsedInt)) { + return new IntValue (parsedInt); + } else { + return null; + } + } + + if (newType == ValueType.Float) { + float parsedFloat; + if (float.TryParse (value, System.Globalization.NumberStyles.Float ,System.Globalization.CultureInfo.InvariantCulture, out parsedFloat)) { + return new FloatValue (parsedFloat); + } else { + return null; + } + } + + throw BadCastException (newType); + } + } + + public class DivertTargetValue : Value + { + public Path targetPath { get { return this.value; } set { this.value = value; } } + public override ValueType valueType { get { return ValueType.DivertTarget; } } + public override bool isTruthy { get { throw new System.Exception("Shouldn't be checking the truthiness of a divert target"); } } + + public DivertTargetValue(Path targetPath) : base(targetPath) + { + } + + public DivertTargetValue() : base(null) + {} + + public override Value Cast(ValueType newType) + { + if (newType == valueType) + return this; + + throw BadCastException (newType); + } + + public override string ToString () + { + return "DivertTargetValue(" + targetPath + ")"; + } + } + + // TODO: Think: Erm, I get that this contains a string, but should + // we really derive from Value? That seems a bit misleading to me. + public class VariablePointerValue : Value + { + public string variableName { get { return this.value; } set { this.value = value; } } + public override ValueType valueType { get { return ValueType.VariablePointer; } } + public override bool isTruthy { get { throw new System.Exception("Shouldn't be checking the truthiness of a variable pointer"); } } + + // Where the variable is located + // -1 = default, unknown, yet to be determined + // 0 = in global scope + // 1+ = callstack element index + 1 (so that the first doesn't conflict with special global scope) + public int contextIndex { get; set; } + + public VariablePointerValue(string variableName, int contextIndex = -1) : base(variableName) + { + this.contextIndex = contextIndex; + } + + public VariablePointerValue() : this(null) + { + } + + public override Value Cast(ValueType newType) + { + if (newType == valueType) + return this; + + throw BadCastException (newType); + } + + public override string ToString () + { + return "VariablePointerValue(" + variableName + ")"; + } + + public override Object Copy() + { + return new VariablePointerValue (variableName, contextIndex); + } + } + + public class ListValue : Value + { + public override ValueType valueType { + get { + return ValueType.List; + } + } + + // Truthy if it is non-empty + public override bool isTruthy { + get { + return value.Count > 0; + } + } + + public override Value Cast (ValueType newType) + { + if (newType == ValueType.Int) { + var max = value.maxItem; + if( max.Key.isNull ) + return new IntValue (0); + else + return new IntValue (max.Value); + } + + else if (newType == ValueType.Float) { + var max = value.maxItem; + if (max.Key.isNull) + return new FloatValue (0.0f); + else + return new FloatValue ((float)max.Value); + } + + else if (newType == ValueType.String) { + var max = value.maxItem; + if (max.Key.isNull) + return new StringValue (""); + else { + return new StringValue (max.Key.ToString()); + } + } + + if (newType == valueType) + return this; + + throw BadCastException (newType); + } + + public ListValue () : base(null) { + value = new InkList (); + } + + public ListValue (InkList list) : base (null) + { + value = new InkList (list); + } + + public ListValue (InkListItem singleItem, int singleValue) : base (null) + { + value = new InkList { + {singleItem, singleValue} + }; + } + + public static void RetainListOriginsForAssignment (Runtime.Object oldValue, Runtime.Object newValue) + { + var oldList = oldValue as ListValue; + var newList = newValue as ListValue; + + // When assigning the emtpy list, try to retain any initial origin names + if (oldList && newList && newList.value.Count == 0) + newList.value.SetInitialOriginNames (oldList.value.originNames); + } + } + +} + diff --git a/Assets/Ink/ink-engine-runtime/Value.cs.meta b/Assets/Ink/ink-engine-runtime/Value.cs.meta new file mode 100644 index 000000000..cdb0f0f7b --- /dev/null +++ b/Assets/Ink/ink-engine-runtime/Value.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: 6a18fada6b5865b448eecf7c16b4aaf5 +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/Assets/Ink/ink-engine-runtime/VariableAssignment.cs b/Assets/Ink/ink-engine-runtime/VariableAssignment.cs new file mode 100644 index 000000000..1c3a433ec --- /dev/null +++ b/Assets/Ink/ink-engine-runtime/VariableAssignment.cs @@ -0,0 +1,27 @@ +using System.ComponentModel; + +namespace Ink.Runtime +{ + // The value to be assigned is popped off the evaluation stack, so no need to keep it here + public class VariableAssignment : Runtime.Object + { + public string variableName { get; protected set; } + public bool isNewDeclaration { get; protected set; } + public bool isGlobal { get; set; } + + public VariableAssignment (string variableName, bool isNewDeclaration) + { + this.variableName = variableName; + this.isNewDeclaration = isNewDeclaration; + } + + // Require default constructor for serialisation + public VariableAssignment() : this(null, false) {} + + public override string ToString () + { + return "VarAssign to " + variableName; + } + } +} + diff --git a/Assets/Ink/ink-engine-runtime/VariableAssignment.cs.meta b/Assets/Ink/ink-engine-runtime/VariableAssignment.cs.meta new file mode 100644 index 000000000..a2741d0ce --- /dev/null +++ b/Assets/Ink/ink-engine-runtime/VariableAssignment.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: e35bcc9deb240dc45b0c776bba8123ac +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/Assets/Ink/ink-engine-runtime/VariableReference.cs b/Assets/Ink/ink-engine-runtime/VariableReference.cs new file mode 100644 index 000000000..74033127a --- /dev/null +++ b/Assets/Ink/ink-engine-runtime/VariableReference.cs @@ -0,0 +1,51 @@ +namespace Ink.Runtime +{ + public class VariableReference : Runtime.Object + { + // Normal named variable + public string name { get; set; } + + // Variable reference is actually a path for a visit (read) count + public Path pathForCount { get; set; } + + public Container containerForCount { + get { + return this.ResolvePath (pathForCount).container; + } + } + + public string pathStringForCount { + get { + if( pathForCount == null ) + return null; + + return CompactPathString(pathForCount); + } + set { + if (value == null) + pathForCount = null; + else + pathForCount = new Path (value); + } + } + + public VariableReference (string name) + { + this.name = name; + } + + // Require default constructor for serialisation + public VariableReference() {} + + public override string ToString () + { + if (name != null) { + return string.Format ("var({0})", name); + } else { + var pathStr = pathStringForCount; + return string.Format("read_count({0})", pathStr); + } + } + } +} + diff --git a/Assets/Ink/ink-engine-runtime/VariableReference.cs.meta b/Assets/Ink/ink-engine-runtime/VariableReference.cs.meta new file mode 100644 index 000000000..d1c022b60 --- /dev/null +++ b/Assets/Ink/ink-engine-runtime/VariableReference.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: e5685a48dae980a46a9479a2c95f49e1 +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/Assets/Ink/ink-engine-runtime/VariablesState.cs b/Assets/Ink/ink-engine-runtime/VariablesState.cs new file mode 100644 index 000000000..7ddab78ff --- /dev/null +++ b/Assets/Ink/ink-engine-runtime/VariablesState.cs @@ -0,0 +1,417 @@ +using System; +using System.Collections.Generic; + +namespace Ink.Runtime +{ + /// + /// Encompasses all the global variables in an ink Story, and + /// allows binding of a VariableChanged event so that that game + /// code can be notified whenever the global variables change. + /// + public class VariablesState : IEnumerable + { + public delegate void VariableChanged(string variableName, Runtime.Object newValue); + public event VariableChanged variableChangedEvent; + + public StatePatch patch; + + public bool batchObservingVariableChanges + { + get { + return _batchObservingVariableChanges; + } + set { + _batchObservingVariableChanges = value; + if (value) { + _changedVariablesForBatchObs = new HashSet (); + } + + // Finished observing variables in a batch - now send + // notifications for changed variables all in one go. + else { + if (_changedVariablesForBatchObs != null) { + foreach (var variableName in _changedVariablesForBatchObs) { + var currentValue = _globalVariables [variableName]; + variableChangedEvent (variableName, currentValue); + } + } + + _changedVariablesForBatchObs = null; + } + } + } + bool _batchObservingVariableChanges; + + // Allow StoryState to change the current callstack, e.g. for + // temporary function evaluation. + public CallStack callStack { + get { + return _callStack; + } + set { + _callStack = value; + } + } + + /// + /// Get or set the value of a named global ink variable. + /// The types available are the standard ink types. Certain + /// types will be implicitly casted when setting. + /// For example, doubles to floats, longs to ints, and bools + /// to ints. + /// + public object this[string variableName] + { + get { + Runtime.Object varContents; + + if (patch != null && patch.TryGetGlobal(variableName, out varContents)) + return (varContents as Runtime.Value).valueObject; + + // Search main dictionary first. + // If it's not found, it might be because the story content has changed, + // and the original default value hasn't be instantiated. + // Should really warn somehow, but it's difficult to see how...! + if ( _globalVariables.TryGetValue (variableName, out varContents) || + _defaultGlobalVariables.TryGetValue(variableName, out varContents) ) + return (varContents as Runtime.Value).valueObject; + else { + return null; + } + } + set { + if (!_defaultGlobalVariables.ContainsKey (variableName)) + throw new StoryException ("Cannot assign to a variable ("+variableName+") that hasn't been declared in the story"); + + var val = Runtime.Value.Create(value); + if (val == null) { + if (value == null) { + throw new Exception ("Cannot pass null to VariableState"); + } else { + throw new Exception ("Invalid value passed to VariableState: "+value.ToString()); + } + } + + SetGlobal (variableName, val); + } + } + + System.Collections.IEnumerator System.Collections.IEnumerable.GetEnumerator() + { + return GetEnumerator(); + } + + /// + /// Enumerator to allow iteration over all global variables by name. + /// + public IEnumerator GetEnumerator() + { + return _globalVariables.Keys.GetEnumerator(); + } + + public VariablesState (CallStack callStack, ListDefinitionsOrigin listDefsOrigin) + { + _globalVariables = new Dictionary (); + _callStack = callStack; + _listDefsOrigin = listDefsOrigin; + } + + public void ApplyPatch() + { + foreach(var namedVar in patch.globals) { + _globalVariables[namedVar.Key] = namedVar.Value; + } + + if(_changedVariablesForBatchObs != null ) { + foreach (var name in patch.changedVariables) + _changedVariablesForBatchObs.Add(name); + } + + patch = null; + } + + public void SetJsonToken(Dictionary jToken) + { + _globalVariables.Clear(); + + foreach (var varVal in _defaultGlobalVariables) { + object loadedToken; + if( jToken.TryGetValue(varVal.Key, out loadedToken) ) { + _globalVariables[varVal.Key] = Json.JTokenToRuntimeObject(loadedToken); + } else { + _globalVariables[varVal.Key] = varVal.Value; + } + } + } + + /// + /// When saving out JSON state, we can skip saving global values that + /// remain equal to the initial values that were declared in ink. + /// This makes the save file (potentially) much smaller assuming that + /// at least a portion of the globals haven't changed. However, it + /// can also take marginally longer to save in the case that the + /// majority HAVE changed, since it has to compare all globals. + /// It may also be useful to turn this off for testing worst case + /// save timing. + /// + public static bool dontSaveDefaultValues = true; + + public void WriteJson(SimpleJson.Writer writer) + { + writer.WriteObjectStart(); + foreach (var keyVal in _globalVariables) + { + var name = keyVal.Key; + var val = keyVal.Value; + + if(dontSaveDefaultValues) { + // Don't write out values that are the same as the default global values + Runtime.Object defaultVal; + if (_defaultGlobalVariables.TryGetValue(name, out defaultVal)) + { + if (RuntimeObjectsEqual(val, defaultVal)) + continue; + } + } + + + writer.WritePropertyStart(name); + Json.WriteRuntimeObject(writer, val); + writer.WritePropertyEnd(); + } + writer.WriteObjectEnd(); + } + + public bool RuntimeObjectsEqual(Runtime.Object obj1, Runtime.Object obj2) + { + if (obj1.GetType() != obj2.GetType()) return false; + + // Perform equality on int/float/bool manually to avoid boxing + var boolVal = obj1 as BoolValue; + if( boolVal != null ) { + return boolVal.value == ((BoolValue)obj2).value; + } + + var intVal = obj1 as IntValue; + if( intVal != null ) { + return intVal.value == ((IntValue)obj2).value; + } + + var floatVal = obj1 as FloatValue; + if (floatVal != null) + { + return floatVal.value == ((FloatValue)obj2).value; + } + + // Other Value type (using proper Equals: list, string, divert path) + var val1 = obj1 as Value; + var val2 = obj2 as Value; + if( val1 != null ) { + return val1.valueObject.Equals(val2.valueObject); + } + + throw new System.Exception("FastRoughDefinitelyEquals: Unsupported runtime object type: "+obj1.GetType()); + } + + public Runtime.Object GetVariableWithName(string name) + { + return GetVariableWithName (name, -1); + } + + public Runtime.Object TryGetDefaultVariableValue (string name) + { + Runtime.Object val = null; + _defaultGlobalVariables.TryGetValue (name, out val); + return val; + } + + public bool GlobalVariableExistsWithName(string name) + { + return _globalVariables.ContainsKey(name) || _defaultGlobalVariables != null && _defaultGlobalVariables.ContainsKey(name); + } + + Runtime.Object GetVariableWithName(string name, int contextIndex) + { + Runtime.Object varValue = GetRawVariableWithName (name, contextIndex); + + // Get value from pointer? + var varPointer = varValue as VariablePointerValue; + if (varPointer) { + varValue = ValueAtVariablePointer (varPointer); + } + + return varValue; + } + + Runtime.Object GetRawVariableWithName(string name, int contextIndex) + { + Runtime.Object varValue = null; + + // 0 context = global + if (contextIndex == 0 || contextIndex == -1) { + if (patch != null && patch.TryGetGlobal(name, out varValue)) + return varValue; + + if ( _globalVariables.TryGetValue (name, out varValue) ) + return varValue; + + // Getting variables can actually happen during globals set up since you can do + // VAR x = A_LIST_ITEM + // So _defaultGlobalVariables may be null. + // We need to do this check though in case a new global is added, so we need to + // revert to the default globals dictionary since an initial value hasn't yet been set. + if( _defaultGlobalVariables != null && _defaultGlobalVariables.TryGetValue(name, out varValue) ) { + return varValue; + } + + var listItemValue = _listDefsOrigin.FindSingleItemListWithName (name); + if (listItemValue) + return listItemValue; + } + + // Temporary + varValue = _callStack.GetTemporaryVariableWithName (name, contextIndex); + + return varValue; + } + + public Runtime.Object ValueAtVariablePointer(VariablePointerValue pointer) + { + return GetVariableWithName (pointer.variableName, pointer.contextIndex); + } + + public void Assign(VariableAssignment varAss, Runtime.Object value) + { + var name = varAss.variableName; + int contextIndex = -1; + + // Are we assigning to a global variable? + bool setGlobal = false; + if (varAss.isNewDeclaration) { + setGlobal = varAss.isGlobal; + } else { + setGlobal = GlobalVariableExistsWithName (name); + } + + // Constructing new variable pointer reference + if (varAss.isNewDeclaration) { + var varPointer = value as VariablePointerValue; + if (varPointer) { + var fullyResolvedVariablePointer = ResolveVariablePointer (varPointer); + value = fullyResolvedVariablePointer; + } + + } + + // Assign to existing variable pointer? + // Then assign to the variable that the pointer is pointing to by name. + else { + + // De-reference variable reference to point to + VariablePointerValue existingPointer = null; + do { + existingPointer = GetRawVariableWithName (name, contextIndex) as VariablePointerValue; + if (existingPointer) { + name = existingPointer.variableName; + contextIndex = existingPointer.contextIndex; + setGlobal = (contextIndex == 0); + } + } while(existingPointer); + } + + + if (setGlobal) { + SetGlobal (name, value); + } else { + _callStack.SetTemporaryVariable (name, value, varAss.isNewDeclaration, contextIndex); + } + } + + public void SnapshotDefaultGlobals () + { + _defaultGlobalVariables = new Dictionary (_globalVariables); + } + + void RetainListOriginsForAssignment (Runtime.Object oldValue, Runtime.Object newValue) + { + var oldList = oldValue as ListValue; + var newList = newValue as ListValue; + if (oldList && newList && newList.value.Count == 0) + newList.value.SetInitialOriginNames (oldList.value.originNames); + } + + public void SetGlobal(string variableName, Runtime.Object value) + { + Runtime.Object oldValue = null; + if( patch == null || !patch.TryGetGlobal(variableName, out oldValue) ) + _globalVariables.TryGetValue (variableName, out oldValue); + + ListValue.RetainListOriginsForAssignment (oldValue, value); + + if (patch != null) + patch.SetGlobal(variableName, value); + else + _globalVariables [variableName] = value; + + if (variableChangedEvent != null && !value.Equals (oldValue)) { + + if (batchObservingVariableChanges) { + if (patch != null) + patch.AddChangedVariable(variableName); + else if(_changedVariablesForBatchObs != null) + _changedVariablesForBatchObs.Add (variableName); + } else { + variableChangedEvent (variableName, value); + } + } + } + + // Given a variable pointer with just the name of the target known, resolve to a variable + // pointer that more specifically points to the exact instance: whether it's global, + // or the exact position of a temporary on the callstack. + VariablePointerValue ResolveVariablePointer(VariablePointerValue varPointer) + { + int contextIndex = varPointer.contextIndex; + + if( contextIndex == -1 ) + contextIndex = GetContextIndexOfVariableNamed (varPointer.variableName); + + var valueOfVariablePointedTo = GetRawVariableWithName (varPointer.variableName, contextIndex); + + // Extra layer of indirection: + // When accessing a pointer to a pointer (e.g. when calling nested or + // recursive functions that take a variable references, ensure we don't create + // a chain of indirection by just returning the final target. + var doubleRedirectionPointer = valueOfVariablePointedTo as VariablePointerValue; + if (doubleRedirectionPointer) { + return doubleRedirectionPointer; + } + + // Make copy of the variable pointer so we're not using the value direct from + // the runtime. Temporary must be local to the current scope. + else { + return new VariablePointerValue (varPointer.variableName, contextIndex); + } + } + + // 0 if named variable is global + // 1+ if named variable is a temporary in a particular call stack element + int GetContextIndexOfVariableNamed(string varName) + { + if (GlobalVariableExistsWithName(varName)) + return 0; + + return _callStack.currentElementIndex; + } + + Dictionary _globalVariables; + + Dictionary _defaultGlobalVariables; + + // Used for accessing temporary variables + CallStack _callStack; + HashSet _changedVariablesForBatchObs; + ListDefinitionsOrigin _listDefsOrigin; + } +} + diff --git a/Assets/Ink/ink-engine-runtime/VariablesState.cs.meta b/Assets/Ink/ink-engine-runtime/VariablesState.cs.meta new file mode 100644 index 000000000..1085a992c --- /dev/null +++ b/Assets/Ink/ink-engine-runtime/VariablesState.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: 4bbf0da96db24d542a6a8d094ec9bfa8 +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/Assets/Ink/ink-engine-runtime/Void.cs b/Assets/Ink/ink-engine-runtime/Void.cs new file mode 100644 index 000000000..340570d9d --- /dev/null +++ b/Assets/Ink/ink-engine-runtime/Void.cs @@ -0,0 +1,10 @@ +namespace Ink.Runtime +{ + public class Void : Runtime.Object + { + public Void () + { + } + } +} + diff --git a/Assets/Ink/ink-engine-runtime/Void.cs.meta b/Assets/Ink/ink-engine-runtime/Void.cs.meta new file mode 100644 index 000000000..afd46fe93 --- /dev/null +++ b/Assets/Ink/ink-engine-runtime/Void.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: f618733a45617be4e92632f51285b7d3 +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/Assets/Ink/ink-engine-runtime/ink-engine-runtime.csproj b/Assets/Ink/ink-engine-runtime/ink-engine-runtime.csproj new file mode 100644 index 000000000..cac1d950d --- /dev/null +++ b/Assets/Ink/ink-engine-runtime/ink-engine-runtime.csproj @@ -0,0 +1,55 @@ + + + + netstandard1.0;netstandard2.0 + Ink.Runtime + ink-engine-runtime + + + + bin\$(Configuration)\$(TargetFramework)\ink-engine-runtime.xml + inkle Ltd + InkleStudios + inkle Ltd + https://github.com/inkle/ink + https://www.inklestudios.com/ink/ + 0.9.0 + https://avatars2.githubusercontent.com/u/1987090 + Runtime engine for the ink scripting language + git + true + Inkle.Ink.Engine + LICENSE.txt + 1701;1702;1591 + + + + + + + True + + + + + + + + <_Parameter1>ink_compiler + + + <_Parameter1>inklecate + + + <_Parameter1>ink-tests + + + + diff --git a/Assets/Ink/ink-engine-runtime/ink-engine-runtime.csproj.meta b/Assets/Ink/ink-engine-runtime/ink-engine-runtime.csproj.meta new file mode 100644 index 000000000..065a88731 --- /dev/null +++ b/Assets/Ink/ink-engine-runtime/ink-engine-runtime.csproj.meta @@ -0,0 +1,7 @@ +fileFormatVersion: 2 +guid: 11e387c19eb670d44a32246d8349b34b +DefaultImporter: + externalObjects: {} + userData: + assetBundleName: + assetBundleVariant: diff --git a/Assets/Prefabs/UI/Choice.prefab b/Assets/Prefabs/UI/Choice.prefab new file mode 100644 index 000000000..212919031 --- /dev/null +++ b/Assets/Prefabs/UI/Choice.prefab @@ -0,0 +1,277 @@ +%YAML 1.1 +%TAG !u! tag:unity3d.com,2011: +--- !u!1 &2041094598146219077 +GameObject: + m_ObjectHideFlags: 0 + m_CorrespondingSourceObject: {fileID: 0} + m_PrefabInstance: {fileID: 0} + m_PrefabAsset: {fileID: 0} + serializedVersion: 6 + m_Component: + - component: {fileID: 1388299342124750210} + - component: {fileID: 7958013063086106696} + m_Layer: 5 + m_Name: TMP SubMeshUI [UbuntuMono-R SDF + LiberationSans SDF Atlas] + m_TagString: Untagged + m_Icon: {fileID: 0} + m_NavMeshLayer: 0 + m_StaticEditorFlags: 0 + m_IsActive: 1 +--- !u!224 &1388299342124750210 +RectTransform: + m_ObjectHideFlags: 0 + m_CorrespondingSourceObject: {fileID: 0} + m_PrefabInstance: {fileID: 0} + m_PrefabAsset: {fileID: 0} + m_GameObject: {fileID: 2041094598146219077} + m_LocalRotation: {x: 0, y: 0, z: 0, w: 1} + m_LocalPosition: {x: 0, y: 0, z: 0} + m_LocalScale: {x: 1, y: 1, z: 1} + m_Children: [] + m_Father: {fileID: 3385051013345111086} + m_RootOrder: 0 + m_LocalEulerAnglesHint: {x: 0, y: 0, z: 0} + m_AnchorMin: {x: 0, y: 0} + m_AnchorMax: {x: 1, y: 1} + m_AnchoredPosition: {x: 0, y: 0} + m_SizeDelta: {x: 0, y: 0} + m_Pivot: {x: 0.5, y: 0.5} +--- !u!222 &7958013063086106696 +CanvasRenderer: + m_ObjectHideFlags: 0 + m_CorrespondingSourceObject: {fileID: 0} + m_PrefabInstance: {fileID: 0} + m_PrefabAsset: {fileID: 0} + m_GameObject: {fileID: 2041094598146219077} + m_CullTransparentMesh: 0 +--- !u!1 &5076249769481262011 +GameObject: + m_ObjectHideFlags: 0 + m_CorrespondingSourceObject: {fileID: 0} + m_PrefabInstance: {fileID: 0} + m_PrefabAsset: {fileID: 0} + serializedVersion: 6 + m_Component: + - component: {fileID: 3385051013345111086} + - component: {fileID: 7536621788324165687} + - component: {fileID: 967251494986686467} + - component: {fileID: 8416456598956235329} + - component: {fileID: 6319816825972189350} + - component: {fileID: 4890066422904577768} + - component: {fileID: 3888200829196937933} + m_Layer: 5 + m_Name: Choice + m_TagString: Untagged + m_Icon: {fileID: 0} + m_NavMeshLayer: 0 + m_StaticEditorFlags: 0 + m_IsActive: 1 +--- !u!224 &3385051013345111086 +RectTransform: + m_ObjectHideFlags: 0 + m_CorrespondingSourceObject: {fileID: 0} + m_PrefabInstance: {fileID: 0} + m_PrefabAsset: {fileID: 0} + m_GameObject: {fileID: 5076249769481262011} + m_LocalRotation: {x: -0, y: -0, z: -0, w: 1} + m_LocalPosition: {x: 0, y: 0, z: 0} + m_LocalScale: {x: 1, y: 1, z: 1} + m_Children: + - {fileID: 1388299342124750210} + m_Father: {fileID: 0} + m_RootOrder: 0 + m_LocalEulerAnglesHint: {x: 0, y: 0, z: 0} + m_AnchorMin: {x: 0, y: 0} + m_AnchorMax: {x: 0, y: 0} + m_AnchoredPosition: {x: 558.5, y: 0} + m_SizeDelta: {x: 1101, y: 0} + m_Pivot: {x: 0.5, y: 0.5} +--- !u!222 &7536621788324165687 +CanvasRenderer: + m_ObjectHideFlags: 0 + m_CorrespondingSourceObject: {fileID: 0} + m_PrefabInstance: {fileID: 0} + m_PrefabAsset: {fileID: 0} + m_GameObject: {fileID: 5076249769481262011} + m_CullTransparentMesh: 0 +--- !u!114 &967251494986686467 +MonoBehaviour: + m_ObjectHideFlags: 0 + m_CorrespondingSourceObject: {fileID: 0} + m_PrefabInstance: {fileID: 0} + m_PrefabAsset: {fileID: 0} + m_GameObject: {fileID: 5076249769481262011} + m_Enabled: 1 + m_EditorHideFlags: 0 + m_Script: {fileID: 11500000, guid: f4688fdb7df04437aeb418b961361dc5, type: 3} + m_Name: + m_EditorClassIdentifier: + m_Material: {fileID: 0} + m_Color: {r: 1, g: 1, b: 1, a: 1} + m_RaycastTarget: 1 + m_RaycastPadding: {x: 0, y: 0, z: 0, w: 0} + m_Maskable: 1 + m_OnCullStateChanged: + m_PersistentCalls: + m_Calls: [] + m_text: Choice A + m_isRightToLeft: 0 + m_fontAsset: {fileID: 11400000, guid: 3fb7d873bb5a7944bb9a7c73c430c44b, type: 2} + m_sharedMaterial: {fileID: 2100000, guid: b9d2f6c9804cec1489502dcc1c19ec54, type: 2} + m_fontSharedMaterials: [] + m_fontMaterial: {fileID: 0} + m_fontMaterials: [] + m_fontColor32: + serializedVersion: 2 + rgba: 4294967295 + m_fontColor: {r: 1, g: 1, b: 1, a: 1} + m_enableVertexGradient: 0 + m_colorMode: 3 + m_fontColorGradient: + topLeft: {r: 1, g: 1, b: 1, a: 1} + topRight: {r: 1, g: 1, b: 1, a: 1} + bottomLeft: {r: 1, g: 1, b: 1, a: 1} + bottomRight: {r: 1, g: 1, b: 1, a: 1} + m_fontColorGradientPreset: {fileID: 0} + m_spriteAsset: {fileID: 0} + m_tintAllSprites: 0 + m_StyleSheet: {fileID: 0} + m_TextStyleHashCode: -1183493901 + m_overrideHtmlColors: 0 + m_faceColor: + serializedVersion: 2 + rgba: 4294967295 + m_fontSize: 28 + m_fontSizeBase: 28 + m_fontWeight: 400 + m_enableAutoSizing: 0 + m_fontSizeMin: 18 + m_fontSizeMax: 72 + m_fontStyle: 0 + m_HorizontalAlignment: 1 + m_VerticalAlignment: 256 + m_textAlignment: 65535 + m_characterSpacing: 0 + m_wordSpacing: 0 + m_lineSpacing: 0 + m_lineSpacingMax: 0 + m_paragraphSpacing: 0 + m_charWidthMaxAdj: 0 + m_enableWordWrapping: 1 + m_wordWrappingRatios: 0.4 + m_overflowMode: 0 + m_linkedTextComponent: {fileID: 0} + parentLinkedComponent: {fileID: 0} + m_enableKerning: 1 + m_enableExtraPadding: 0 + checkPaddingRequired: 0 + m_isRichText: 1 + m_parseCtrlCharacters: 1 + m_isOrthographic: 1 + m_isCullingEnabled: 0 + m_horizontalMapping: 0 + m_verticalMapping: 0 + m_uvLineOffset: 0 + m_geometrySortingOrder: 0 + m_IsTextObjectScaleStatic: 0 + m_VertexBufferAutoSizeReduction: 1 + m_useMaxVisibleDescender: 1 + m_pageToDisplay: 1 + m_margin: {x: 0, y: 0, z: 0, w: 0} + m_isUsingLegacyAnimationComponent: 0 + m_isVolumetricText: 0 + m_hasFontAssetChanged: 0 + m_baseMaterial: {fileID: 0} + m_maskOffset: {x: 0, y: 0, z: 0, w: 0} +--- !u!114 &8416456598956235329 +MonoBehaviour: + m_ObjectHideFlags: 0 + m_CorrespondingSourceObject: {fileID: 0} + m_PrefabInstance: {fileID: 0} + m_PrefabAsset: {fileID: 0} + m_GameObject: {fileID: 5076249769481262011} + m_Enabled: 1 + m_EditorHideFlags: 0 + m_Script: {fileID: 11500000, guid: 306cc8c2b49d7114eaa3623786fc2126, type: 3} + m_Name: + m_EditorClassIdentifier: + m_IgnoreLayout: 0 + m_MinWidth: -1 + m_MinHeight: -1 + m_PreferredWidth: -1 + m_PreferredHeight: -1 + m_FlexibleWidth: -1 + m_FlexibleHeight: -1 + m_LayoutPriority: 1 +--- !u!114 &6319816825972189350 +MonoBehaviour: + m_ObjectHideFlags: 0 + m_CorrespondingSourceObject: {fileID: 0} + m_PrefabInstance: {fileID: 0} + m_PrefabAsset: {fileID: 0} + m_GameObject: {fileID: 5076249769481262011} + m_Enabled: 1 + m_EditorHideFlags: 0 + m_Script: {fileID: 11500000, guid: 3245ec927659c4140ac4f8d17403cc18, type: 3} + m_Name: + m_EditorClassIdentifier: + m_HorizontalFit: 0 + m_VerticalFit: 2 +--- !u!114 &4890066422904577768 +MonoBehaviour: + m_ObjectHideFlags: 0 + m_CorrespondingSourceObject: {fileID: 0} + m_PrefabInstance: {fileID: 0} + m_PrefabAsset: {fileID: 0} + m_GameObject: {fileID: 5076249769481262011} + m_Enabled: 1 + m_EditorHideFlags: 0 + m_Script: {fileID: 11500000, guid: 4e29b1a8efbd4b44bb3f3716e73f07ff, type: 3} + m_Name: + m_EditorClassIdentifier: + m_Navigation: + m_Mode: 3 + m_WrapAround: 0 + m_SelectOnUp: {fileID: 0} + m_SelectOnDown: {fileID: 0} + m_SelectOnLeft: {fileID: 0} + m_SelectOnRight: {fileID: 0} + m_Transition: 1 + m_Colors: + m_NormalColor: {r: 1, g: 1, b: 1, a: 1} + m_HighlightedColor: {r: 0.9607843, g: 0.9607843, b: 0.9607843, a: 1} + m_PressedColor: {r: 0.78431374, g: 0.78431374, b: 0.78431374, a: 1} + m_SelectedColor: {r: 0.9607843, g: 0.9607843, b: 0.9607843, a: 1} + m_DisabledColor: {r: 0.78431374, g: 0.78431374, b: 0.78431374, a: 0.5019608} + m_ColorMultiplier: 1 + m_FadeDuration: 0.1 + m_SpriteState: + m_HighlightedSprite: {fileID: 0} + m_PressedSprite: {fileID: 0} + m_SelectedSprite: {fileID: 0} + m_DisabledSprite: {fileID: 0} + m_AnimationTriggers: + m_NormalTrigger: Normal + m_HighlightedTrigger: Highlighted + m_PressedTrigger: Pressed + m_SelectedTrigger: Selected + m_DisabledTrigger: Disabled + m_Interactable: 1 + m_TargetGraphic: {fileID: 967251494986686467} + m_OnClick: + m_PersistentCalls: + m_Calls: [] +--- !u!114 &3888200829196937933 +MonoBehaviour: + m_ObjectHideFlags: 0 + m_CorrespondingSourceObject: {fileID: 0} + m_PrefabInstance: {fileID: 0} + m_PrefabAsset: {fileID: 0} + m_GameObject: {fileID: 5076249769481262011} + m_Enabled: 1 + m_EditorHideFlags: 0 + m_Script: {fileID: 11500000, guid: 369e33e0c70b03740a9f757c5a1a9dac, type: 3} + m_Name: + m_EditorClassIdentifier: + Label: {fileID: 967251494986686467} + Button: {fileID: 4890066422904577768} diff --git a/Assets/Prefabs/UI/Choice.prefab.meta b/Assets/Prefabs/UI/Choice.prefab.meta new file mode 100644 index 000000000..3ad6755e7 --- /dev/null +++ b/Assets/Prefabs/UI/Choice.prefab.meta @@ -0,0 +1,7 @@ +fileFormatVersion: 2 +guid: 18da8be52a78cd34e964e16bf36a5aab +PrefabImporter: + externalObjects: {} + userData: + assetBundleName: + assetBundleVariant: diff --git a/Assets/Scenes/ARPG.unity b/Assets/Scenes/ARPG.unity index 78ee932a0..e3e1f83a0 100644 --- a/Assets/Scenes/ARPG.unity +++ b/Assets/Scenes/ARPG.unity @@ -220,6 +220,61 @@ CanvasRenderer: m_PrefabAsset: {fileID: 0} m_GameObject: {fileID: 8750545} m_CullTransparentMesh: 0 +--- !u!1 &14255051 +GameObject: + m_ObjectHideFlags: 0 + m_CorrespondingSourceObject: {fileID: 0} + m_PrefabInstance: {fileID: 0} + m_PrefabAsset: {fileID: 0} + serializedVersion: 6 + m_Component: + - component: {fileID: 14255052} + - component: {fileID: 14255053} + m_Layer: 5 + m_Name: Local Screen + m_TagString: Untagged + m_Icon: {fileID: 0} + m_NavMeshLayer: 0 + m_StaticEditorFlags: 0 + m_IsActive: 0 +--- !u!224 &14255052 +RectTransform: + m_ObjectHideFlags: 0 + m_CorrespondingSourceObject: {fileID: 0} + m_PrefabInstance: {fileID: 0} + m_PrefabAsset: {fileID: 0} + m_GameObject: {fileID: 14255051} + m_LocalRotation: {x: 0, y: 0, z: 0, w: 1} + m_LocalPosition: {x: 0, y: 0, z: 0} + m_LocalScale: {x: 1, y: 1, z: 1} + m_Children: + - {fileID: 5630987214048981317} + - {fileID: 708838806} + m_Father: {fileID: 1726632265} + m_RootOrder: 0 + m_LocalEulerAnglesHint: {x: 0, y: 0, z: 0} + m_AnchorMin: {x: 0, y: 0} + m_AnchorMax: {x: 1, y: 1} + m_AnchoredPosition: {x: 0, y: -34} + m_SizeDelta: {x: -64, y: -132} + m_Pivot: {x: 0.5, y: 0.5} +--- !u!114 &14255053 +MonoBehaviour: + m_ObjectHideFlags: 0 + m_CorrespondingSourceObject: {fileID: 0} + m_PrefabInstance: {fileID: 0} + m_PrefabAsset: {fileID: 0} + m_GameObject: {fileID: 14255051} + m_Enabled: 1 + m_EditorHideFlags: 0 + m_Script: {fileID: 11500000, guid: 94223b4e7b954df47a5400f0e7be80c1, type: 3} + m_Name: + m_EditorClassIdentifier: + ContinueTrigger: {fileID: 708838807} + Output: {fileID: 2118604532} + ChoiceParent: {fileID: 1225245880} + ChoicePrefab: {fileID: 3888200829196937933, guid: 18da8be52a78cd34e964e16bf36a5aab, + type: 3} --- !u!1 &19222411 GameObject: m_ObjectHideFlags: 0 @@ -808,11 +863,11 @@ RectTransform: m_LocalScale: {x: 1, y: 1, z: 1} m_Children: [] m_Father: {fileID: 1783772015} - m_RootOrder: 0 + m_RootOrder: 1 m_LocalEulerAnglesHint: {x: 0, y: 0, z: 0} m_AnchorMin: {x: 0, y: 1} m_AnchorMax: {x: 0, y: 1} - m_AnchoredPosition: {x: 527.51, y: -40} + m_AnchoredPosition: {x: 616.52, y: -40} m_SizeDelta: {x: 329.91, y: 56} m_Pivot: {x: 0.5, y: 0.5} --- !u!114 &101395091 @@ -1087,6 +1142,102 @@ RectTransform: m_AnchoredPosition: {x: -0.000015258789, y: -40} m_SizeDelta: {x: 0, y: 12} m_Pivot: {x: 0.5, y: 1} +--- !u!1 &119922872 +GameObject: + m_ObjectHideFlags: 0 + m_CorrespondingSourceObject: {fileID: 0} + m_PrefabInstance: {fileID: 0} + m_PrefabAsset: {fileID: 0} + serializedVersion: 6 + m_Component: + - component: {fileID: 119922873} + - component: {fileID: 119922876} + - component: {fileID: 119922875} + - component: {fileID: 119922874} + m_Layer: 5 + m_Name: Divider + m_TagString: Untagged + m_Icon: {fileID: 0} + m_NavMeshLayer: 0 + m_StaticEditorFlags: 0 + m_IsActive: 1 +--- !u!224 &119922873 +RectTransform: + m_ObjectHideFlags: 0 + m_CorrespondingSourceObject: {fileID: 0} + m_PrefabInstance: {fileID: 0} + m_PrefabAsset: {fileID: 0} + m_GameObject: {fileID: 119922872} + m_LocalRotation: {x: -0, y: -0, z: -0, w: 1} + m_LocalPosition: {x: 0, y: 0, z: 0} + m_LocalScale: {x: 1, y: 1, z: 1} + m_Children: [] + m_Father: {fileID: 708838806} + m_RootOrder: 1 + m_LocalEulerAnglesHint: {x: 0, y: 0, z: 0} + m_AnchorMin: {x: 0, y: 1} + m_AnchorMax: {x: 1, y: 1} + m_AnchoredPosition: {x: 0, y: -40} + m_SizeDelta: {x: 0, y: 3} + m_Pivot: {x: 0.5, y: 0.5} +--- !u!114 &119922874 +MonoBehaviour: + m_ObjectHideFlags: 0 + m_CorrespondingSourceObject: {fileID: 0} + m_PrefabInstance: {fileID: 0} + m_PrefabAsset: {fileID: 0} + m_GameObject: {fileID: 119922872} + m_Enabled: 1 + m_EditorHideFlags: 0 + m_Script: {fileID: 11500000, guid: 306cc8c2b49d7114eaa3623786fc2126, type: 3} + m_Name: + m_EditorClassIdentifier: + m_IgnoreLayout: 1 + m_MinWidth: -1 + m_MinHeight: 4 + m_PreferredWidth: -1 + m_PreferredHeight: -1 + m_FlexibleWidth: -1 + m_FlexibleHeight: -1 + m_LayoutPriority: 1 +--- !u!114 &119922875 +MonoBehaviour: + m_ObjectHideFlags: 0 + m_CorrespondingSourceObject: {fileID: 0} + m_PrefabInstance: {fileID: 0} + m_PrefabAsset: {fileID: 0} + m_GameObject: {fileID: 119922872} + m_Enabled: 1 + m_EditorHideFlags: 0 + m_Script: {fileID: 11500000, guid: fe87c0e1cc204ed48ad3b37840f39efc, type: 3} + m_Name: + m_EditorClassIdentifier: + m_Material: {fileID: 0} + m_Color: {r: 0.8, g: 0.9333333, b: 1, a: 1} + m_RaycastTarget: 1 + m_RaycastPadding: {x: 0, y: 0, z: 0, w: 0} + m_Maskable: 1 + m_OnCullStateChanged: + m_PersistentCalls: + m_Calls: [] + m_Sprite: {fileID: 21300000, guid: ea8a1213adadb5a4fba6b1785033a34b, type: 3} + m_Type: 1 + m_PreserveAspect: 0 + m_FillCenter: 1 + m_FillMethod: 4 + m_FillAmount: 1 + m_FillClockwise: 1 + m_FillOrigin: 0 + m_UseSpriteMesh: 0 + m_PixelsPerUnitMultiplier: 1 +--- !u!222 &119922876 +CanvasRenderer: + m_ObjectHideFlags: 0 + m_CorrespondingSourceObject: {fileID: 0} + m_PrefabInstance: {fileID: 0} + m_PrefabAsset: {fileID: 0} + m_GameObject: {fileID: 119922872} + m_CullTransparentMesh: 0 --- !u!1 &121030072 GameObject: m_ObjectHideFlags: 0 @@ -8018,7 +8169,7 @@ RectTransform: - {fileID: 1914914798} - {fileID: 655315360} m_Father: {fileID: 1726632265} - m_RootOrder: 2 + m_RootOrder: 3 m_LocalEulerAnglesHint: {x: 0, y: 0, z: 0} m_AnchorMin: {x: 0, y: 0} m_AnchorMax: {x: 1, y: 1} @@ -9494,7 +9645,7 @@ RectTransform: - {fileID: 250585915} - {fileID: 1130044040} m_Father: {fileID: 1726632265} - m_RootOrder: 1 + m_RootOrder: 2 m_LocalEulerAnglesHint: {x: 0, y: 0, z: 0} m_AnchorMin: {x: 0, y: 0} m_AnchorMax: {x: 1, y: 1} @@ -10864,6 +11015,97 @@ MeshFilter: m_PrefabAsset: {fileID: 0} m_GameObject: {fileID: 708399893} m_Mesh: {fileID: 10210, guid: 0000000000000000e000000000000000, type: 0} +--- !u!1 &708838805 +GameObject: + m_ObjectHideFlags: 0 + m_CorrespondingSourceObject: {fileID: 0} + m_PrefabInstance: {fileID: 0} + m_PrefabAsset: {fileID: 0} + serializedVersion: 6 + m_Component: + - component: {fileID: 708838806} + - component: {fileID: 708838809} + - component: {fileID: 708838808} + - component: {fileID: 708838807} + m_Layer: 5 + m_Name: Event Log + m_TagString: Untagged + m_Icon: {fileID: 0} + m_NavMeshLayer: 0 + m_StaticEditorFlags: 0 + m_IsActive: 1 +--- !u!224 &708838806 +RectTransform: + m_ObjectHideFlags: 0 + m_CorrespondingSourceObject: {fileID: 0} + m_PrefabInstance: {fileID: 0} + m_PrefabAsset: {fileID: 0} + m_GameObject: {fileID: 708838805} + m_LocalRotation: {x: -0, y: -0, z: -0, w: 1} + m_LocalPosition: {x: 0, y: 0, z: 0} + m_LocalScale: {x: 1, y: 1, z: 1} + m_Children: + - {fileID: 1523504652} + - {fileID: 119922873} + - {fileID: 1648604381} + m_Father: {fileID: 14255052} + m_RootOrder: 1 + m_LocalEulerAnglesHint: {x: 0, y: 0, z: 0} + m_AnchorMin: {x: 1, y: 0} + m_AnchorMax: {x: 1, y: 1} + m_AnchoredPosition: {x: 0, y: 0} + m_SizeDelta: {x: 1132, y: 0} + m_Pivot: {x: 1, y: 0.5} +--- !u!114 &708838807 +MonoBehaviour: + m_ObjectHideFlags: 0 + m_CorrespondingSourceObject: {fileID: 0} + m_PrefabInstance: {fileID: 0} + m_PrefabAsset: {fileID: 0} + m_GameObject: {fileID: 708838805} + m_Enabled: 1 + m_EditorHideFlags: 0 + m_Script: {fileID: 11500000, guid: aa69c313aba23f945b760e79c45083ad, type: 3} + m_Name: + m_EditorClassIdentifier: +--- !u!114 &708838808 +MonoBehaviour: + m_ObjectHideFlags: 0 + m_CorrespondingSourceObject: {fileID: 0} + m_PrefabInstance: {fileID: 0} + m_PrefabAsset: {fileID: 0} + m_GameObject: {fileID: 708838805} + m_Enabled: 1 + m_EditorHideFlags: 0 + m_Script: {fileID: 11500000, guid: fe87c0e1cc204ed48ad3b37840f39efc, type: 3} + m_Name: + m_EditorClassIdentifier: + m_Material: {fileID: 0} + m_Color: {r: 0, g: 0, b: 0, a: 0.29803923} + m_RaycastTarget: 1 + m_RaycastPadding: {x: 0, y: 0, z: 0, w: 0} + m_Maskable: 1 + m_OnCullStateChanged: + m_PersistentCalls: + m_Calls: [] + m_Sprite: {fileID: 21300000, guid: 7ed12bf887e951949bd02894a21fb3ff, type: 3} + m_Type: 1 + m_PreserveAspect: 0 + m_FillCenter: 1 + m_FillMethod: 4 + m_FillAmount: 1 + m_FillClockwise: 1 + m_FillOrigin: 0 + m_UseSpriteMesh: 0 + m_PixelsPerUnitMultiplier: 1 +--- !u!222 &708838809 +CanvasRenderer: + m_ObjectHideFlags: 0 + m_CorrespondingSourceObject: {fileID: 0} + m_PrefabInstance: {fileID: 0} + m_PrefabAsset: {fileID: 0} + m_GameObject: {fileID: 708838805} + m_CullTransparentMesh: 0 --- !u!1 &719842150 GameObject: m_ObjectHideFlags: 0 @@ -11872,6 +12114,101 @@ CanvasRenderer: m_PrefabAsset: {fileID: 0} m_GameObject: {fileID: 776416423} m_CullTransparentMesh: 1 +--- !u!1 &776899541 +GameObject: + m_ObjectHideFlags: 0 + m_CorrespondingSourceObject: {fileID: 0} + m_PrefabInstance: {fileID: 0} + m_PrefabAsset: {fileID: 0} + serializedVersion: 6 + m_Component: + - component: {fileID: 776899542} + - component: {fileID: 776899544} + - component: {fileID: 776899543} + m_Layer: 5 + m_Name: Scrollbar Vertical + m_TagString: Untagged + m_Icon: {fileID: 0} + m_NavMeshLayer: 0 + m_StaticEditorFlags: 0 + m_IsActive: 1 +--- !u!224 &776899542 +RectTransform: + m_ObjectHideFlags: 0 + m_CorrespondingSourceObject: {fileID: 0} + m_PrefabInstance: {fileID: 0} + m_PrefabAsset: {fileID: 0} + m_GameObject: {fileID: 776899541} + m_LocalRotation: {x: 0, y: 0, z: 0, w: 1} + m_LocalPosition: {x: 0, y: 0, z: 0} + m_LocalScale: {x: 1, y: 1, z: 1} + m_Children: + - {fileID: 1036871929} + m_Father: {fileID: 1648604381} + m_RootOrder: 1 + m_LocalEulerAnglesHint: {x: 0, y: 0, z: 0} + m_AnchorMin: {x: 1, y: 0} + m_AnchorMax: {x: 1, y: 1} + m_AnchoredPosition: {x: 0, y: 0} + m_SizeDelta: {x: 10, y: 0} + m_Pivot: {x: 1, y: 1} +--- !u!114 &776899543 +MonoBehaviour: + m_ObjectHideFlags: 0 + m_CorrespondingSourceObject: {fileID: 0} + m_PrefabInstance: {fileID: 0} + m_PrefabAsset: {fileID: 0} + m_GameObject: {fileID: 776899541} + m_Enabled: 1 + m_EditorHideFlags: 0 + m_Script: {fileID: 11500000, guid: 2a4db7a114972834c8e4117be1d82ba3, type: 3} + m_Name: + m_EditorClassIdentifier: + m_Navigation: + m_Mode: 3 + m_WrapAround: 0 + m_SelectOnUp: {fileID: 0} + m_SelectOnDown: {fileID: 0} + m_SelectOnLeft: {fileID: 0} + m_SelectOnRight: {fileID: 0} + m_Transition: 1 + m_Colors: + m_NormalColor: {r: 1, g: 1, b: 1, a: 1} + m_HighlightedColor: {r: 0.9607843, g: 0.9607843, b: 0.9607843, a: 1} + m_PressedColor: {r: 0.78431374, g: 0.78431374, b: 0.78431374, a: 1} + m_SelectedColor: {r: 0.9607843, g: 0.9607843, b: 0.9607843, a: 1} + m_DisabledColor: {r: 0.78431374, g: 0.78431374, b: 0.78431374, a: 0.5019608} + m_ColorMultiplier: 1 + m_FadeDuration: 0.1 + m_SpriteState: + m_HighlightedSprite: {fileID: 0} + m_PressedSprite: {fileID: 0} + m_SelectedSprite: {fileID: 0} + m_DisabledSprite: {fileID: 0} + m_AnimationTriggers: + m_NormalTrigger: Normal + m_HighlightedTrigger: Highlighted + m_PressedTrigger: Pressed + m_SelectedTrigger: Highlighted + m_DisabledTrigger: Disabled + m_Interactable: 1 + m_TargetGraphic: {fileID: 1852331625} + m_HandleRect: {fileID: 1852331624} + m_Direction: 2 + m_Value: 0 + m_Size: 1 + m_NumberOfSteps: 0 + m_OnValueChanged: + m_PersistentCalls: + m_Calls: [] +--- !u!222 &776899544 +CanvasRenderer: + m_ObjectHideFlags: 0 + m_CorrespondingSourceObject: {fileID: 0} + m_PrefabInstance: {fileID: 0} + m_PrefabAsset: {fileID: 0} + m_GameObject: {fileID: 776899541} + m_CullTransparentMesh: 0 --- !u!1 &783543864 GameObject: m_ObjectHideFlags: 0 @@ -13750,11 +14087,11 @@ RectTransform: m_LocalScale: {x: 1, y: 1, z: 1} m_Children: [] m_Father: {fileID: 1783772015} - m_RootOrder: 2 + m_RootOrder: 3 m_LocalEulerAnglesHint: {x: 0, y: 0, z: 0} m_AnchorMin: {x: 0, y: 1} m_AnchorMax: {x: 0, y: 1} - m_AnchoredPosition: {x: 960.13495, y: -40} + m_AnchoredPosition: {x: 1049.145, y: -40} m_SizeDelta: {x: 146.84, y: 56} m_Pivot: {x: 0.5, y: 0.5} --- !u!114 &931657852 @@ -16110,6 +16447,42 @@ CanvasRenderer: m_PrefabAsset: {fileID: 0} m_GameObject: {fileID: 1029396710} m_CullTransparentMesh: 0 +--- !u!1 &1036871928 +GameObject: + m_ObjectHideFlags: 0 + m_CorrespondingSourceObject: {fileID: 0} + m_PrefabInstance: {fileID: 0} + m_PrefabAsset: {fileID: 0} + serializedVersion: 6 + m_Component: + - component: {fileID: 1036871929} + m_Layer: 5 + m_Name: Sliding Area + m_TagString: Untagged + m_Icon: {fileID: 0} + m_NavMeshLayer: 0 + m_StaticEditorFlags: 0 + m_IsActive: 1 +--- !u!224 &1036871929 +RectTransform: + m_ObjectHideFlags: 0 + m_CorrespondingSourceObject: {fileID: 0} + m_PrefabInstance: {fileID: 0} + m_PrefabAsset: {fileID: 0} + m_GameObject: {fileID: 1036871928} + m_LocalRotation: {x: 0, y: 0, z: 0, w: 1} + m_LocalPosition: {x: 0, y: 0, z: 0} + m_LocalScale: {x: 1, y: 1, z: 1} + m_Children: + - {fileID: 1852331624} + m_Father: {fileID: 776899542} + m_RootOrder: 0 + m_LocalEulerAnglesHint: {x: 0, y: 0, z: 0} + m_AnchorMin: {x: 0, y: 0} + m_AnchorMax: {x: 1, y: 1} + m_AnchoredPosition: {x: 0, y: 0} + m_SizeDelta: {x: -20, y: -20} + m_Pivot: {x: 0.5, y: 0.5} --- !u!1 &1037490738 GameObject: m_ObjectHideFlags: 0 @@ -17028,6 +17401,96 @@ CanvasRenderer: m_PrefabAsset: {fileID: 0} m_GameObject: {fileID: 1115239398} m_CullTransparentMesh: 1 +--- !u!1 &1115501494 +GameObject: + m_ObjectHideFlags: 0 + m_CorrespondingSourceObject: {fileID: 0} + m_PrefabInstance: {fileID: 0} + m_PrefabAsset: {fileID: 0} + serializedVersion: 6 + m_Component: + - component: {fileID: 1115501495} + - component: {fileID: 1115501498} + - component: {fileID: 1115501497} + - component: {fileID: 1115501496} + m_Layer: 5 + m_Name: Viewport + m_TagString: Untagged + m_Icon: {fileID: 0} + m_NavMeshLayer: 0 + m_StaticEditorFlags: 0 + m_IsActive: 1 +--- !u!224 &1115501495 +RectTransform: + m_ObjectHideFlags: 0 + m_CorrespondingSourceObject: {fileID: 0} + m_PrefabInstance: {fileID: 0} + m_PrefabAsset: {fileID: 0} + m_GameObject: {fileID: 1115501494} + m_LocalRotation: {x: 0, y: 0, z: 0, w: 1} + m_LocalPosition: {x: 0, y: 0, z: 0} + m_LocalScale: {x: 1, y: 1, z: 1} + m_Children: + - {fileID: 1225245880} + m_Father: {fileID: 1648604381} + m_RootOrder: 0 + m_LocalEulerAnglesHint: {x: 0, y: 0, z: 0} + m_AnchorMin: {x: 0, y: 0} + m_AnchorMax: {x: 1, y: 1} + m_AnchoredPosition: {x: 0, y: 0} + m_SizeDelta: {x: -7, y: 0} + m_Pivot: {x: 0, y: 1} +--- !u!114 &1115501496 +MonoBehaviour: + m_ObjectHideFlags: 0 + m_CorrespondingSourceObject: {fileID: 0} + m_PrefabInstance: {fileID: 0} + m_PrefabAsset: {fileID: 0} + m_GameObject: {fileID: 1115501494} + m_Enabled: 1 + m_EditorHideFlags: 0 + m_Script: {fileID: 11500000, guid: fe87c0e1cc204ed48ad3b37840f39efc, type: 3} + m_Name: + m_EditorClassIdentifier: + m_Material: {fileID: 0} + m_Color: {r: 1, g: 1, b: 1, a: 1} + m_RaycastTarget: 1 + m_RaycastPadding: {x: 0, y: 0, z: 0, w: 0} + m_Maskable: 1 + m_OnCullStateChanged: + m_PersistentCalls: + m_Calls: [] + m_Sprite: {fileID: 10917, guid: 0000000000000000f000000000000000, type: 0} + m_Type: 1 + m_PreserveAspect: 0 + m_FillCenter: 1 + m_FillMethod: 4 + m_FillAmount: 1 + m_FillClockwise: 1 + m_FillOrigin: 0 + m_UseSpriteMesh: 0 + m_PixelsPerUnitMultiplier: 1 +--- !u!222 &1115501497 +CanvasRenderer: + m_ObjectHideFlags: 0 + m_CorrespondingSourceObject: {fileID: 0} + m_PrefabInstance: {fileID: 0} + m_PrefabAsset: {fileID: 0} + m_GameObject: {fileID: 1115501494} + m_CullTransparentMesh: 0 +--- !u!114 &1115501498 +MonoBehaviour: + m_ObjectHideFlags: 0 + m_CorrespondingSourceObject: {fileID: 0} + m_PrefabInstance: {fileID: 0} + m_PrefabAsset: {fileID: 0} + m_GameObject: {fileID: 1115501494} + m_Enabled: 1 + m_EditorHideFlags: 0 + m_Script: {fileID: 11500000, guid: 31a19414c41e5ae4aae2af33fee712f6, type: 3} + m_Name: + m_EditorClassIdentifier: + m_ShowMaskGraphic: 0 --- !u!1 &1130044037 GameObject: m_ObjectHideFlags: 0 @@ -18045,6 +18508,84 @@ MonoBehaviour: m_Script: {fileID: 11500000, guid: 1281fe44325f9b548aa42dc331b17266, type: 3} m_Name: m_EditorClassIdentifier: +--- !u!1 &1225245879 +GameObject: + m_ObjectHideFlags: 0 + m_CorrespondingSourceObject: {fileID: 0} + m_PrefabInstance: {fileID: 0} + m_PrefabAsset: {fileID: 0} + serializedVersion: 6 + m_Component: + - component: {fileID: 1225245880} + - component: {fileID: 1225245882} + - component: {fileID: 1225245881} + m_Layer: 5 + m_Name: Content + m_TagString: Untagged + m_Icon: {fileID: 0} + m_NavMeshLayer: 0 + m_StaticEditorFlags: 0 + m_IsActive: 1 +--- !u!224 &1225245880 +RectTransform: + m_ObjectHideFlags: 0 + m_CorrespondingSourceObject: {fileID: 0} + m_PrefabInstance: {fileID: 0} + m_PrefabAsset: {fileID: 0} + m_GameObject: {fileID: 1225245879} + m_LocalRotation: {x: 0, y: 0, z: 0, w: 1} + m_LocalPosition: {x: 0, y: 0, z: 0} + m_LocalScale: {x: 1, y: 1, z: 1} + m_Children: + - {fileID: 2118604529} + m_Father: {fileID: 1115501495} + m_RootOrder: 0 + m_LocalEulerAnglesHint: {x: 0, y: 0, z: 0} + m_AnchorMin: {x: 0, y: 0} + m_AnchorMax: {x: 1, y: 1} + m_AnchoredPosition: {x: 4, y: 0} + m_SizeDelta: {x: -8, y: -330.99} + m_Pivot: {x: 0, y: 1} +--- !u!114 &1225245881 +MonoBehaviour: + m_ObjectHideFlags: 0 + m_CorrespondingSourceObject: {fileID: 0} + m_PrefabInstance: {fileID: 0} + m_PrefabAsset: {fileID: 0} + m_GameObject: {fileID: 1225245879} + m_Enabled: 1 + m_EditorHideFlags: 0 + m_Script: {fileID: 11500000, guid: 3245ec927659c4140ac4f8d17403cc18, type: 3} + m_Name: + m_EditorClassIdentifier: + m_HorizontalFit: 0 + m_VerticalFit: 2 +--- !u!114 &1225245882 +MonoBehaviour: + m_ObjectHideFlags: 0 + m_CorrespondingSourceObject: {fileID: 0} + m_PrefabInstance: {fileID: 0} + m_PrefabAsset: {fileID: 0} + m_GameObject: {fileID: 1225245879} + m_Enabled: 1 + m_EditorHideFlags: 0 + m_Script: {fileID: 11500000, guid: 59f8146938fff824cb5fd77236b75775, type: 3} + m_Name: + m_EditorClassIdentifier: + m_Padding: + m_Left: 8 + m_Right: 8 + m_Top: 8 + m_Bottom: 8 + m_ChildAlignment: 0 + m_Spacing: 32 + m_ChildForceExpandWidth: 1 + m_ChildForceExpandHeight: 0 + m_ChildControlWidth: 1 + m_ChildControlHeight: 1 + m_ChildScaleWidth: 0 + m_ChildScaleHeight: 0 + m_ReverseArrangement: 0 --- !u!1001 &1227588621 PrefabInstance: m_ObjectHideFlags: 0 @@ -19920,11 +20461,11 @@ RectTransform: m_LocalScale: {x: 1, y: 1, z: 1} m_Children: [] m_Father: {fileID: 1783772015} - m_RootOrder: 3 + m_RootOrder: 4 m_LocalEulerAnglesHint: {x: 0, y: 0, z: 0} m_AnchorMin: {x: 0, y: 1} m_AnchorMax: {x: 0, y: 1} - m_AnchoredPosition: {x: 1145.4999, y: -40} + m_AnchoredPosition: {x: 1234.5099, y: -40} m_SizeDelta: {x: 223.89, y: 56} m_Pivot: {x: 0.5, y: 0.5} --- !u!114 &1399108419 @@ -20873,11 +21414,11 @@ RectTransform: m_LocalScale: {x: 1, y: 1, z: 1} m_Children: [] m_Father: {fileID: 1783772015} - m_RootOrder: 1 + m_RootOrder: 2 m_LocalEulerAnglesHint: {x: 0, y: 0, z: 0} m_AnchorMin: {x: 0, y: 1} m_AnchorMax: {x: 0, y: 1} - m_AnchoredPosition: {x: 789.58997, y: -40} + m_AnchoredPosition: {x: 878.6, y: -40} m_SizeDelta: {x: 194.25, y: 56} m_Pivot: {x: 0.5, y: 0.5} --- !u!114 &1464157086 @@ -21251,6 +21792,203 @@ MeshFilter: m_PrefabAsset: {fileID: 0} m_GameObject: {fileID: 1476765547} m_Mesh: {fileID: 10210, guid: 0000000000000000e000000000000000, type: 0} +--- !u!1 &1485884351 +GameObject: + m_ObjectHideFlags: 0 + m_CorrespondingSourceObject: {fileID: 0} + m_PrefabInstance: {fileID: 0} + m_PrefabAsset: {fileID: 0} + serializedVersion: 6 + m_Component: + - component: {fileID: 1485884352} + - component: {fileID: 1485884356} + - component: {fileID: 1485884355} + - component: {fileID: 1485884354} + - component: {fileID: 1485884353} + m_Layer: 5 + m_Name: Local + m_TagString: Untagged + m_Icon: {fileID: 0} + m_NavMeshLayer: 0 + m_StaticEditorFlags: 0 + m_IsActive: 1 +--- !u!224 &1485884352 +RectTransform: + m_ObjectHideFlags: 0 + m_CorrespondingSourceObject: {fileID: 0} + m_PrefabInstance: {fileID: 0} + m_PrefabAsset: {fileID: 0} + m_GameObject: {fileID: 1485884351} + m_LocalRotation: {x: 0, y: 0, z: 0, w: 1} + m_LocalPosition: {x: 0, y: 0, z: 0} + m_LocalScale: {x: 1, y: 1, z: 1} + m_Children: [] + m_Father: {fileID: 1783772015} + m_RootOrder: 0 + m_LocalEulerAnglesHint: {x: 0, y: 0, z: 0} + m_AnchorMin: {x: 0, y: 1} + m_AnchorMax: {x: 0, y: 1} + m_AnchoredPosition: {x: 362.555, y: -40} + m_SizeDelta: {x: 178.02, y: 56} + m_Pivot: {x: 0.5, y: 0.5} +--- !u!114 &1485884353 +MonoBehaviour: + m_ObjectHideFlags: 0 + m_CorrespondingSourceObject: {fileID: 0} + m_PrefabInstance: {fileID: 0} + m_PrefabAsset: {fileID: 0} + m_GameObject: {fileID: 1485884351} + m_Enabled: 1 + m_EditorHideFlags: 0 + m_Script: {fileID: 11500000, guid: d90317f6ecd38754fad9aee92f46b126, type: 3} + m_Name: + m_EditorClassIdentifier: + TabContents: {fileID: 14255051} + Button: {fileID: 1485884354} + Tab: 4 + Text: {fileID: 1485884355} + RequireDock: 0 +--- !u!114 &1485884354 +MonoBehaviour: + m_ObjectHideFlags: 0 + m_CorrespondingSourceObject: {fileID: 0} + m_PrefabInstance: {fileID: 0} + m_PrefabAsset: {fileID: 0} + m_GameObject: {fileID: 1485884351} + m_Enabled: 1 + m_EditorHideFlags: 0 + m_Script: {fileID: 11500000, guid: 4e29b1a8efbd4b44bb3f3716e73f07ff, type: 3} + m_Name: + m_EditorClassIdentifier: + m_Navigation: + m_Mode: 3 + m_WrapAround: 0 + m_SelectOnUp: {fileID: 0} + m_SelectOnDown: {fileID: 0} + m_SelectOnLeft: {fileID: 0} + m_SelectOnRight: {fileID: 0} + m_Transition: 1 + m_Colors: + m_NormalColor: {r: 1, g: 1, b: 1, a: 1} + m_HighlightedColor: {r: 0.9607843, g: 0.9607843, b: 0.9607843, a: 1} + m_PressedColor: {r: 0.78431374, g: 0.78431374, b: 0.78431374, a: 1} + m_SelectedColor: {r: 0.9607843, g: 0.9607843, b: 0.9607843, a: 1} + m_DisabledColor: {r: 0.78431374, g: 0.78431374, b: 0.78431374, a: 0.5019608} + m_ColorMultiplier: 1 + m_FadeDuration: 0.1 + m_SpriteState: + m_HighlightedSprite: {fileID: 0} + m_PressedSprite: {fileID: 0} + m_SelectedSprite: {fileID: 0} + m_DisabledSprite: {fileID: 0} + m_AnimationTriggers: + m_NormalTrigger: Normal + m_HighlightedTrigger: Highlighted + m_PressedTrigger: Pressed + m_SelectedTrigger: Selected + m_DisabledTrigger: Disabled + m_Interactable: 1 + m_TargetGraphic: {fileID: 1485884355} + m_OnClick: + m_PersistentCalls: + m_Calls: [] +--- !u!114 &1485884355 +MonoBehaviour: + m_ObjectHideFlags: 0 + m_CorrespondingSourceObject: {fileID: 0} + m_PrefabInstance: {fileID: 0} + m_PrefabAsset: {fileID: 0} + m_GameObject: {fileID: 1485884351} + m_Enabled: 1 + m_EditorHideFlags: 0 + m_Script: {fileID: 11500000, guid: f4688fdb7df04437aeb418b961361dc5, type: 3} + m_Name: + m_EditorClassIdentifier: + m_Material: {fileID: 0} + m_Color: {r: 1, g: 1, b: 1, a: 1} + m_RaycastTarget: 1 + m_RaycastPadding: {x: 0, y: 0, z: 0, w: 0} + m_Maskable: 1 + m_OnCullStateChanged: + m_PersistentCalls: + m_Calls: [] + m_text: Local + m_isRightToLeft: 0 + m_fontAsset: {fileID: 11400000, guid: f65e20c70af9671428dd62c7c635e417, type: 2} + m_sharedMaterial: {fileID: 2100000, guid: 0e7beef0cfe7ac44cb03690b8e068c5e, type: 2} + m_fontSharedMaterials: [] + m_fontMaterial: {fileID: 0} + m_fontMaterials: [] + m_fontColor32: + serializedVersion: 2 + rgba: 4294967295 + m_fontColor: {r: 1, g: 1, b: 1, a: 1} + m_enableVertexGradient: 0 + m_colorMode: 3 + m_fontColorGradient: + topLeft: {r: 1, g: 1, b: 1, a: 1} + topRight: {r: 1, g: 1, b: 1, a: 1} + bottomLeft: {r: 1, g: 1, b: 1, a: 1} + bottomRight: {r: 1, g: 1, b: 1, a: 1} + m_fontColorGradientPreset: {fileID: 0} + m_spriteAsset: {fileID: 0} + m_tintAllSprites: 0 + m_StyleSheet: {fileID: 0} + m_TextStyleHashCode: -1183493901 + m_overrideHtmlColors: 0 + m_faceColor: + serializedVersion: 2 + rgba: 4294967295 + m_fontSize: 49.95 + m_fontSizeBase: 36 + m_fontWeight: 400 + m_enableAutoSizing: 1 + m_fontSizeMin: 18 + m_fontSizeMax: 72 + m_fontStyle: 1 + m_HorizontalAlignment: 2 + m_VerticalAlignment: 512 + m_textAlignment: 65535 + m_characterSpacing: 0 + m_wordSpacing: 0 + m_lineSpacing: 0 + m_lineSpacingMax: 0 + m_paragraphSpacing: 0 + m_charWidthMaxAdj: 0 + m_enableWordWrapping: 1 + m_wordWrappingRatios: 0.4 + m_overflowMode: 0 + m_linkedTextComponent: {fileID: 0} + parentLinkedComponent: {fileID: 0} + m_enableKerning: 1 + m_enableExtraPadding: 0 + checkPaddingRequired: 0 + m_isRichText: 1 + m_parseCtrlCharacters: 1 + m_isOrthographic: 1 + m_isCullingEnabled: 0 + m_horizontalMapping: 0 + m_verticalMapping: 0 + m_uvLineOffset: 0 + m_geometrySortingOrder: 0 + m_IsTextObjectScaleStatic: 0 + m_VertexBufferAutoSizeReduction: 1 + m_useMaxVisibleDescender: 1 + m_pageToDisplay: 1 + m_margin: {x: 0, y: 0, z: 0, w: 0} + m_isUsingLegacyAnimationComponent: 0 + m_isVolumetricText: 0 + m_hasFontAssetChanged: 0 + m_baseMaterial: {fileID: 0} + m_maskOffset: {x: 0, y: 0, z: 0, w: 0} +--- !u!222 &1485884356 +CanvasRenderer: + m_ObjectHideFlags: 0 + m_CorrespondingSourceObject: {fileID: 0} + m_PrefabInstance: {fileID: 0} + m_PrefabAsset: {fileID: 0} + m_GameObject: {fileID: 1485884351} + m_CullTransparentMesh: 0 --- !u!1 &1486694123 GameObject: m_ObjectHideFlags: 0 @@ -21525,6 +22263,162 @@ MonoBehaviour: m_Script: {fileID: 11500000, guid: 1281fe44325f9b548aa42dc331b17266, type: 3} m_Name: m_EditorClassIdentifier: +--- !u!1 &1523504651 +GameObject: + m_ObjectHideFlags: 0 + m_CorrespondingSourceObject: {fileID: 0} + m_PrefabInstance: {fileID: 0} + m_PrefabAsset: {fileID: 0} + serializedVersion: 6 + m_Component: + - component: {fileID: 1523504652} + - component: {fileID: 1523504655} + - component: {fileID: 1523504654} + - component: {fileID: 1523504653} + m_Layer: 5 + m_Name: Title + m_TagString: Untagged + m_Icon: {fileID: 0} + m_NavMeshLayer: 0 + m_StaticEditorFlags: 0 + m_IsActive: 1 +--- !u!224 &1523504652 +RectTransform: + m_ObjectHideFlags: 0 + m_CorrespondingSourceObject: {fileID: 0} + m_PrefabInstance: {fileID: 0} + m_PrefabAsset: {fileID: 0} + m_GameObject: {fileID: 1523504651} + m_LocalRotation: {x: -0, y: -0, z: -0, w: 1} + m_LocalPosition: {x: 0, y: 0, z: 0} + m_LocalScale: {x: 1, y: 1, z: 1} + m_Children: [] + m_Father: {fileID: 708838806} + m_RootOrder: 0 + m_LocalEulerAnglesHint: {x: 0, y: 0, z: 0} + m_AnchorMin: {x: 0, y: 1} + m_AnchorMax: {x: 1, y: 1} + m_AnchoredPosition: {x: 16, y: -8} + m_SizeDelta: {x: -32, y: 24} + m_Pivot: {x: 0, y: 1} +--- !u!114 &1523504653 +MonoBehaviour: + m_ObjectHideFlags: 0 + m_CorrespondingSourceObject: {fileID: 0} + m_PrefabInstance: {fileID: 0} + m_PrefabAsset: {fileID: 0} + m_GameObject: {fileID: 1523504651} + m_Enabled: 1 + m_EditorHideFlags: 0 + m_Script: {fileID: 11500000, guid: 306cc8c2b49d7114eaa3623786fc2126, type: 3} + m_Name: + m_EditorClassIdentifier: + m_IgnoreLayout: 0 + m_MinWidth: -1 + m_MinHeight: -1 + m_PreferredWidth: -1 + m_PreferredHeight: -1 + m_FlexibleWidth: 9999 + m_FlexibleHeight: -1 + m_LayoutPriority: 1 +--- !u!114 &1523504654 +MonoBehaviour: + m_ObjectHideFlags: 0 + m_CorrespondingSourceObject: {fileID: 0} + m_PrefabInstance: {fileID: 0} + m_PrefabAsset: {fileID: 0} + m_GameObject: {fileID: 1523504651} + m_Enabled: 1 + m_EditorHideFlags: 0 + m_Script: {fileID: 11500000, guid: f4688fdb7df04437aeb418b961361dc5, type: 3} + m_Name: + m_EditorClassIdentifier: + m_Material: {fileID: 0} + m_Color: {r: 1, g: 1, b: 1, a: 1} + m_RaycastTarget: 1 + m_RaycastPadding: {x: 0, y: 0, z: 0, w: 0} + m_Maskable: 1 + m_OnCullStateChanged: + m_PersistentCalls: + m_Calls: [] + m_text: Event Log + m_isRightToLeft: 0 + m_fontAsset: {fileID: 11400000, guid: 53555f7a2d5e745428813f1b1118734f, type: 2} + m_sharedMaterial: {fileID: -2804126062856497447, guid: 53555f7a2d5e745428813f1b1118734f, + type: 2} + m_fontSharedMaterials: [] + m_fontMaterial: {fileID: 0} + m_fontMaterials: [] + m_fontColor32: + serializedVersion: 2 + rgba: 4294967295 + m_fontColor: {r: 1, g: 1, b: 1, a: 1} + m_enableVertexGradient: 0 + m_colorMode: 3 + m_fontColorGradient: + topLeft: {r: 1, g: 1, b: 1, a: 1} + topRight: {r: 1, g: 1, b: 1, a: 1} + bottomLeft: {r: 1, g: 1, b: 1, a: 1} + bottomRight: {r: 1, g: 1, b: 1, a: 1} + m_fontColorGradientPreset: {fileID: 0} + m_spriteAsset: {fileID: 0} + m_tintAllSprites: 0 + m_StyleSheet: {fileID: 0} + m_TextStyleHashCode: -1183493901 + m_overrideHtmlColors: 0 + m_faceColor: + serializedVersion: 2 + rgba: 4294967295 + m_fontSize: 24 + m_fontSizeBase: 24 + m_fontWeight: 400 + m_enableAutoSizing: 0 + m_fontSizeMin: 18 + m_fontSizeMax: 72 + m_fontStyle: 0 + m_HorizontalAlignment: 2 + m_VerticalAlignment: 512 + m_textAlignment: 65535 + m_characterSpacing: 0 + m_wordSpacing: 0 + m_lineSpacing: 0 + m_lineSpacingMax: 0 + m_paragraphSpacing: 0 + m_charWidthMaxAdj: 0 + m_enableWordWrapping: 1 + m_wordWrappingRatios: 0.4 + m_overflowMode: 0 + m_linkedTextComponent: {fileID: 0} + parentLinkedComponent: {fileID: 0} + m_enableKerning: 1 + m_enableExtraPadding: 0 + checkPaddingRequired: 0 + m_isRichText: 1 + m_parseCtrlCharacters: 1 + m_isOrthographic: 1 + m_isCullingEnabled: 0 + m_horizontalMapping: 0 + m_verticalMapping: 0 + m_uvLineOffset: 0 + m_geometrySortingOrder: 0 + m_IsTextObjectScaleStatic: 0 + m_VertexBufferAutoSizeReduction: 1 + m_useMaxVisibleDescender: 1 + m_pageToDisplay: 1 + m_margin: {x: 0, y: 0, z: 0, w: 0} + m_isUsingLegacyAnimationComponent: 0 + m_isVolumetricText: 0 + m_hasFontAssetChanged: 0 + m_baseMaterial: {fileID: 0} + m_maskOffset: {x: 0, y: 0, z: 0, w: 0} +--- !u!222 &1523504655 +CanvasRenderer: + m_ObjectHideFlags: 0 + m_CorrespondingSourceObject: {fileID: 0} + m_PrefabInstance: {fileID: 0} + m_PrefabAsset: {fileID: 0} + m_GameObject: {fileID: 1523504651} + m_CullTransparentMesh: 0 --- !u!1 &1529341206 GameObject: m_ObjectHideFlags: 0 @@ -21945,7 +22839,7 @@ PrefabInstance: - target: {fileID: 878382121558056004, guid: 2758dfa2744d7ad4d8877545189d116e, type: 3} propertyPath: m_AnchoredPosition.x - value: 55.675 + value: 0 objectReference: {fileID: 0} - target: {fileID: 878382121558056004, guid: 2758dfa2744d7ad4d8877545189d116e, type: 3} @@ -23145,7 +24039,7 @@ PrefabInstance: - target: {fileID: 878382121558056004, guid: 2758dfa2744d7ad4d8877545189d116e, type: 3} propertyPath: m_AnchoredPosition.x - value: 60.98 + value: 0 objectReference: {fileID: 0} - target: {fileID: 878382121558056004, guid: 2758dfa2744d7ad4d8877545189d116e, type: 3} @@ -23817,6 +24711,83 @@ Transform: m_Father: {fileID: 1037490739} m_RootOrder: 3 m_LocalEulerAnglesHint: {x: 0, y: 0, z: 0} +--- !u!1 &1648604380 +GameObject: + m_ObjectHideFlags: 0 + m_CorrespondingSourceObject: {fileID: 0} + m_PrefabInstance: {fileID: 0} + m_PrefabAsset: {fileID: 0} + serializedVersion: 6 + m_Component: + - component: {fileID: 1648604381} + - component: {fileID: 1648604383} + - component: {fileID: 1648604382} + m_Layer: 5 + m_Name: Scroll View + m_TagString: Untagged + m_Icon: {fileID: 0} + m_NavMeshLayer: 0 + m_StaticEditorFlags: 0 + m_IsActive: 1 +--- !u!224 &1648604381 +RectTransform: + m_ObjectHideFlags: 0 + m_CorrespondingSourceObject: {fileID: 0} + m_PrefabInstance: {fileID: 0} + m_PrefabAsset: {fileID: 0} + m_GameObject: {fileID: 1648604380} + m_LocalRotation: {x: -0, y: -0, z: -0, w: 1} + m_LocalPosition: {x: 0, y: 0, z: 0} + m_LocalScale: {x: 1, y: 1, z: 1} + m_Children: + - {fileID: 1115501495} + - {fileID: 776899542} + m_Father: {fileID: 708838806} + m_RootOrder: 2 + m_LocalEulerAnglesHint: {x: 0, y: 0, z: 0} + m_AnchorMin: {x: 0, y: 0} + m_AnchorMax: {x: 1, y: 1} + m_AnchoredPosition: {x: 0, y: -20.5} + m_SizeDelta: {x: 0, y: -49} + m_Pivot: {x: 0.5, y: 0.5} +--- !u!222 &1648604382 +CanvasRenderer: + m_ObjectHideFlags: 0 + m_CorrespondingSourceObject: {fileID: 0} + m_PrefabInstance: {fileID: 0} + m_PrefabAsset: {fileID: 0} + m_GameObject: {fileID: 1648604380} + m_CullTransparentMesh: 0 +--- !u!114 &1648604383 +MonoBehaviour: + m_ObjectHideFlags: 0 + m_CorrespondingSourceObject: {fileID: 0} + m_PrefabInstance: {fileID: 0} + m_PrefabAsset: {fileID: 0} + m_GameObject: {fileID: 1648604380} + m_Enabled: 1 + m_EditorHideFlags: 0 + m_Script: {fileID: 11500000, guid: 1aa08ab6e0800fa44ae55d278d1423e3, type: 3} + m_Name: + m_EditorClassIdentifier: + m_Content: {fileID: 1225245880} + m_Horizontal: 0 + m_Vertical: 1 + m_MovementType: 2 + m_Elasticity: 0.1 + m_Inertia: 1 + m_DecelerationRate: 0.135 + m_ScrollSensitivity: 10 + m_Viewport: {fileID: 1115501495} + m_HorizontalScrollbar: {fileID: 0} + m_VerticalScrollbar: {fileID: 776899543} + m_HorizontalScrollbarVisibility: 0 + m_VerticalScrollbarVisibility: 2 + m_HorizontalScrollbarSpacing: -3 + m_VerticalScrollbarSpacing: -3 + m_OnValueChanged: + m_PersistentCalls: + m_Calls: [] --- !u!1 &1665127615 GameObject: m_ObjectHideFlags: 0 @@ -24561,6 +25532,7 @@ RectTransform: m_LocalPosition: {x: 0, y: 0, z: 0} m_LocalScale: {x: 1, y: 1, z: 1} m_Children: + - {fileID: 14255052} - {fileID: 1997243493} - {fileID: 630131159} - {fileID: 522642868} @@ -25334,12 +26306,13 @@ RectTransform: m_LocalPosition: {x: 0, y: 0, z: 0} m_LocalScale: {x: 1, y: 1, z: 1} m_Children: + - {fileID: 1485884352} - {fileID: 101395090} - {fileID: 1464157085} - {fileID: 931657851} - {fileID: 1399108418} m_Father: {fileID: 1726632265} - m_RootOrder: 4 + m_RootOrder: 5 m_LocalEulerAnglesHint: {x: 0, y: 0, z: 0} m_AnchorMin: {x: 0, y: 1} m_AnchorMax: {x: 1, y: 1} @@ -26155,6 +27128,81 @@ CanvasRenderer: m_PrefabAsset: {fileID: 0} m_GameObject: {fileID: 1850578694} m_CullTransparentMesh: 0 +--- !u!1 &1852331623 +GameObject: + m_ObjectHideFlags: 0 + m_CorrespondingSourceObject: {fileID: 0} + m_PrefabInstance: {fileID: 0} + m_PrefabAsset: {fileID: 0} + serializedVersion: 6 + m_Component: + - component: {fileID: 1852331624} + - component: {fileID: 1852331626} + - component: {fileID: 1852331625} + m_Layer: 5 + m_Name: Handle + m_TagString: Untagged + m_Icon: {fileID: 0} + m_NavMeshLayer: 0 + m_StaticEditorFlags: 0 + m_IsActive: 1 +--- !u!224 &1852331624 +RectTransform: + m_ObjectHideFlags: 0 + m_CorrespondingSourceObject: {fileID: 0} + m_PrefabInstance: {fileID: 0} + m_PrefabAsset: {fileID: 0} + m_GameObject: {fileID: 1852331623} + m_LocalRotation: {x: 0, y: 0, z: 0, w: 1} + m_LocalPosition: {x: 0, y: 0, z: 0} + m_LocalScale: {x: 1, y: 1, z: 1} + m_Children: [] + m_Father: {fileID: 1036871929} + m_RootOrder: 0 + m_LocalEulerAnglesHint: {x: 0, y: 0, z: 0} + m_AnchorMin: {x: 0, y: 0} + m_AnchorMax: {x: 1, y: 1} + m_AnchoredPosition: {x: 0, y: 0} + m_SizeDelta: {x: 20, y: 20} + m_Pivot: {x: 0.5, y: 0.5} +--- !u!114 &1852331625 +MonoBehaviour: + m_ObjectHideFlags: 0 + m_CorrespondingSourceObject: {fileID: 0} + m_PrefabInstance: {fileID: 0} + m_PrefabAsset: {fileID: 0} + m_GameObject: {fileID: 1852331623} + m_Enabled: 1 + m_EditorHideFlags: 0 + m_Script: {fileID: 11500000, guid: fe87c0e1cc204ed48ad3b37840f39efc, type: 3} + m_Name: + m_EditorClassIdentifier: + m_Material: {fileID: 0} + m_Color: {r: 1, g: 0.44583336, b: 0.050000012, a: 0.65882355} + m_RaycastTarget: 1 + m_RaycastPadding: {x: 0, y: 0, z: 0, w: 0} + m_Maskable: 1 + m_OnCullStateChanged: + m_PersistentCalls: + m_Calls: [] + m_Sprite: {fileID: 21300000, guid: 7ed12bf887e951949bd02894a21fb3ff, type: 3} + m_Type: 1 + m_PreserveAspect: 0 + m_FillCenter: 1 + m_FillMethod: 4 + m_FillAmount: 1 + m_FillClockwise: 1 + m_FillOrigin: 0 + m_UseSpriteMesh: 0 + m_PixelsPerUnitMultiplier: 1 +--- !u!222 &1852331626 +CanvasRenderer: + m_ObjectHideFlags: 0 + m_CorrespondingSourceObject: {fileID: 0} + m_PrefabInstance: {fileID: 0} + m_PrefabAsset: {fileID: 0} + m_GameObject: {fileID: 1852331623} + m_CullTransparentMesh: 0 --- !u!1 &1857285684 GameObject: m_ObjectHideFlags: 0 @@ -26251,6 +27299,50 @@ MeshFilter: m_PrefabAsset: {fileID: 0} m_GameObject: {fileID: 1857285684} m_Mesh: {fileID: 10210, guid: 0000000000000000e000000000000000, type: 0} +--- !u!1 &1863046923 +GameObject: + m_ObjectHideFlags: 0 + m_CorrespondingSourceObject: {fileID: 0} + m_PrefabInstance: {fileID: 0} + m_PrefabAsset: {fileID: 0} + serializedVersion: 6 + m_Component: + - component: {fileID: 1863046924} + - component: {fileID: 1863046925} + m_Layer: 5 + m_Name: TMP SubMeshUI [UbuntuMono-R SDF + LiberationSans SDF Atlas] + m_TagString: Untagged + m_Icon: {fileID: 0} + m_NavMeshLayer: 0 + m_StaticEditorFlags: 0 + m_IsActive: 1 +--- !u!224 &1863046924 +RectTransform: + m_ObjectHideFlags: 0 + m_CorrespondingSourceObject: {fileID: 0} + m_PrefabInstance: {fileID: 0} + m_PrefabAsset: {fileID: 0} + m_GameObject: {fileID: 1863046923} + m_LocalRotation: {x: 0, y: 0, z: 0, w: 1} + m_LocalPosition: {x: 0, y: 0, z: 0} + m_LocalScale: {x: 1, y: 1, z: 1} + m_Children: [] + m_Father: {fileID: 2118604529} + m_RootOrder: 0 + m_LocalEulerAnglesHint: {x: 0, y: 0, z: 0} + m_AnchorMin: {x: 0, y: 0} + m_AnchorMax: {x: 1, y: 1} + m_AnchoredPosition: {x: 0, y: 0} + m_SizeDelta: {x: 0, y: 0} + m_Pivot: {x: 0.5, y: 0.5} +--- !u!222 &1863046925 +CanvasRenderer: + m_ObjectHideFlags: 0 + m_CorrespondingSourceObject: {fileID: 0} + m_PrefabInstance: {fileID: 0} + m_PrefabAsset: {fileID: 0} + m_GameObject: {fileID: 1863046923} + m_CullTransparentMesh: 0 --- !u!1 &1868140980 GameObject: m_ObjectHideFlags: 0 @@ -27457,7 +28549,7 @@ RectTransform: - {fileID: 7399108074413661591} - {fileID: 245842385} m_Father: {fileID: 1726632265} - m_RootOrder: 0 + m_RootOrder: 1 m_LocalEulerAnglesHint: {x: 0, y: 0, z: 0} m_AnchorMin: {x: 0, y: 0} m_AnchorMax: {x: 1, y: 1} @@ -27868,7 +28960,7 @@ RectTransform: - {fileID: 1998350929} - {fileID: 1005841432} m_Father: {fileID: 1726632265} - m_RootOrder: 3 + m_RootOrder: 4 m_LocalEulerAnglesHint: {x: 0, y: 0, z: 0} m_AnchorMin: {x: 0, y: 0} m_AnchorMax: {x: 1, y: 1} @@ -28877,6 +29969,184 @@ MonoBehaviour: m_Script: {fileID: 11500000, guid: 1281fe44325f9b548aa42dc331b17266, type: 3} m_Name: m_EditorClassIdentifier: +--- !u!1 &2118604528 +GameObject: + m_ObjectHideFlags: 0 + m_CorrespondingSourceObject: {fileID: 0} + m_PrefabInstance: {fileID: 0} + m_PrefabAsset: {fileID: 0} + serializedVersion: 6 + m_Component: + - component: {fileID: 2118604529} + - component: {fileID: 2118604533} + - component: {fileID: 2118604532} + - component: {fileID: 2118604531} + - component: {fileID: 2118604530} + m_Layer: 5 + m_Name: History + m_TagString: Untagged + m_Icon: {fileID: 0} + m_NavMeshLayer: 0 + m_StaticEditorFlags: 0 + m_IsActive: 1 +--- !u!224 &2118604529 +RectTransform: + m_ObjectHideFlags: 0 + m_CorrespondingSourceObject: {fileID: 0} + m_PrefabInstance: {fileID: 0} + m_PrefabAsset: {fileID: 0} + m_GameObject: {fileID: 2118604528} + m_LocalRotation: {x: -0, y: -0, z: -0, w: 1} + m_LocalPosition: {x: 0, y: 0, z: 0} + m_LocalScale: {x: 1, y: 1, z: 1} + m_Children: + - {fileID: 1863046924} + m_Father: {fileID: 1225245880} + m_RootOrder: 0 + m_LocalEulerAnglesHint: {x: 0, y: 0, z: 0} + m_AnchorMin: {x: 0, y: 1} + m_AnchorMax: {x: 0, y: 1} + m_AnchoredPosition: {x: 558.5, y: -134.005} + m_SizeDelta: {x: 1101, y: 252.01} + m_Pivot: {x: 0.5, y: 0.5} +--- !u!114 &2118604530 +MonoBehaviour: + m_ObjectHideFlags: 0 + m_CorrespondingSourceObject: {fileID: 0} + m_PrefabInstance: {fileID: 0} + m_PrefabAsset: {fileID: 0} + m_GameObject: {fileID: 2118604528} + m_Enabled: 1 + m_EditorHideFlags: 0 + m_Script: {fileID: 11500000, guid: 3245ec927659c4140ac4f8d17403cc18, type: 3} + m_Name: + m_EditorClassIdentifier: + m_HorizontalFit: 0 + m_VerticalFit: 2 +--- !u!114 &2118604531 +MonoBehaviour: + m_ObjectHideFlags: 0 + m_CorrespondingSourceObject: {fileID: 0} + m_PrefabInstance: {fileID: 0} + m_PrefabAsset: {fileID: 0} + m_GameObject: {fileID: 2118604528} + m_Enabled: 1 + m_EditorHideFlags: 0 + m_Script: {fileID: 11500000, guid: 306cc8c2b49d7114eaa3623786fc2126, type: 3} + m_Name: + m_EditorClassIdentifier: + m_IgnoreLayout: 0 + m_MinWidth: -1 + m_MinHeight: -1 + m_PreferredWidth: -1 + m_PreferredHeight: -1 + m_FlexibleWidth: -1 + m_FlexibleHeight: -1 + m_LayoutPriority: 1 +--- !u!114 &2118604532 +MonoBehaviour: + m_ObjectHideFlags: 0 + m_CorrespondingSourceObject: {fileID: 0} + m_PrefabInstance: {fileID: 0} + m_PrefabAsset: {fileID: 0} + m_GameObject: {fileID: 2118604528} + m_Enabled: 1 + m_EditorHideFlags: 0 + m_Script: {fileID: 11500000, guid: f4688fdb7df04437aeb418b961361dc5, type: 3} + m_Name: + m_EditorClassIdentifier: + m_Material: {fileID: 0} + m_Color: {r: 1, g: 1, b: 1, a: 1} + m_RaycastTarget: 1 + m_RaycastPadding: {x: 0, y: 0, z: 0, w: 0} + m_Maskable: 1 + m_OnCullStateChanged: + m_PersistentCalls: + m_Calls: [] + m_text: "What the fuck did you just fucking type about me, you little bitch? I\u2019ll + have you know I graduated top of my class at MIT, and I\u2019ve been involved + in numerous secret raids with Anonymous, and I have over 300 confirmed DDoSes.\n\nI + am trained in online trolling and I\u2019m the top hacker in the entire world. + You are nothing to me but just another virus host. I will wipe you the fuck out + with precision the likes of which has never been seen before on the Internet, + mark my fucking words. You think you can get away with typing that shit to me + over the Internet? Think again, fucker." + m_isRightToLeft: 0 + m_fontAsset: {fileID: 11400000, guid: 3fb7d873bb5a7944bb9a7c73c430c44b, type: 2} + m_sharedMaterial: {fileID: 2100000, guid: b9d2f6c9804cec1489502dcc1c19ec54, type: 2} + m_fontSharedMaterials: [] + m_fontMaterial: {fileID: 0} + m_fontMaterials: [] + m_fontColor32: + serializedVersion: 2 + rgba: 4294967295 + m_fontColor: {r: 1, g: 1, b: 1, a: 1} + m_enableVertexGradient: 0 + m_colorMode: 3 + m_fontColorGradient: + topLeft: {r: 1, g: 1, b: 1, a: 1} + topRight: {r: 1, g: 1, b: 1, a: 1} + bottomLeft: {r: 1, g: 1, b: 1, a: 1} + bottomRight: {r: 1, g: 1, b: 1, a: 1} + m_fontColorGradientPreset: {fileID: 0} + m_spriteAsset: {fileID: 0} + m_tintAllSprites: 0 + m_StyleSheet: {fileID: 0} + m_TextStyleHashCode: -1183493901 + m_overrideHtmlColors: 0 + m_faceColor: + serializedVersion: 2 + rgba: 4294967295 + m_fontSize: 28 + m_fontSizeBase: 28 + m_fontWeight: 400 + m_enableAutoSizing: 0 + m_fontSizeMin: 18 + m_fontSizeMax: 72 + m_fontStyle: 0 + m_HorizontalAlignment: 1 + m_VerticalAlignment: 256 + m_textAlignment: 65535 + m_characterSpacing: 0 + m_wordSpacing: 0 + m_lineSpacing: 0 + m_lineSpacingMax: 0 + m_paragraphSpacing: 0 + m_charWidthMaxAdj: 0 + m_enableWordWrapping: 1 + m_wordWrappingRatios: 0.4 + m_overflowMode: 0 + m_linkedTextComponent: {fileID: 0} + parentLinkedComponent: {fileID: 0} + m_enableKerning: 1 + m_enableExtraPadding: 0 + checkPaddingRequired: 0 + m_isRichText: 1 + m_parseCtrlCharacters: 1 + m_isOrthographic: 1 + m_isCullingEnabled: 0 + m_horizontalMapping: 0 + m_verticalMapping: 0 + m_uvLineOffset: 0 + m_geometrySortingOrder: 0 + m_IsTextObjectScaleStatic: 0 + m_VertexBufferAutoSizeReduction: 1 + m_useMaxVisibleDescender: 1 + m_pageToDisplay: 1 + m_margin: {x: 0, y: 0, z: 0, w: 0} + m_isUsingLegacyAnimationComponent: 0 + m_isVolumetricText: 0 + m_hasFontAssetChanged: 0 + m_baseMaterial: {fileID: 0} + m_maskOffset: {x: 0, y: 0, z: 0, w: 0} +--- !u!222 &2118604533 +CanvasRenderer: + m_ObjectHideFlags: 0 + m_CorrespondingSourceObject: {fileID: 0} + m_PrefabInstance: {fileID: 0} + m_PrefabAsset: {fileID: 0} + m_GameObject: {fileID: 2118604528} + m_CullTransparentMesh: 0 --- !u!1 &2122035459 GameObject: m_ObjectHideFlags: 0 @@ -33242,6 +34512,456 @@ CanvasRenderer: m_PrefabAsset: {fileID: 0} m_GameObject: {fileID: 7234671467082970194} m_CullTransparentMesh: 0 +--- !u!114 &3408386362260095380 +MonoBehaviour: + m_ObjectHideFlags: 0 + m_CorrespondingSourceObject: {fileID: 0} + m_PrefabInstance: {fileID: 0} + m_PrefabAsset: {fileID: 0} + m_GameObject: {fileID: 3408386362260095383} + m_Enabled: 1 + m_EditorHideFlags: 0 + m_Script: {fileID: 11500000, guid: 3245ec927659c4140ac4f8d17403cc18, type: 3} + m_Name: + m_EditorClassIdentifier: + m_HorizontalFit: 0 + m_VerticalFit: 2 +--- !u!114 &3408386362260095381 +MonoBehaviour: + m_ObjectHideFlags: 0 + m_CorrespondingSourceObject: {fileID: 0} + m_PrefabInstance: {fileID: 0} + m_PrefabAsset: {fileID: 0} + m_GameObject: {fileID: 3408386362260095383} + m_Enabled: 1 + m_EditorHideFlags: 0 + m_Script: {fileID: 11500000, guid: 59f8146938fff824cb5fd77236b75775, type: 3} + m_Name: + m_EditorClassIdentifier: + m_Padding: + m_Left: 8 + m_Right: 8 + m_Top: 8 + m_Bottom: 8 + m_ChildAlignment: 0 + m_Spacing: 4 + m_ChildForceExpandWidth: 1 + m_ChildForceExpandHeight: 0 + m_ChildControlWidth: 1 + m_ChildControlHeight: 1 + m_ChildScaleWidth: 0 + m_ChildScaleHeight: 0 + m_ReverseArrangement: 0 +--- !u!224 &3408386362260095382 +RectTransform: + m_ObjectHideFlags: 0 + m_CorrespondingSourceObject: {fileID: 0} + m_PrefabInstance: {fileID: 0} + m_PrefabAsset: {fileID: 0} + m_GameObject: {fileID: 3408386362260095383} + m_LocalRotation: {x: 0, y: 0, z: 0, w: 1} + m_LocalPosition: {x: 0, y: 0, z: 0} + m_LocalScale: {x: 1, y: 1, z: 1} + m_Children: [] + m_Father: {fileID: 3408386362832899666} + m_RootOrder: 0 + m_LocalEulerAnglesHint: {x: 0, y: 0, z: 0} + m_AnchorMin: {x: 0, y: 0} + m_AnchorMax: {x: 1, y: 1} + m_AnchoredPosition: {x: 4, y: 0} + m_SizeDelta: {x: -8, y: -583} + m_Pivot: {x: 0, y: 1} +--- !u!1 &3408386362260095383 +GameObject: + m_ObjectHideFlags: 0 + m_CorrespondingSourceObject: {fileID: 0} + m_PrefabInstance: {fileID: 0} + m_PrefabAsset: {fileID: 0} + serializedVersion: 6 + m_Component: + - component: {fileID: 3408386362260095382} + - component: {fileID: 3408386362260095381} + - component: {fileID: 3408386362260095380} + m_Layer: 5 + m_Name: Content + m_TagString: Untagged + m_Icon: {fileID: 0} + m_NavMeshLayer: 0 + m_StaticEditorFlags: 0 + m_IsActive: 1 +--- !u!1 &3408386362298136552 +GameObject: + m_ObjectHideFlags: 0 + m_CorrespondingSourceObject: {fileID: 0} + m_PrefabInstance: {fileID: 0} + m_PrefabAsset: {fileID: 0} + serializedVersion: 6 + m_Component: + - component: {fileID: 3408386362298136559} + - component: {fileID: 3408386362298136557} + - component: {fileID: 3408386362298136558} + m_Layer: 5 + m_Name: Handle + m_TagString: Untagged + m_Icon: {fileID: 0} + m_NavMeshLayer: 0 + m_StaticEditorFlags: 0 + m_IsActive: 1 +--- !u!222 &3408386362298136557 +CanvasRenderer: + m_ObjectHideFlags: 0 + m_CorrespondingSourceObject: {fileID: 0} + m_PrefabInstance: {fileID: 0} + m_PrefabAsset: {fileID: 0} + m_GameObject: {fileID: 3408386362298136552} + m_CullTransparentMesh: 0 +--- !u!114 &3408386362298136558 +MonoBehaviour: + m_ObjectHideFlags: 0 + m_CorrespondingSourceObject: {fileID: 0} + m_PrefabInstance: {fileID: 0} + m_PrefabAsset: {fileID: 0} + m_GameObject: {fileID: 3408386362298136552} + m_Enabled: 1 + m_EditorHideFlags: 0 + m_Script: {fileID: 11500000, guid: fe87c0e1cc204ed48ad3b37840f39efc, type: 3} + m_Name: + m_EditorClassIdentifier: + m_Material: {fileID: 0} + m_Color: {r: 1, g: 0.44583336, b: 0.050000012, a: 0.65882355} + m_RaycastTarget: 1 + m_RaycastPadding: {x: 0, y: 0, z: 0, w: 0} + m_Maskable: 1 + m_OnCullStateChanged: + m_PersistentCalls: + m_Calls: [] + m_Sprite: {fileID: 21300000, guid: 7ed12bf887e951949bd02894a21fb3ff, type: 3} + m_Type: 1 + m_PreserveAspect: 0 + m_FillCenter: 1 + m_FillMethod: 4 + m_FillAmount: 1 + m_FillClockwise: 1 + m_FillOrigin: 0 + m_UseSpriteMesh: 0 + m_PixelsPerUnitMultiplier: 1 +--- !u!224 &3408386362298136559 +RectTransform: + m_ObjectHideFlags: 0 + m_CorrespondingSourceObject: {fileID: 0} + m_PrefabInstance: {fileID: 0} + m_PrefabAsset: {fileID: 0} + m_GameObject: {fileID: 3408386362298136552} + m_LocalRotation: {x: 0, y: 0, z: 0, w: 1} + m_LocalPosition: {x: 0, y: 0, z: 0} + m_LocalScale: {x: 1, y: 1, z: 1} + m_Children: [] + m_Father: {fileID: 3408386363387120877} + m_RootOrder: 0 + m_LocalEulerAnglesHint: {x: 0, y: 0, z: 0} + m_AnchorMin: {x: 0, y: 0} + m_AnchorMax: {x: 1, y: 1} + m_AnchoredPosition: {x: 0, y: 0} + m_SizeDelta: {x: 20, y: 20} + m_Pivot: {x: 0.5, y: 0.5} +--- !u!222 &3408386362832899664 +CanvasRenderer: + m_ObjectHideFlags: 0 + m_CorrespondingSourceObject: {fileID: 0} + m_PrefabInstance: {fileID: 0} + m_PrefabAsset: {fileID: 0} + m_GameObject: {fileID: 3408386362832899667} + m_CullTransparentMesh: 0 +--- !u!114 &3408386362832899665 +MonoBehaviour: + m_ObjectHideFlags: 0 + m_CorrespondingSourceObject: {fileID: 0} + m_PrefabInstance: {fileID: 0} + m_PrefabAsset: {fileID: 0} + m_GameObject: {fileID: 3408386362832899667} + m_Enabled: 1 + m_EditorHideFlags: 0 + m_Script: {fileID: 11500000, guid: fe87c0e1cc204ed48ad3b37840f39efc, type: 3} + m_Name: + m_EditorClassIdentifier: + m_Material: {fileID: 0} + m_Color: {r: 1, g: 1, b: 1, a: 1} + m_RaycastTarget: 1 + m_RaycastPadding: {x: 0, y: 0, z: 0, w: 0} + m_Maskable: 1 + m_OnCullStateChanged: + m_PersistentCalls: + m_Calls: [] + m_Sprite: {fileID: 10917, guid: 0000000000000000f000000000000000, type: 0} + m_Type: 1 + m_PreserveAspect: 0 + m_FillCenter: 1 + m_FillMethod: 4 + m_FillAmount: 1 + m_FillClockwise: 1 + m_FillOrigin: 0 + m_UseSpriteMesh: 0 + m_PixelsPerUnitMultiplier: 1 +--- !u!224 &3408386362832899666 +RectTransform: + m_ObjectHideFlags: 0 + m_CorrespondingSourceObject: {fileID: 0} + m_PrefabInstance: {fileID: 0} + m_PrefabAsset: {fileID: 0} + m_GameObject: {fileID: 3408386362832899667} + m_LocalRotation: {x: 0, y: 0, z: 0, w: 1} + m_LocalPosition: {x: 0, y: 0, z: 0} + m_LocalScale: {x: 1, y: 1, z: 1} + m_Children: + - {fileID: 3408386362260095382} + m_Father: {fileID: 3408386364042537272} + m_RootOrder: 0 + m_LocalEulerAnglesHint: {x: 0, y: 0, z: 0} + m_AnchorMin: {x: 0, y: 0} + m_AnchorMax: {x: 1, y: 1} + m_AnchoredPosition: {x: 0, y: 0} + m_SizeDelta: {x: -7, y: 0} + m_Pivot: {x: 0, y: 1} +--- !u!1 &3408386362832899667 +GameObject: + m_ObjectHideFlags: 0 + m_CorrespondingSourceObject: {fileID: 0} + m_PrefabInstance: {fileID: 0} + m_PrefabAsset: {fileID: 0} + serializedVersion: 6 + m_Component: + - component: {fileID: 3408386362832899666} + - component: {fileID: 3408386362832899671} + - component: {fileID: 3408386362832899664} + - component: {fileID: 3408386362832899665} + m_Layer: 5 + m_Name: Viewport + m_TagString: Untagged + m_Icon: {fileID: 0} + m_NavMeshLayer: 0 + m_StaticEditorFlags: 0 + m_IsActive: 1 +--- !u!114 &3408386362832899671 +MonoBehaviour: + m_ObjectHideFlags: 0 + m_CorrespondingSourceObject: {fileID: 0} + m_PrefabInstance: {fileID: 0} + m_PrefabAsset: {fileID: 0} + m_GameObject: {fileID: 3408386362832899667} + m_Enabled: 1 + m_EditorHideFlags: 0 + m_Script: {fileID: 11500000, guid: 31a19414c41e5ae4aae2af33fee712f6, type: 3} + m_Name: + m_EditorClassIdentifier: + m_ShowMaskGraphic: 0 +--- !u!224 &3408386363387120877 +RectTransform: + m_ObjectHideFlags: 0 + m_CorrespondingSourceObject: {fileID: 0} + m_PrefabInstance: {fileID: 0} + m_PrefabAsset: {fileID: 0} + m_GameObject: {fileID: 3408386363387120878} + m_LocalRotation: {x: 0, y: 0, z: 0, w: 1} + m_LocalPosition: {x: 0, y: 0, z: 0} + m_LocalScale: {x: 1, y: 1, z: 1} + m_Children: + - {fileID: 3408386362298136559} + m_Father: {fileID: 3408386364039715001} + m_RootOrder: 0 + m_LocalEulerAnglesHint: {x: 0, y: 0, z: 0} + m_AnchorMin: {x: 0, y: 0} + m_AnchorMax: {x: 1, y: 1} + m_AnchoredPosition: {x: 0, y: 0} + m_SizeDelta: {x: -20, y: -20} + m_Pivot: {x: 0.5, y: 0.5} +--- !u!1 &3408386363387120878 +GameObject: + m_ObjectHideFlags: 0 + m_CorrespondingSourceObject: {fileID: 0} + m_PrefabInstance: {fileID: 0} + m_PrefabAsset: {fileID: 0} + serializedVersion: 6 + m_Component: + - component: {fileID: 3408386363387120877} + m_Layer: 5 + m_Name: Sliding Area + m_TagString: Untagged + m_Icon: {fileID: 0} + m_NavMeshLayer: 0 + m_StaticEditorFlags: 0 + m_IsActive: 1 +--- !u!114 &3408386364039715000 +MonoBehaviour: + m_ObjectHideFlags: 0 + m_CorrespondingSourceObject: {fileID: 0} + m_PrefabInstance: {fileID: 0} + m_PrefabAsset: {fileID: 0} + m_GameObject: {fileID: 3408386364039715002} + m_Enabled: 1 + m_EditorHideFlags: 0 + m_Script: {fileID: 11500000, guid: 2a4db7a114972834c8e4117be1d82ba3, type: 3} + m_Name: + m_EditorClassIdentifier: + m_Navigation: + m_Mode: 3 + m_WrapAround: 0 + m_SelectOnUp: {fileID: 0} + m_SelectOnDown: {fileID: 0} + m_SelectOnLeft: {fileID: 0} + m_SelectOnRight: {fileID: 0} + m_Transition: 1 + m_Colors: + m_NormalColor: {r: 1, g: 1, b: 1, a: 1} + m_HighlightedColor: {r: 0.9607843, g: 0.9607843, b: 0.9607843, a: 1} + m_PressedColor: {r: 0.78431374, g: 0.78431374, b: 0.78431374, a: 1} + m_SelectedColor: {r: 0.9607843, g: 0.9607843, b: 0.9607843, a: 1} + m_DisabledColor: {r: 0.78431374, g: 0.78431374, b: 0.78431374, a: 0.5019608} + m_ColorMultiplier: 1 + m_FadeDuration: 0.1 + m_SpriteState: + m_HighlightedSprite: {fileID: 0} + m_PressedSprite: {fileID: 0} + m_SelectedSprite: {fileID: 0} + m_DisabledSprite: {fileID: 0} + m_AnimationTriggers: + m_NormalTrigger: Normal + m_HighlightedTrigger: Highlighted + m_PressedTrigger: Pressed + m_SelectedTrigger: Highlighted + m_DisabledTrigger: Disabled + m_Interactable: 1 + m_TargetGraphic: {fileID: 3408386362298136558} + m_HandleRect: {fileID: 3408386362298136559} + m_Direction: 2 + m_Value: 0 + m_Size: 1 + m_NumberOfSteps: 0 + m_OnValueChanged: + m_PersistentCalls: + m_Calls: [] +--- !u!224 &3408386364039715001 +RectTransform: + m_ObjectHideFlags: 0 + m_CorrespondingSourceObject: {fileID: 0} + m_PrefabInstance: {fileID: 0} + m_PrefabAsset: {fileID: 0} + m_GameObject: {fileID: 3408386364039715002} + m_LocalRotation: {x: 0, y: 0, z: 0, w: 1} + m_LocalPosition: {x: 0, y: 0, z: 0} + m_LocalScale: {x: 1, y: 1, z: 1} + m_Children: + - {fileID: 3408386363387120877} + m_Father: {fileID: 3408386364042537272} + m_RootOrder: 1 + m_LocalEulerAnglesHint: {x: 0, y: 0, z: 0} + m_AnchorMin: {x: 1, y: 0} + m_AnchorMax: {x: 1, y: 1} + m_AnchoredPosition: {x: 0, y: 0} + m_SizeDelta: {x: 10, y: 0} + m_Pivot: {x: 1, y: 1} +--- !u!1 &3408386364039715002 +GameObject: + m_ObjectHideFlags: 0 + m_CorrespondingSourceObject: {fileID: 0} + m_PrefabInstance: {fileID: 0} + m_PrefabAsset: {fileID: 0} + serializedVersion: 6 + m_Component: + - component: {fileID: 3408386364039715001} + - component: {fileID: 3408386364039715006} + - component: {fileID: 3408386364039715000} + m_Layer: 5 + m_Name: Scrollbar Vertical + m_TagString: Untagged + m_Icon: {fileID: 0} + m_NavMeshLayer: 0 + m_StaticEditorFlags: 0 + m_IsActive: 1 +--- !u!222 &3408386364039715006 +CanvasRenderer: + m_ObjectHideFlags: 0 + m_CorrespondingSourceObject: {fileID: 0} + m_PrefabInstance: {fileID: 0} + m_PrefabAsset: {fileID: 0} + m_GameObject: {fileID: 3408386364039715002} + m_CullTransparentMesh: 0 +--- !u!224 &3408386364042537272 +RectTransform: + m_ObjectHideFlags: 0 + m_CorrespondingSourceObject: {fileID: 0} + m_PrefabInstance: {fileID: 0} + m_PrefabAsset: {fileID: 0} + m_GameObject: {fileID: 3408386364042537273} + m_LocalRotation: {x: -0, y: -0, z: -0, w: 1} + m_LocalPosition: {x: 0, y: 0, z: 0} + m_LocalScale: {x: 1, y: 1, z: 1} + m_Children: + - {fileID: 3408386362832899666} + - {fileID: 3408386364039715001} + m_Father: {fileID: 5630987214048981317} + m_RootOrder: 2 + m_LocalEulerAnglesHint: {x: 0, y: 0, z: 0} + m_AnchorMin: {x: 0, y: 0} + m_AnchorMax: {x: 1, y: 1} + m_AnchoredPosition: {x: 0, y: -20.5} + m_SizeDelta: {x: 0, y: -49} + m_Pivot: {x: 0.5, y: 0.5} +--- !u!1 &3408386364042537273 +GameObject: + m_ObjectHideFlags: 0 + m_CorrespondingSourceObject: {fileID: 0} + m_PrefabInstance: {fileID: 0} + m_PrefabAsset: {fileID: 0} + serializedVersion: 6 + m_Component: + - component: {fileID: 3408386364042537272} + - component: {fileID: 3408386364042537277} + - component: {fileID: 3408386364042537279} + m_Layer: 5 + m_Name: Scroll View + m_TagString: Untagged + m_Icon: {fileID: 0} + m_NavMeshLayer: 0 + m_StaticEditorFlags: 0 + m_IsActive: 1 +--- !u!114 &3408386364042537277 +MonoBehaviour: + m_ObjectHideFlags: 0 + m_CorrespondingSourceObject: {fileID: 0} + m_PrefabInstance: {fileID: 0} + m_PrefabAsset: {fileID: 0} + m_GameObject: {fileID: 3408386364042537273} + m_Enabled: 1 + m_EditorHideFlags: 0 + m_Script: {fileID: 11500000, guid: 1aa08ab6e0800fa44ae55d278d1423e3, type: 3} + m_Name: + m_EditorClassIdentifier: + m_Content: {fileID: 3408386362260095382} + m_Horizontal: 0 + m_Vertical: 1 + m_MovementType: 2 + m_Elasticity: 0.1 + m_Inertia: 1 + m_DecelerationRate: 0.135 + m_ScrollSensitivity: 10 + m_Viewport: {fileID: 3408386362832899666} + m_HorizontalScrollbar: {fileID: 0} + m_VerticalScrollbar: {fileID: 3408386364039715000} + m_HorizontalScrollbarVisibility: 0 + m_VerticalScrollbarVisibility: 2 + m_HorizontalScrollbarSpacing: -3 + m_VerticalScrollbarSpacing: -3 + m_OnValueChanged: + m_PersistentCalls: + m_Calls: [] +--- !u!222 &3408386364042537279 +CanvasRenderer: + m_ObjectHideFlags: 0 + m_CorrespondingSourceObject: {fileID: 0} + m_PrefabInstance: {fileID: 0} + m_PrefabAsset: {fileID: 0} + m_GameObject: {fileID: 3408386364042537273} + m_CullTransparentMesh: 0 --- !u!114 &3792548363175711565 MonoBehaviour: m_ObjectHideFlags: 0 @@ -33661,6 +35381,316 @@ RectTransform: m_AnchoredPosition: {x: 0, y: -40} m_SizeDelta: {x: 0, y: 3} m_Pivot: {x: 0.5, y: 0.5} +--- !u!1 &5630987212537872480 +GameObject: + m_ObjectHideFlags: 0 + m_CorrespondingSourceObject: {fileID: 0} + m_PrefabInstance: {fileID: 0} + m_PrefabAsset: {fileID: 0} + serializedVersion: 6 + m_Component: + - component: {fileID: 5630987212537872481} + - component: {fileID: 5630987212537872484} + - component: {fileID: 5630987212537872483} + - component: {fileID: 5630987212537872482} + m_Layer: 5 + m_Name: Divider + m_TagString: Untagged + m_Icon: {fileID: 0} + m_NavMeshLayer: 0 + m_StaticEditorFlags: 0 + m_IsActive: 1 +--- !u!224 &5630987212537872481 +RectTransform: + m_ObjectHideFlags: 0 + m_CorrespondingSourceObject: {fileID: 0} + m_PrefabInstance: {fileID: 0} + m_PrefabAsset: {fileID: 0} + m_GameObject: {fileID: 5630987212537872480} + m_LocalRotation: {x: -0, y: -0, z: -0, w: 1} + m_LocalPosition: {x: 0, y: 0, z: 0} + m_LocalScale: {x: 1, y: 1, z: 1} + m_Children: [] + m_Father: {fileID: 5630987214048981317} + m_RootOrder: 1 + m_LocalEulerAnglesHint: {x: 0, y: 0, z: 0} + m_AnchorMin: {x: 0, y: 1} + m_AnchorMax: {x: 1, y: 1} + m_AnchoredPosition: {x: 0, y: -40} + m_SizeDelta: {x: 0, y: 3} + m_Pivot: {x: 0.5, y: 0.5} +--- !u!114 &5630987212537872482 +MonoBehaviour: + m_ObjectHideFlags: 0 + m_CorrespondingSourceObject: {fileID: 0} + m_PrefabInstance: {fileID: 0} + m_PrefabAsset: {fileID: 0} + m_GameObject: {fileID: 5630987212537872480} + m_Enabled: 1 + m_EditorHideFlags: 0 + m_Script: {fileID: 11500000, guid: 306cc8c2b49d7114eaa3623786fc2126, type: 3} + m_Name: + m_EditorClassIdentifier: + m_IgnoreLayout: 1 + m_MinWidth: -1 + m_MinHeight: 4 + m_PreferredWidth: -1 + m_PreferredHeight: -1 + m_FlexibleWidth: -1 + m_FlexibleHeight: -1 + m_LayoutPriority: 1 +--- !u!114 &5630987212537872483 +MonoBehaviour: + m_ObjectHideFlags: 0 + m_CorrespondingSourceObject: {fileID: 0} + m_PrefabInstance: {fileID: 0} + m_PrefabAsset: {fileID: 0} + m_GameObject: {fileID: 5630987212537872480} + m_Enabled: 1 + m_EditorHideFlags: 0 + m_Script: {fileID: 11500000, guid: fe87c0e1cc204ed48ad3b37840f39efc, type: 3} + m_Name: + m_EditorClassIdentifier: + m_Material: {fileID: 0} + m_Color: {r: 0.8, g: 0.9333333, b: 1, a: 1} + m_RaycastTarget: 1 + m_RaycastPadding: {x: 0, y: 0, z: 0, w: 0} + m_Maskable: 1 + m_OnCullStateChanged: + m_PersistentCalls: + m_Calls: [] + m_Sprite: {fileID: 21300000, guid: ea8a1213adadb5a4fba6b1785033a34b, type: 3} + m_Type: 1 + m_PreserveAspect: 0 + m_FillCenter: 1 + m_FillMethod: 4 + m_FillAmount: 1 + m_FillClockwise: 1 + m_FillOrigin: 0 + m_UseSpriteMesh: 0 + m_PixelsPerUnitMultiplier: 1 +--- !u!222 &5630987212537872484 +CanvasRenderer: + m_ObjectHideFlags: 0 + m_CorrespondingSourceObject: {fileID: 0} + m_PrefabInstance: {fileID: 0} + m_PrefabAsset: {fileID: 0} + m_GameObject: {fileID: 5630987212537872480} + m_CullTransparentMesh: 0 +--- !u!1 &5630987214048981316 +GameObject: + m_ObjectHideFlags: 0 + m_CorrespondingSourceObject: {fileID: 0} + m_PrefabInstance: {fileID: 0} + m_PrefabAsset: {fileID: 0} + serializedVersion: 6 + m_Component: + - component: {fileID: 5630987214048981317} + - component: {fileID: 5630987214048981320} + - component: {fileID: 5630987214048981323} + m_Layer: 5 + m_Name: Stories + m_TagString: Untagged + m_Icon: {fileID: 0} + m_NavMeshLayer: 0 + m_StaticEditorFlags: 0 + m_IsActive: 1 +--- !u!224 &5630987214048981317 +RectTransform: + m_ObjectHideFlags: 0 + m_CorrespondingSourceObject: {fileID: 0} + m_PrefabInstance: {fileID: 0} + m_PrefabAsset: {fileID: 0} + m_GameObject: {fileID: 5630987214048981316} + m_LocalRotation: {x: -0, y: -0, z: -0, w: 1} + m_LocalPosition: {x: 0, y: 0, z: 0} + m_LocalScale: {x: 1, y: 1, z: 1} + m_Children: + - {fileID: 5630987214140693203} + - {fileID: 5630987212537872481} + - {fileID: 3408386364042537272} + m_Father: {fileID: 14255052} + m_RootOrder: 0 + m_LocalEulerAnglesHint: {x: 0, y: 0, z: 0} + m_AnchorMin: {x: 0, y: 0} + m_AnchorMax: {x: 0, y: 1} + m_AnchoredPosition: {x: 0, y: 0} + m_SizeDelta: {x: 400, y: 0} + m_Pivot: {x: 0, y: 0.5} +--- !u!222 &5630987214048981320 +CanvasRenderer: + m_ObjectHideFlags: 0 + m_CorrespondingSourceObject: {fileID: 0} + m_PrefabInstance: {fileID: 0} + m_PrefabAsset: {fileID: 0} + m_GameObject: {fileID: 5630987214048981316} + m_CullTransparentMesh: 0 +--- !u!114 &5630987214048981323 +MonoBehaviour: + m_ObjectHideFlags: 0 + m_CorrespondingSourceObject: {fileID: 0} + m_PrefabInstance: {fileID: 0} + m_PrefabAsset: {fileID: 0} + m_GameObject: {fileID: 5630987214048981316} + m_Enabled: 1 + m_EditorHideFlags: 0 + m_Script: {fileID: 11500000, guid: fe87c0e1cc204ed48ad3b37840f39efc, type: 3} + m_Name: + m_EditorClassIdentifier: + m_Material: {fileID: 0} + m_Color: {r: 0, g: 0, b: 0, a: 0.29803923} + m_RaycastTarget: 1 + m_RaycastPadding: {x: 0, y: 0, z: 0, w: 0} + m_Maskable: 1 + m_OnCullStateChanged: + m_PersistentCalls: + m_Calls: [] + m_Sprite: {fileID: 21300000, guid: 7ed12bf887e951949bd02894a21fb3ff, type: 3} + m_Type: 1 + m_PreserveAspect: 0 + m_FillCenter: 1 + m_FillMethod: 4 + m_FillAmount: 1 + m_FillClockwise: 1 + m_FillOrigin: 0 + m_UseSpriteMesh: 0 + m_PixelsPerUnitMultiplier: 1 +--- !u!1 &5630987214140693202 +GameObject: + m_ObjectHideFlags: 0 + m_CorrespondingSourceObject: {fileID: 0} + m_PrefabInstance: {fileID: 0} + m_PrefabAsset: {fileID: 0} + serializedVersion: 6 + m_Component: + - component: {fileID: 5630987214140693203} + - component: {fileID: 5630987214140693205} + - component: {fileID: 5630987214140693204} + - component: {fileID: 6727939290776359631} + m_Layer: 5 + m_Name: Title + m_TagString: Untagged + m_Icon: {fileID: 0} + m_NavMeshLayer: 0 + m_StaticEditorFlags: 0 + m_IsActive: 1 +--- !u!224 &5630987214140693203 +RectTransform: + m_ObjectHideFlags: 0 + m_CorrespondingSourceObject: {fileID: 0} + m_PrefabInstance: {fileID: 0} + m_PrefabAsset: {fileID: 0} + m_GameObject: {fileID: 5630987214140693202} + m_LocalRotation: {x: -0, y: -0, z: -0, w: 1} + m_LocalPosition: {x: 0, y: 0, z: 0} + m_LocalScale: {x: 1, y: 1, z: 1} + m_Children: [] + m_Father: {fileID: 5630987214048981317} + m_RootOrder: 0 + m_LocalEulerAnglesHint: {x: 0, y: 0, z: 0} + m_AnchorMin: {x: 0, y: 1} + m_AnchorMax: {x: 1, y: 1} + m_AnchoredPosition: {x: 16, y: -8} + m_SizeDelta: {x: -32, y: 24} + m_Pivot: {x: 0, y: 1} +--- !u!114 &5630987214140693204 +MonoBehaviour: + m_ObjectHideFlags: 0 + m_CorrespondingSourceObject: {fileID: 0} + m_PrefabInstance: {fileID: 0} + m_PrefabAsset: {fileID: 0} + m_GameObject: {fileID: 5630987214140693202} + m_Enabled: 1 + m_EditorHideFlags: 0 + m_Script: {fileID: 11500000, guid: f4688fdb7df04437aeb418b961361dc5, type: 3} + m_Name: + m_EditorClassIdentifier: + m_Material: {fileID: 0} + m_Color: {r: 1, g: 1, b: 1, a: 1} + m_RaycastTarget: 1 + m_RaycastPadding: {x: 0, y: 0, z: 0, w: 0} + m_Maskable: 1 + m_OnCullStateChanged: + m_PersistentCalls: + m_Calls: [] + m_text: Stories + m_isRightToLeft: 0 + m_fontAsset: {fileID: 11400000, guid: 53555f7a2d5e745428813f1b1118734f, type: 2} + m_sharedMaterial: {fileID: -2804126062856497447, guid: 53555f7a2d5e745428813f1b1118734f, + type: 2} + m_fontSharedMaterials: [] + m_fontMaterial: {fileID: 0} + m_fontMaterials: [] + m_fontColor32: + serializedVersion: 2 + rgba: 4294967295 + m_fontColor: {r: 1, g: 1, b: 1, a: 1} + m_enableVertexGradient: 0 + m_colorMode: 3 + m_fontColorGradient: + topLeft: {r: 1, g: 1, b: 1, a: 1} + topRight: {r: 1, g: 1, b: 1, a: 1} + bottomLeft: {r: 1, g: 1, b: 1, a: 1} + bottomRight: {r: 1, g: 1, b: 1, a: 1} + m_fontColorGradientPreset: {fileID: 0} + m_spriteAsset: {fileID: 0} + m_tintAllSprites: 0 + m_StyleSheet: {fileID: 0} + m_TextStyleHashCode: -1183493901 + m_overrideHtmlColors: 0 + m_faceColor: + serializedVersion: 2 + rgba: 4294967295 + m_fontSize: 24 + m_fontSizeBase: 24 + m_fontWeight: 400 + m_enableAutoSizing: 0 + m_fontSizeMin: 18 + m_fontSizeMax: 72 + m_fontStyle: 0 + m_HorizontalAlignment: 2 + m_VerticalAlignment: 512 + m_textAlignment: 65535 + m_characterSpacing: 0 + m_wordSpacing: 0 + m_lineSpacing: 0 + m_lineSpacingMax: 0 + m_paragraphSpacing: 0 + m_charWidthMaxAdj: 0 + m_enableWordWrapping: 1 + m_wordWrappingRatios: 0.4 + m_overflowMode: 0 + m_linkedTextComponent: {fileID: 0} + parentLinkedComponent: {fileID: 0} + m_enableKerning: 1 + m_enableExtraPadding: 0 + checkPaddingRequired: 0 + m_isRichText: 1 + m_parseCtrlCharacters: 1 + m_isOrthographic: 1 + m_isCullingEnabled: 0 + m_horizontalMapping: 0 + m_verticalMapping: 0 + m_uvLineOffset: 0 + m_geometrySortingOrder: 0 + m_IsTextObjectScaleStatic: 0 + m_VertexBufferAutoSizeReduction: 1 + m_useMaxVisibleDescender: 1 + m_pageToDisplay: 1 + m_margin: {x: 0, y: 0, z: 0, w: 0} + m_isUsingLegacyAnimationComponent: 0 + m_isVolumetricText: 0 + m_hasFontAssetChanged: 0 + m_baseMaterial: {fileID: 0} + m_maskOffset: {x: 0, y: 0, z: 0, w: 0} +--- !u!222 &5630987214140693205 +CanvasRenderer: + m_ObjectHideFlags: 0 + m_CorrespondingSourceObject: {fileID: 0} + m_PrefabInstance: {fileID: 0} + m_PrefabAsset: {fileID: 0} + m_GameObject: {fileID: 5630987214140693202} + m_CullTransparentMesh: 0 --- !u!1 &5731918074809343756 GameObject: m_ObjectHideFlags: 0 @@ -33717,6 +35747,26 @@ RectTransform: m_AnchoredPosition: {x: 0, y: 0} m_SizeDelta: {x: 0, y: 0} m_Pivot: {x: 0.5, y: 0.5} +--- !u!114 &6727939290776359631 +MonoBehaviour: + m_ObjectHideFlags: 0 + m_CorrespondingSourceObject: {fileID: 0} + m_PrefabInstance: {fileID: 0} + m_PrefabAsset: {fileID: 0} + m_GameObject: {fileID: 5630987214140693202} + m_Enabled: 1 + m_EditorHideFlags: 0 + m_Script: {fileID: 11500000, guid: 306cc8c2b49d7114eaa3623786fc2126, type: 3} + m_Name: + m_EditorClassIdentifier: + m_IgnoreLayout: 0 + m_MinWidth: -1 + m_MinHeight: -1 + m_PreferredWidth: -1 + m_PreferredHeight: -1 + m_FlexibleWidth: 9999 + m_FlexibleHeight: -1 + m_LayoutPriority: 1 --- !u!222 &6770948969429432073 CanvasRenderer: m_ObjectHideFlags: 0 diff --git a/Assets/Scripts/Gameplay/ActionGameManager.cs b/Assets/Scripts/Gameplay/ActionGameManager.cs index 6c4d8316a..26437e6dc 100644 --- a/Assets/Scripts/Gameplay/ActionGameManager.cs +++ b/Assets/Scripts/Gameplay/ActionGameManager.cs @@ -8,6 +8,8 @@ using System.Collections.Generic; using System.IO; using System.Linq; using Cinemachine; +using Ink; +using Ink.Runtime; using MessagePack; using TMPro; using UniRx; @@ -21,6 +23,7 @@ using UnityEngine.EventSystems; using static Unity.Mathematics.math; using float2 = Unity.Mathematics.float2; using float3 = Unity.Mathematics.float3; +using Path = System.IO.Path; using quaternion = Unity.Mathematics.quaternion; using Random = UnityEngine.Random; @@ -154,6 +157,7 @@ public class ActionGameManager : MonoBehaviour public ItemManager ItemManager { get; private set; } public Zone Zone { get; private set; } public List Loadouts { get; } = new List(); + public IEnumerable GetStories => _stories; private readonly (float2 direction, string name)[] _directions = { (float2(0, 1), "Front"), @@ -165,6 +169,8 @@ public class ActionGameManager : MonoBehaviour private DragAction _dragAction; private Action _endDragCallback; + private List _stories = new List(); + public EntitySettings NewEntitySettings { get => MessagePackSerializer.Deserialize(MessagePackSerializer.Serialize(Settings.GameplaySettings.DefaultEntitySettings)); @@ -200,6 +206,14 @@ public class ActionGameManager : MonoBehaviour ItemManager = new ItemManager(CultCache, Settings.GameplaySettings, Debug.Log); ZoneRenderer.ItemManager = ItemManager; + var narrativePath = GameDataDirectory.CreateSubdirectory("Narrative"); + var narrativeFiles = narrativePath.EnumerateFiles("*.ink"); + foreach(var inkFile in narrativeFiles) + { + var compiler = new Compiler(File.ReadAllText(inkFile.FullName)); + _stories.Add(compiler.Compile()); + } + // _loadoutPath = GameDataDirectory.CreateSubdirectory("Loadouts"); // Loadouts.AddRange(_loadoutPath.EnumerateFiles("*.loadout") // .Select(fi => MessagePackSerializer.Deserialize(File.ReadAllBytes(fi.FullName)))); diff --git a/Assets/Scripts/UI/ChoicePrefab.cs b/Assets/Scripts/UI/ChoicePrefab.cs new file mode 100644 index 000000000..2946d60c7 --- /dev/null +++ b/Assets/Scripts/UI/ChoicePrefab.cs @@ -0,0 +1,9 @@ +using TMPro; +using UnityEngine; +using UnityEngine.UI; + +public class ChoicePrefab : MonoBehaviour +{ + public TextMeshProUGUI Label; + public Button Button; +} \ No newline at end of file diff --git a/Assets/Scripts/UI/ChoicePrefab.cs.meta b/Assets/Scripts/UI/ChoicePrefab.cs.meta new file mode 100644 index 000000000..bd24e9ec5 --- /dev/null +++ b/Assets/Scripts/UI/ChoicePrefab.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: 369e33e0c70b03740a9f757c5a1a9dac +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/Assets/Scripts/UI/LocalMenu.cs b/Assets/Scripts/UI/LocalMenu.cs new file mode 100644 index 000000000..88259f0dd --- /dev/null +++ b/Assets/Scripts/UI/LocalMenu.cs @@ -0,0 +1,63 @@ +using System; +using System.Collections; +using System.Collections.Generic; +using System.Linq; +using Ink.Runtime; +using TMPro; +using UniRx; +using UniRx.Triggers; +using UnityEngine; + +public class LocalMenu : MonoBehaviour +{ + public ObservablePointerClickTrigger ContinueTrigger; + public TextMeshProUGUI Output; + public RectTransform ChoiceParent; + public ChoicePrefab ChoicePrefab; + + private Story _currentStory; + private List _choiceInstances = new List(); + + private void OnEnable() + { + _currentStory = ActionGameManager.Instance.GetStories.First(); + Continue(); + } + + void Start() + { + ContinueTrigger.OnPointerClickAsObservable().Subscribe(pointerEvent => + { + if (_currentStory == null) return; + + if(_currentStory.canContinue) Continue(); + }); + } + + void Continue() + { + Output.text = _currentStory.Continue(); + + foreach(var instance in _choiceInstances) + Destroy(instance); + _choiceInstances.Clear(); + + foreach (var choice in _currentStory.currentChoices) + { + var choiceInstance = Instantiate(ChoicePrefab, ChoiceParent); + choiceInstance.Label.text = choice.text; + choiceInstance.Button.onClick.AddListener(() => + { + _currentStory.ChoosePath(choice.targetPath); + Continue(); + }); + _choiceInstances.Add(choiceInstance.gameObject); + } + } + + // Update is called once per frame + void Update() + { + + } +} diff --git a/Assets/Scripts/UI/LocalMenu.cs.meta b/Assets/Scripts/UI/LocalMenu.cs.meta new file mode 100644 index 000000000..41858aad1 --- /dev/null +++ b/Assets/Scripts/UI/LocalMenu.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: 94223b4e7b954df47a5400f0e7be80c1 +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/Assets/Scripts/UI/MenuPanel.cs b/Assets/Scripts/UI/MenuPanel.cs index 20e19a005..ce6f6ddeb 100644 --- a/Assets/Scripts/UI/MenuPanel.cs +++ b/Assets/Scripts/UI/MenuPanel.cs @@ -73,5 +73,6 @@ public enum MenuTab Map, Inventory, Trade, - Galaxy + Galaxy, + Local } \ No newline at end of file diff --git a/GameData/PlayerSettings.msgpack b/GameData/PlayerSettings.msgpack index c76a1ccc0..a9d771654 100644 --- a/GameData/PlayerSettings.msgpack +++ b/GameData/PlayerSettings.msgpack @@ -1,3 +1,3 @@ version https://git-lfs.github.com/spec/v1 -oid sha256:0ac5d262fca3d766a88a6f5849db285f7b8d42cda04f747c9f36f562c85490b9 +oid sha256:e65428c99ca8688be45695ee938703cc2cfb82f7c0a41594ccbfaecad24ec2e3 size 17318