diff --git a/app/main-process/ink/inkjs-compatible/ink-engine-runtime.pdb b/app/main-process/ink/inkjs-compatible/ink-engine-runtime.pdb index d35e7a4f..59e6ab60 100644 Binary files a/app/main-process/ink/inkjs-compatible/ink-engine-runtime.pdb and b/app/main-process/ink/inkjs-compatible/ink-engine-runtime.pdb differ diff --git a/app/main-process/ink/inkjs-compatible/ink-engine-runtime.xml b/app/main-process/ink/inkjs-compatible/ink-engine-runtime.xml new file mode 100644 index 00000000..be343caf --- /dev/null +++ b/app/main-process/ink/inkjs-compatible/ink-engine-runtime.xml @@ -0,0 +1,1133 @@ + + + + ink-engine-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. + + + + + The main text to presented to the player for this Choice. + + + + + The target path that the Story should be diverted to if + this Choice is chosen. + + + + + Get the path to the original choice point - where was this choice defined in the story? + + A dot separated path into the story data. + + + + The original index into currentChoices list on the Story when + this Choice was generated, for convenience. + + + + + 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. + + + + + 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. + + + + + The name of the list where the item was originally defined. + + + + + The main name of the item as defined in ink. + + + + + Create an item with the given original list definition name, and the name of this + item. + + + + + Create an item from a dot-separted string of the form "listDefinitionName.listItemName". + + + + + Get the full dot-separated name of the item, in the form "listDefinitionName.itemName". + + + + + Get the full dot-separated name of the item, in the form "listDefinitionName.itemName". + Calls fullName internally. + + + + + Is this item the same as another item? + + + + + Get the hashcode for an item. + + + + + 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! + + + + + Create a new empty ink list. + + + + + Create a new ink list that contains the same contents as another list. + + + + + 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. + + + + + Converts a string to an ink list and returns for use in the story. + + InkList created from string list item + Item key. + Origin story. + + + + 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. + + + + + 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. + You can also provide the Story object, so in the case of an unknown element, it can be created fresh + + + + + Returns true if this ink list contains an item with the given short name + (ignoring the original list where it was defined). + + + + + Get the maximum item in the list, equivalent to calling LIST_MAX(list) in ink. + + + + + Get the minimum item in the list, equivalent to calling LIST_MIN(list) in ink. + + + + + The inverse of the list, equivalent to calling LIST_INVERSE(list) in ink + + + + + The list of all items from the original list definition, equivalent to calling + LIST_ALL(list) in ink. + + + + + 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. + + + + + 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. + + + + + Fast test for the existence of any intersection between the current list and another + + + + + 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. + + + + 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. + + + + Returns true if the current list contains an item matching the given name. + + Other list. + + + + 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. + + + + + 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). + + + + + 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. + + + + + 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). + + + + + 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. + + + + + Returns true if the passed object is also an ink list that contains + the same items as the current list, false otherwise. + + + + + Return the hashcode for this object, used for comparisons and inserting into dictionaries. + + + + + If you have an InkList that's known to have one single item, this is a convenient way to get it. + + + + + 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. + + + + + Base class for all ink runtime content. + + + + + Runtime.Objects can be included in the main Story as a hierarchy. + Usually parents are Container objects. (TODO: Always?) + + The parent. + + + Allow implicit conversion to bool so you don't have to do: + if( myObj != null ) ... + + + Required for implicit bool comparison + + + Required for implicit bool comparison + + + Required for implicit bool comparison + + + Required for implicit bool comparison + + + + 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. + + + + + 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(); + + + + + + The root node in the hierarchical tree of recorded ink timings. + + + + + Generate a printable report based on the data recording during profiling. + + + + + 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. + + + + + 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. + + + + + 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. + + + + + The key for the node corresponds to the printable name of the callstack element. + + + + + 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 /// + + + + Whether this node contains any sub-nodes - i.e. does it call anything else + that has been recorded? + + true if has children; otherwise, false. + + + + Total number of milliseconds this node has been active for. + + + + + Returns a sorted enumerable of the nodes in descending order of + how long they took to run. + + + + + 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. + + + + 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. + + + + + 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. + + + + + A Story is the core class that represents a complete Ink narrative, and + manages the evaluation and state of it. + + + + + The current version of the ink story file format. + + + + + The minimum legacy version of ink that can be loaded by the current version of the code. + + + + + 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. + + + + + The latest line of text to be generated from a Continue() call. + + + + + Gets a list of tags as defined with '#' in source that were seen + during the latest Continue() call. + + + + + Any errors generated during evaluation of the Story. + + + + + Any warnings generated during evaluation of the Story. + + + + + The current flow name if using multi-flow functionality - see SwitchFlow + + + + + Is the default flow currently active? By definition, will also return true if not using multi-flow functionality - see SwitchFlow + + + + + Names of currently alive flows (not including the default flow) + + + + + Whether the currentErrors list contains any errors. + THIS MAY BE REMOVED - you should be setting an error handler directly + using Story.onError. + + + + + Whether the currentWarnings list contains any warnings. + + + + + 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. + + + + + 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 + + + + + + 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. + + + + + Callback for when ContinueInternal is complete + + + + + Callback for when a choice is about to be executed + + + + + Callback for when a function is about to be evaluated + + + + + Callback for when a function has been evaluated + This is necessary because evaluating a function can cause continuing + + + + + Callback for when a path string is chosen + + + + + 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. + + + + + Stop recording ink profiling information during calls to Continue on Story. + To generate a report from the profiler, call + + + + + Construct a Story object using a JSON string compiled through inklecate. + + + + + The Story itself in JSON representation. + + + + + The Story itself in JSON representation. + + + + + Reset the Story back to its initial state as it was when it was + first constructed. + + + + + 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. + + + + + 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. + + + + 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(). + + + + 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. + + + + + 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). + + + + + 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. + + + + 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. + + + + See CopyStateForBackgroundThreadSave. This method releases the + "frozen" save state, applying its patch that it was using internally. + + + + + 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. + + + + 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. + + + + 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. + + + + + Checks if a function exists. + + True if the function exists, else false. + The name of the function as declared in ink. + + + + 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! + + + + 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! + + + + 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. + + + + + Try to get a reference to an external function. This was originally exposed for the + Ink-Unity integration plugin so that the inspector can list them. + + + + + 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. + + + + + 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. + + + + 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. + + + + 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. + + + + 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. + + + + 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. + + + + 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. + + + + 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. + + + + 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. + + + + 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. + + + + 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. + + + + 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. + + + + Remove a binding for a named EXTERNAL ink function. + + + + + Check that all EXTERNAL ink functions have a valid bound C# function. + Note that this is automatically called on the first call to Continue(). + + + + + Delegate definition for variable observation - see ObserveVariable. + + + + + 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. + + + + 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. + + + + 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. + + + + Get any global tags associated with the story. These are defined as + hash tags defined at the very top of the story. + + + + + 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". + + + + 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. + + + + + 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! + + + + + Constructs a default instance of a StoryException without a message. + + + + + Constructs an instance of a StoryException with a message. + + The error message. + + + + 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. + + + + + The current version of the state save file JSON-based format. + + + + + Callback for when a state is loaded + + + + + Exports the current state to json format, in order to save the game. + + The save state in json format. + + + + 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. + + + + + Loads a previously saved state in JSON format. + + The JSON string to load. + + + + 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. + + + + String representation of the location where the story currently is. + + + + + Get the previous state of currentPathString, which can be helpful + for finding out where the story was before it ended (when the path + string becomes null) + + + + + 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. + + + + + 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. + + + + + 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. + + + + + Enumerator to allow iteration over all global variables by name. + + + + + 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. + + + + + Callback for errors throughout both the ink runtime and compiler. + + + + + 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. + + + + Generated by a "TODO" note in the ink source + + + You should probably fix this, but it's not critical + + + Critical error that can't be recovered from + + + diff --git a/app/main-process/ink/inkjs-compatible/ink_compiler.pdb b/app/main-process/ink/inkjs-compatible/ink_compiler.pdb index 53ed1d59..a92ee470 100644 Binary files a/app/main-process/ink/inkjs-compatible/ink_compiler.pdb and b/app/main-process/ink/inkjs-compatible/ink_compiler.pdb differ diff --git a/app/main-process/ink/inkjs-compatible/inkjs-version.txt b/app/main-process/ink/inkjs-compatible/inkjs-version.txt index c6386167..f7ca2efe 100644 --- a/app/main-process/ink/inkjs-compatible/inkjs-version.txt +++ b/app/main-process/ink/inkjs-compatible/inkjs-version.txt @@ -1,4 +1,4 @@ -inkjs is currently: 2.2.1 -compatible with ink: 1.1.1 +inkjs is currently: 2.2.3 +compatible with ink: 1.2.0 ..which is the version of inklecate in this folder. \ No newline at end of file diff --git a/app/main-process/ink/inkjs-compatible/inklecate.pdb b/app/main-process/ink/inkjs-compatible/inklecate.pdb index bce87e0e..c3cb2c0e 100644 Binary files a/app/main-process/ink/inkjs-compatible/inklecate.pdb and b/app/main-process/ink/inkjs-compatible/inklecate.pdb differ diff --git a/app/main-process/ink/inkjs-compatible/inklecate_linux b/app/main-process/ink/inkjs-compatible/inklecate_linux index 3db50d63..1fc9bbc5 100755 Binary files a/app/main-process/ink/inkjs-compatible/inklecate_linux and b/app/main-process/ink/inkjs-compatible/inklecate_linux differ diff --git a/app/main-process/ink/inkjs-compatible/inklecate_mac b/app/main-process/ink/inkjs-compatible/inklecate_mac index 18a92e43..45e87d16 100755 Binary files a/app/main-process/ink/inkjs-compatible/inklecate_mac and b/app/main-process/ink/inkjs-compatible/inklecate_mac differ diff --git a/app/main-process/ink/inkjs-compatible/inklecate_win.exe b/app/main-process/ink/inkjs-compatible/inklecate_win.exe index dce87474..0bea4771 100755 Binary files a/app/main-process/ink/inkjs-compatible/inklecate_win.exe and b/app/main-process/ink/inkjs-compatible/inklecate_win.exe differ