2 |
3 |
44 |
--------------------------------------------------------------------------------
/resources/resources/screens/pause.html:
--------------------------------------------------------------------------------
1 |
2 |
3 |
45 |
--------------------------------------------------------------------------------
/bin/commands/build.com.js:
--------------------------------------------------------------------------------
1 |
2 | var fs = require("fs");
3 |
4 | function create(context) {
5 |
6 | var builder, logger;
7 |
8 | function init() {
9 | logger = context.getInterface("logger", ["success", "error"]);
10 | builder = context.getInterface("builder", ["build"]);
11 | context.decorate("cli/getCommands", decorate);
12 | }
13 |
14 | function destroy() {
15 | context.removeDecorator("cli/getCommands", decorate);
16 | builder = null;
17 | logger = null;
18 | }
19 |
20 | function decorate(fn) {
21 | return function () {
22 |
23 | var commands = fn();
24 |
25 | commands.build = {
26 | run: build,
27 | brief: "builds project for browser",
28 | usage: "[
2 |
3 |
--------------------------------------------------------------------------------
/src/runtime/vars.com.js:
--------------------------------------------------------------------------------
1 |
2 | function create(context) {
3 |
4 | var vars;
5 |
6 | var api = context.createInterface("vars", {
7 | get: get,
8 | getAll: getAll,
9 | has: has,
10 | remove: remove,
11 | clear: clear,
12 | set: set,
13 | onResume: onResume
14 | });
15 |
16 | function init() {
17 |
18 | vars = {};
19 | context.on("resume_game", api.onResume);
20 |
21 | context.connectInterface(api);
22 | }
23 |
24 | function destroy() {
25 | context.disconnectInterface(api);
26 | vars = null;
27 | }
28 |
29 | function onResume(data) {
30 |
31 | api.clear();
32 |
33 | Object.keys(data.vars).forEach(function (key) {
34 | vars[key] = data.vars[key];
35 | });
36 |
37 | context.publish("vars_resume");
38 | }
39 |
40 | function get(key) {
41 | return vars[key];
42 | }
43 |
44 | function remove(key) {
45 | delete vars[key];
46 | }
47 |
48 | function getAll() {
49 | return vars;
50 | }
51 |
52 | function set(key, value) {
53 | context.publish("before_set_var", key);
54 | vars[key] = value;
55 | context.publish("set_var", key);
56 | }
57 |
58 | function has(key) {
59 | return (key in vars);
60 | }
61 |
62 | function clear() {
63 | Object.keys(vars).forEach(function (key) {
64 | delete vars[key];
65 | });
66 | }
67 |
68 | return {
69 | init: init,
70 | destroy: destroy
71 | };
72 | }
73 |
74 | module.exports = {
75 | name: "vars",
76 | version: "2.0.0",
77 | application: "toothrot",
78 | applicationVersion: "2.x",
79 | applicationSteps: ["run"],
80 | environments: ["any"],
81 | create: create
82 | };
83 |
--------------------------------------------------------------------------------
/src/utils/appCacheManifest.com.js:
--------------------------------------------------------------------------------
1 |
2 | function create(context) {
3 |
4 | var path, fsHelper, logger;
5 |
6 | var api = context.createInterface("appCacheManifest", {
7 | create: createManifest
8 | });
9 |
10 | function init() {
11 |
12 | path = context.channel("getModule")("path");
13 | fsHelper = context.getInterface("fileSystem", ["readDirRecursive"]);
14 | logger = context.getInterface("logger", ["success"]);
15 |
16 | context.connectInterface(api);
17 | context.subscribe("builder/build.after", onBuild);
18 | }
19 |
20 | function destroy() {
21 |
22 | fsHelper = null;
23 |
24 | context.disconnectInterface(api);
25 | context.unsubscribe("builder/build.after", onBuild);
26 | }
27 |
28 | function onBuild(data) {
29 | createManifest(data.outputFs, data.browserDir);
30 | }
31 |
32 | function createManifest(fs, dir) {
33 |
34 | var cacheFile = "" +
35 | "CACHE MANIFEST\n" +
36 | "# Timestamp: " + Date.now() + "\n" +
37 | "# Automatically created by Toothrot Engine\n" +
38 | "\n" +
39 | "CACHE:\n";
40 |
41 | var cacheFilePath = path.join(dir, "cache.manifest");
42 | var files = fsHelper.readDirRecursive(fs, dir);
43 |
44 | files.forEach(function (file) {
45 | cacheFile += normalizePath(file) + "\n";
46 | });
47 |
48 | fs.writeFileSync(cacheFilePath, cacheFile);
49 |
50 | logger.success("Created appcache file at: " + cacheFilePath);
51 |
52 | function normalizePath(path) {
53 | return path.replace("\\", "/");
54 | }
55 | }
56 |
57 | return {
58 | init: init,
59 | destroy: destroy
60 | };
61 | }
62 |
63 | module.exports = {
64 | create: create
65 | };
66 |
--------------------------------------------------------------------------------
/src/utils/errors.json:
--------------------------------------------------------------------------------
1 | {
2 |
3 | "NO_TITLE": "No story title specified!",
4 | "NO_START_NODE": "Required node 'start' is missing.",
5 | "SETTINGS_JSON_ERROR": "The settings section contains mal-formed JSON.",
6 | "HIERARCHY_JSON_ERROR": "The hierarchy section contains mal-formed JSON.",
7 | "CIRCULAR_HIERARCHY": "The hierarchy is circular. Tag '{tag}' references itself.",
8 | "UNKNOWN_NEXT_NODE": "Unknown next node '{next}' for node '{nodeId}' (<{nodeFile}>@{nodeLine}).",
9 | "UNKNOWN_AUTONEXT_TARGET": "Unknown autonextTarget '{target}' for node '{nodeId}' (<{nodeFile}>@{nodeLine}).",
10 | "CONFLICT_NEXT_RETURN": "Conflict: Node '{nodeId}' (<{nodeFile}>@{nodeLine}) has both a next node and a return to the last node.",
11 | "NO_AUTONEXT_TARGET": "Node '{nodeId}' (<{nodeFile}>@{nodeLine}) has an autonext property but no autonextTarget, next node or return is specified.",
12 | "OPTION_WITHOUT_TARGET_OR_VALUE": "Option must have at least one of 'target' or 'value' in node '{nodeId}' (<{nodeFile}>@{nodeLine}). <{optionFile}>@{optionLine}",
13 | "UNKNOWN_OPTION_TARGET": "Unknown node '{target}' referenced in option '{label}' in node '{nodeId}' (<{nodeFile}>@{nodeLine}). <{optionFile}>@{optionLine}",
14 | "NO_LINK_TARGET": "No link target specified for link '{label}' in node '{nodeId}' (<{file}>@{nodeLine}). <{file}>@{linkLine}",
15 | "UNKNOWN_LINK_TARGET": "No such link target '{target}' for link '{label}' in node '{nodeId}' (<{file}>@{nodeLine}). <{file}>@{linkLine}",
16 | "MULTIPLE_NEXT_NODES": "Node '{nodeId}' (<{file}>@{nodeLine}) cannot have more than one next node. <{file}>@{lineOffset}",
17 | "MALFORMED_OPTION": "Malformed option in node '{nodeId}' (<{file}>@{nodeLine}). <{file}>@{lineOffset}",
18 | "INVALID_JSON_IN_SECTION_PROPERTY": "Cannot parse property '{property}' in section '{section}' (<{sectionFile}>@{sectionLine}): {errorMessage}",
19 | "INVALID_JSON_IN_NODE_PROPERTY": "Cannot parse property '{property}' in node '{nodeId}' (<{nodeFile}>@{nodeLine}): {errorMessage}"
20 | }
--------------------------------------------------------------------------------
/misc/templates/scripts.js:
--------------------------------------------------------------------------------
1 | //
2 | // {{$description}}
3 | //
4 | // Engine version: {{$engineVersion}}
5 | // Build time: {{$buildTime}}
6 | //
7 |
8 | /* global TOOTHROT */
9 |
10 | (function () {
11 |
12 | var scripts = {};
13 |
14 | /* eslint-disable camelcase */
15 | /* eslint-disable no-unused-vars */
16 |
17 | {{$functions}}
18 |
19 | /* eslint-enable camelcase */
20 | /* eslint-enable no-unused-vars */
21 |
22 | // @ts-ignore
23 | TOOTHROT.decorate("getGlobalScript", function (fn) {
24 | return function (name) {
25 |
26 | var scriptName;
27 | var result = fn(name);
28 |
29 | if (result) {
30 | return result;
31 | }
32 |
33 | scriptName = "global__slot_" + name;
34 |
35 | return scriptName in scripts ? scripts[scriptName] : null;
36 | };
37 | });
38 |
39 | // @ts-ignore
40 | TOOTHROT.decorate("getSectionScript", function (fn) {
41 | return function (sectionName, slotName) {
42 |
43 | var scriptName;
44 | var result = fn(sectionName, slotName);
45 |
46 | if (result) {
47 | return result;
48 | }
49 |
50 | scriptName = "section_" + sectionName + "__slot_" + slotName;
51 |
52 | return scriptName in scripts ? scripts[scriptName] : null;
53 | };
54 | });
55 |
56 | // @ts-ignore
57 | TOOTHROT.decorate("getNodeScript", function (fn) {
58 | return function (nodeName, slotName) {
59 |
60 | var scriptName;
61 | var result = fn(nodeName, slotName);
62 |
63 | if (result) {
64 | return result;
65 | }
66 |
67 | scriptName = "node_" + nodeName + "__slot_" + slotName;
68 |
69 | return scriptName in scripts ? scripts[scriptName] : null;
70 | };
71 | });
72 |
73 | }());
74 |
--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
1 | # Toothrot Engine
2 |
3 | DEPRECATION NOTICE: This project is no longer actively maintained.
4 |
5 | An engine for creating text-based games.
6 |
7 | Toothrot Engine allows you to create interactive fiction, parser-less text adventures or other
8 | text-based games. The games are written in an eye-friendly text-based format (similar to Markdown)
9 | and allow writing your game logic in JavaScript.
10 |
11 | To develop games with this engine, basic knowledge of JavaScript and HTML is recommended,
12 | though not required for simple choice-based or hypertext games.
13 |
14 | **Please note:** For most people [Toothrot IDE](https://github.com/toothrot-if/toothrot-ide/)
15 | is the better choice for developing Toothrot games.
16 |
17 | ## Features
18 |
19 | * Markdown-like format for writing games
20 | * Different modes of interaction:
21 | * Regular links (like known from Twine)
22 | * Option menus (like in ChoiceScript or in visual novels)
23 | * Going to the next node by clicking or pushing a button (like in visual novels)
24 | * Customizable screen system written in regular HTML and CSS with default screens:
25 | * Main screen
26 | * Pause screen
27 | * Savegame screen
28 | * Settings screen
29 | * Savegame system with slots, auto-save and quick save/load
30 | * Text nodes can also be things in the simple world model, e.g. rooms, items or persons
31 | * Text nodes can be tagged and put into a hierarchy
32 | * Text nodes can contain other text nodes
33 | * Support for mobile devices (and "add to homescreen")
34 | * Exports games for browsers (works without a web server) or as Windows/Mac/Linux desktop apps
35 | * Audio support with separate channels for sounds, ambience and music
36 | * Games playable using the keyboard
37 | * Games playable with screen readers (experimental)
38 | * Extensible JavaScript API
39 | * Speed-adjustable reveal effect for text (like in visual novels)
40 | * Browser builds support application cache (offline mode) out of the box
41 |
42 | ## Documentation
43 |
44 | The documentation resides in its own repository and can be found
45 | [here](https://github.com/toothrot-if/toothrot-docs/).
46 |
--------------------------------------------------------------------------------
/src/utils/browser/confirmations.com.js:
--------------------------------------------------------------------------------
1 |
2 | function create(context) {
3 |
4 | var api = context.createInterface("uiConfirmations", {
5 | create: createConfirm
6 | });
7 |
8 | function init() {
9 | context.connectInterface(api);
10 | }
11 |
12 | function destroy() {
13 | context.disconnectInterface(api);
14 | }
15 |
16 | function createConfirm() {
17 |
18 | function confirm(text, then) {
19 |
20 | var template = context.channel("resources/get").call("templates").confirm;
21 | var focus = context.getInterface("focus", ["getMode", "setMode"]);
22 | var boxContainer = document.createElement("div");
23 | var oldFocus = focus.getMode();
24 |
25 | focus.setMode("messagebox");
26 |
27 | boxContainer.setAttribute("class", "message-box-container");
28 |
29 | boxContainer.innerHTML = template.replace("{message}", text);
30 |
31 | boxContainer.addEventListener("click", onClick);
32 | document.body.appendChild(boxContainer);
33 |
34 | boxContainer.focus();
35 |
36 | function onClick(event) {
37 |
38 | var type = event.target.getAttribute("data-type");
39 | var value = event.target.getAttribute("data-value");
40 |
41 | if (type === "messagebox-button") {
42 |
43 | event.stopPropagation();
44 | event.preventDefault();
45 |
46 | focus.setMode(oldFocus);
47 | boxContainer.parentNode.removeChild(boxContainer);
48 | boxContainer.removeEventListener("click", onClick);
49 |
50 | then(value === "yes" ? true : false);
51 | }
52 | }
53 | }
54 |
55 | return confirm;
56 | }
57 |
58 | return {
59 | init: init,
60 | destroy: destroy
61 | };
62 | }
63 |
64 | module.exports = {
65 | create: create
66 | };
67 |
--------------------------------------------------------------------------------
/bin/commands/pack.com.js:
--------------------------------------------------------------------------------
1 | /* global process */
2 |
3 | var fs = require("fs");
4 |
5 | function create(context) {
6 |
7 | var packer, logger;
8 |
9 | function init() {
10 | logger = context.getInterface("logger", ["error"]);
11 | packer = context.getInterface("packer", ["pack"]);
12 | context.decorate("cli/getCommands", decorate);
13 | }
14 |
15 | function destroy() {
16 | context.removeDecorator("cli/getCommands", decorate);
17 | packer = null;
18 | logger = null;
19 | }
20 |
21 | function decorate(fn) {
22 | return function () {
23 |
24 | var commands = fn();
25 |
26 | commands.pack = {
27 | run: pack,
28 | brief: "packs the project resources into a resource file",
29 | usage: "[
4 |
41 |
5 |
10 |
6 |
7 |
8 |
9 |
11 |
24 |
40 |
12 |
13 |
14 |
15 |
16 |
17 |
18 |
19 |
20 |
21 |
22 |
23 |
2 |
3 |
--------------------------------------------------------------------------------
/src/storyFileReader.com.js:
--------------------------------------------------------------------------------
1 |
2 | var EXTENSION = /\.tr\.md/;
3 | var MAIN_FILE = "main.tr.md";
4 | var MAIN_FILE_NAME = /main\.tr\.md/;
5 |
6 | function create(context) {
7 |
8 | var joinPath, fileSystem;
9 |
10 | var api = context.createInterface("storyFileReader", {
11 | read: readStoryFiles,
12 | isStoryFile: isStoryFile,
13 | isMainStoryFile: isMainStoryFile,
14 | fileNameToMarker: fileNameToMarker,
15 | getStoryFileExtensionTest: getStoryFileExtensionTest,
16 | getMainStoryFileTest: getMainStoryFileTest,
17 | getMainStoryFileName: getMainStoryFileName
18 | });
19 |
20 | function init() {
21 | joinPath = context.channel("getModule")("path").join;
22 | fileSystem = context.getInterface("fileSystem", ["readDirRecursive"]);
23 | context.connectInterface(api);
24 | }
25 |
26 | function destroy() {
27 | context.disconnectInterface(api);
28 | fileSystem = null;
29 | }
30 |
31 | function readStoryFiles(fs, dir) {
32 |
33 | var files = fileSystem.readDirRecursive(fs, dir).filter(function (file) {
34 |
35 | if (api.isMainStoryFile(file)) {
36 | return false;
37 | }
38 |
39 | return api.isStoryFile(file);
40 | });
41 |
42 | var mainFileName = api.getMainStoryFileName();
43 | var mainFile = joinPath(dir, mainFileName);
44 | var content = api.fileNameToMarker(mainFileName) + "\n";
45 |
46 | content += fs.readFileSync(mainFile);
47 |
48 | files.forEach(function (file) {
49 |
50 | var fileContent = fs.readFileSync(joinPath(dir, file));
51 |
52 | content += api.fileNameToMarker(file) + "\n";
53 | content += fileContent;
54 | });
55 |
56 | return content;
57 | }
58 |
59 | function isMainStoryFile(fileName) {
60 | return api.getMainStoryFileTest().test(fileName);
61 | }
62 |
63 | function isStoryFile(fileName) {
64 | return api.getStoryFileExtensionTest().test(fileName);
65 | }
66 |
67 | function getMainStoryFileName() {
68 | return MAIN_FILE;
69 | }
70 |
71 | function fileNameToMarker(fileName) {
72 | return "<<<" + fileName + ">>>";
73 | }
74 |
75 | function getMainStoryFileTest() {
76 | return MAIN_FILE_NAME;
77 | }
78 |
79 | function getStoryFileExtensionTest() {
80 | return EXTENSION;
81 | }
82 |
83 | return {
84 | init: init,
85 | destroy: destroy
86 | };
87 | }
88 |
89 | module.exports = {
90 | create: create
91 | };
92 |
--------------------------------------------------------------------------------
/src/utils/scripts.com.js:
--------------------------------------------------------------------------------
1 |
2 | function create(context) {
3 |
4 | var story, env, vars, logger, getNodeScript, getGlobalScript, getSectionScript;
5 |
6 | var api = context.createInterface("scripts", {
7 | run: runScript,
8 | write: write,
9 | writeLn: writeLn,
10 | runNodeScript: runNodeScript,
11 | runGlobalScript: runGlobalScript,
12 | runSectionScript: runSectionScript
13 | });
14 |
15 | function init() {
16 |
17 | getNodeScript = context.channel("getNodeScript");
18 | getGlobalScript = context.channel("getGlobalScript");
19 | getSectionScript = context.channel("getSectionScript");
20 |
21 | env = context.getInterface("env", ["getAll"]);
22 | vars = context.getInterface("vars", ["getAll"]);
23 | story = context.getInterface("story", ["getAll"]);
24 | logger = context.getInterface("logger", ["error"]);
25 |
26 | context.connectInterface(api);
27 | }
28 |
29 | function destroy() {
30 | context.disconnectInterface(api);
31 | }
32 |
33 | function runNodeScript(nodeName, slotName) {
34 | return runScript(getNodeScript(nodeName, slotName));
35 | }
36 |
37 | function runSectionScript(sectionName, slotName) {
38 | return runScript(getSectionScript(sectionName, slotName));
39 | }
40 |
41 | function runGlobalScript(slotName) {
42 | return runScript(getGlobalScript(slotName));
43 | }
44 |
45 | function runScript(script) {
46 |
47 | var result = "";
48 |
49 | try {
50 |
51 | result = "";
52 |
53 | script(
54 | context,
55 | story.getAll(),
56 | env.getAll(),
57 | vars.getAll(),
58 | write,
59 | writeLn,
60 | script.line,
61 | script.file
62 | );
63 | }
64 | catch (error) {
65 | logger.error(
66 | "Cannot execute script (<" + script.file + ">@" + script.line + "):",
67 | error
68 | );
69 | }
70 |
71 | return result;
72 |
73 | function write(text) {
74 | result += api.write(text);
75 | }
76 |
77 | function writeLn(text) {
78 | result += api.writeLn(text);
79 | }
80 | }
81 |
82 | function write(text) {
83 | return text;
84 | }
85 |
86 | function writeLn(text) {
87 | return "\n
4 |
5 |
42 |
64 |
6 | 
19 |
20 |
21 | Save
7 |8 | Save the image below to your device. It contains the current state of your 9 | game, your settings, and what's in your quicksave slot. 10 |
11 | 15 |
22 |
32 |
33 |
41 | Load
23 |
24 |
25 |
31 |
26 |
30 | 27 | Click to select a datacard image to load 28 |
29 |" + text; 88 | } 89 | 90 | return { 91 | init: init, 92 | destroy: destroy 93 | }; 94 | } 95 | 96 | module.exports = { 97 | create: create 98 | }; 99 | -------------------------------------------------------------------------------- /bin/cli.com.js: -------------------------------------------------------------------------------- 1 | /* eslint-disable no-console */ 2 | /* global process */ 3 | 4 | var parseArgs = require("./args").parse; 5 | 6 | // @ts-ignore 7 | var package = require("../package.json"); 8 | 9 | function create(context) { 10 | 11 | var api = context.createInterface("cli", { 12 | run: run, 13 | getCommands: getCommands 14 | }); 15 | 16 | function init() { 17 | context.connectInterface(api); 18 | context.once("app/ready", api.run); 19 | } 20 | 21 | function destroy() { 22 | context.disconnectInterface(api); 23 | } 24 | 25 | function getCommands() { 26 | return { 27 | help: { 28 | run: showInfo, 29 | brief: "shows help/info for a command", 30 | usage: "[
2 |
87 |
--------------------------------------------------------------------------------
/src/runtime/browser-ui/cartridges.com.js:
--------------------------------------------------------------------------------
1 |
2 | var SCREEN_NAME = "cartridges";
3 | var LINK_TYPE = "cartridge-link";
4 | var IMAGE_TYPE = "cartridge-image";
5 | var LINK_QUERY = "[data-type='" + LINK_TYPE + "']";
6 | var IMAGE_QUERY = "[data-type='" + IMAGE_TYPE + "']";
7 |
8 | var SOURCE_IMAGE_ID = "images/datacard.png";
9 |
10 | function getImageElements() {
11 | return toArray(document.querySelectorAll(IMAGE_QUERY));
12 | }
13 |
14 | function getLinkElements() {
15 | return toArray(document.querySelectorAll(LINK_QUERY));
16 | }
17 |
18 | function toArray(collection) {
19 | return Array.prototype.slice.call(collection);
20 | }
21 |
22 | function create(context) {
23 |
24 | var interpreter, dropZone, confirm, sourceImage, resources, logger, cartridge, confirmation;
25 |
26 | var cartridges = context.createInterface("cartridges", {
27 | getSourceImage: getCartridgeSourceImage,
28 | showDropZone: showDropZone,
29 | hideDropZone: hideDropZone,
30 | generate: generateCartridge,
31 | getImageElements: getImageElements,
32 | getLinkElements: getLinkElements,
33 | readDatacard: readDatacard,
34 | readFile: readFile
35 | });
36 |
37 | function init() {
38 |
39 | var getModule = context.channel("getModule");
40 |
41 | cartridge = getModule("png-cartridge");
42 |
43 | context.connectInterface(cartridges);
44 |
45 | confirmation = context.getInterface("uiConfirmations", ["create"]);
46 | interpreter = context.getInterface("interpreter", ["getState", "updateState"]);
47 | resources = context.getInterface("resources", ["get", "has"]);
48 | logger = context.getInterface("logger", ["log", "error"]);
49 |
50 | confirm = confirmation.create();
51 | dropZone = document.createElement("div");
52 | sourceImage = cartridges.getSourceImage();
53 |
54 | dropZone.setAttribute("class", "global-drop-zone");
55 | document.body.appendChild(dropZone);
56 |
57 | window.addEventListener("dragenter", cartridges.showDropZone);
58 | dropZone.addEventListener("dragenter", handleDragOver);
59 | dropZone.addEventListener("dragover", handleDragOver);
60 | dropZone.addEventListener("dragleave", cartridges.hideDropZone);
61 | dropZone.addEventListener("drop", handleDrop);
62 |
63 | context.on("showScreen", onShowScreen);
64 | context.on("cartridge_file_change", onFileChange);
65 |
66 | }
67 |
68 | function destroy() {
69 |
70 | context.disconnectInterface(cartridges);
71 |
72 | window.removeEventListener("dragenter", cartridges.showDropZone);
73 | context.removeListener("showScreen", onShowScreen);
74 | context.removeListener("cartridge_file_change", onFileChange);
75 |
76 | logger = null;
77 | resources = null;
78 | interpreter = null;
79 | confirm = null;
80 | dropZone = null;
81 | sourceImage = null;
82 |
83 | }
84 |
85 | function runScreenScript() {
86 |
87 | var file = document.querySelector(".file");
88 | var uploadContainer = document.querySelector(".upload-container");
89 | var downloadLink = document.querySelector(".download-link");
90 |
91 | function onClick(event) {
92 | event.stopPropagation();
93 | }
94 |
95 | function onFileChange(event) {
96 | context.publish("cartridge_file_change", event);
97 | }
98 |
99 | uploadContainer.addEventListener("click", onClick);
100 | downloadLink.addEventListener("click", onClick);
101 | file.addEventListener("change", onFileChange);
102 |
103 | }
104 |
105 | function onShowScreen(screen) {
106 | if (screen === SCREEN_NAME) {
107 | runScreenScript();
108 | cartridges.generate();
109 | }
110 | }
111 |
112 | function onFileChange(event) {
113 |
114 | var file = event.target.files[0];
115 |
116 | event.preventDefault();
117 |
118 | cartridges.readFile(file);
119 | }
120 |
121 | function generateCartridge() {
122 |
123 | var cart = cartridge.save(interpreter.getState(), sourceImage);
124 |
125 | cartridges.getImageElements().forEach(function (image) {
126 | image.src = cart.src;
127 | });
128 |
129 | cartridges.getLinkElements().forEach(function (link) {
130 | link.href = cart.src;
131 | });
132 | }
133 |
134 | function handleDrop(event) {
135 |
136 | var file = event.dataTransfer.files[0];
137 |
138 | event.preventDefault();
139 | cartridges.hideDropZone();
140 | cartridges.readFile(file);
141 | }
142 |
143 | function readFile(file) {
144 | if (file && (/image\/png/).test(file.type)) {
145 | cartridges.readDatacard(file);
146 | }
147 | }
148 |
149 | function handleDragOver(event) {
150 | event.dataTransfer.dropEffect = "copy";
151 | event.preventDefault();
152 | }
153 |
154 | function showDropZone() {
155 | dropZone.style.visibility = "visible";
156 | dropZone.style.opacity = 1;
157 | }
158 |
159 | function hideDropZone() {
160 | dropZone.style.visibility = "hidden";
161 | dropZone.style.opacity = 0;
162 | }
163 |
164 | function readDatacard(file) {
165 |
166 | var reader = new FileReader();
167 |
168 | reader.onload = function (event) {
169 |
170 | var data;
171 | var image = new Image();
172 |
173 | document.body.appendChild(image);
174 |
175 | image.src = event.target.result;
176 |
177 | setTimeout(function () {
178 |
179 | try {
180 | data = cartridge.load(image);
181 | }
182 | catch (error) {
183 | document.body.removeChild(image);
184 | logger.error(error);
185 | return;
186 | }
187 |
188 | document.body.removeChild(image);
189 |
190 | confirm("Load state from datacard and discard progress?", function (yes) {
191 | if (yes) {
192 | interpreter.updateState(data);
193 | }
194 | });
195 |
196 | }, 100);
197 | };
198 |
199 | reader.readAsDataURL(file);
200 | }
201 |
202 | function getCartridgeSourceImage() {
203 |
204 | var uri = resources.get("images")[SOURCE_IMAGE_ID];
205 | var image = new Image();
206 |
207 | image.src = uri;
208 | image.style.opacity = "0";
209 |
210 | document.body.appendChild(image);
211 |
212 | return image;
213 | }
214 |
215 | return {
216 | init: init,
217 | destroy: destroy
218 | };
219 |
220 | }
221 |
222 | module.exports = {
223 | name: "cartridges",
224 | version: "2.0.0",
225 | application: "toothrot",
226 | applicationVersion: "2.x",
227 | applicationSteps: ["run"],
228 | environments: ["browser"],
229 | create: create
230 | };
231 |
--------------------------------------------------------------------------------
/src/validator.com.js:
--------------------------------------------------------------------------------
1 |
2 | function create(context) {
3 |
4 | var createError;
5 |
6 | var api = context.createInterface("validator", {
7 | createValidator: createValidator
8 | });
9 |
10 | function init() {
11 |
12 | createError = context.channel("toothrotErrors/createError").call;
13 |
14 | context.connectInterface(api);
15 | }
16 |
17 | function destroy() {
18 | context.disconnectInterface(api);
19 | }
20 |
21 | function createValidator(handleError) {
22 |
23 | function validateNodes(nodes) {
24 | Object.keys(nodes).forEach(function (key) {
25 | validateNode(nodes[key], key, nodes);
26 | });
27 | }
28 |
29 | function validateAst(ast) {
30 |
31 | if (!ast.meta.title) {
32 | handleError(createError({id: "NO_TITLE"}));
33 | }
34 |
35 | if (!ast.nodes.start) {
36 | handleError(createError({id: "NO_START_NODE"}));
37 | }
38 |
39 | validateHierarchy(ast.head.hierarchy);
40 | validateNodes(ast.nodes);
41 | }
42 |
43 | function validateHierarchy(hierarchy) {
44 |
45 | try {
46 | Object.keys(hierarchy).forEach(function (tag) {
47 | resolveHierarchy(tag, hierarchy);
48 | });
49 | }
50 | catch (tag) {
51 | handleError(createError({
52 | id: "CIRCULAR_HIERARCHY",
53 | tag: tag
54 | }));
55 | }
56 | }
57 |
58 | function resolveHierarchy(tag, hierarchy, resolving) {
59 |
60 | var tags = [];
61 | var ancestors = hierarchy[tag];
62 |
63 | resolving = resolving || [];
64 |
65 | resolving.push(tag);
66 |
67 | ancestors.forEach(function (ancestor) {
68 |
69 | if (resolving.indexOf(ancestor) >= 0) {
70 | throw tag;
71 | }
72 |
73 | resolveHierarchy(ancestor, hierarchy, resolving).forEach(function (otherTag) {
74 | tags.push(otherTag);
75 | });
76 |
77 | });
78 |
79 | resolving.splice(resolving.indexOf(tag), 1);
80 |
81 | return tags;
82 | }
83 |
84 | function validateNode(node, name, nodes) {
85 |
86 | if (node.next && !nodes[node.next]) {
87 | handleError(createError({
88 | id: "UNKNOWN_NEXT_NODE",
89 | next: node.next,
90 | nodeLine: node.line,
91 | nodeFile: node.file,
92 | nodeId: node.id
93 | }));
94 | }
95 |
96 | if (node.data.autonextTarget && !nodes[node.data.autonextTarget]) {
97 | handleError(createError({
98 | id: "UNKNOWN_AUTONEXT_TARGET",
99 | target: node.data.autonextTarget,
100 | nodeLine: node.line,
101 | nodeFile: node.file,
102 | nodeId: node.id
103 | }));
104 | }
105 |
106 | if (node.next && node.returnToLast) {
107 | handleError(createError({
108 | id: "CONFLICT_NEXT_RETURN",
109 | nodeId: node.id,
110 | nodeFile: node.file,
111 | nodeLine: node.line
112 | }));
113 | }
114 |
115 | if (
116 | node.data.autonext &&
117 | !node.returnToLast &&
118 | !node.next &&
119 | !node.data.autonextTarget
120 | ) {
121 | handleError(createError({
122 | id: "NO_AUTONEXT_TARGET",
123 | nodeId: node.id,
124 | nodeFile: node.file,
125 | nodeLine: node.line
126 | }));
127 | }
128 |
129 | validateOptions(node, nodes);
130 | validateLinks(node, nodes);
131 | }
132 |
133 | function validateOptions(node, nodes) {
134 | if (Array.isArray(node.options)) {
135 | node.options.forEach(function (option) {
136 | validateOption(option, node, nodes);
137 | });
138 | }
139 | }
140 |
141 | function validateOption(option, node, nodes) {
142 |
143 | if (!option.target && !option.value) {
144 | handleError(createError({
145 | id: "OPTION_WITHOUT_TARGET_OR_VALUE",
146 | nodeId: node.id,
147 | nodeLine: node.line,
148 | nodeFile: node.file,
149 | optionFile: option.file,
150 | optionLine: option.line
151 | }));
152 | }
153 |
154 | if (option.target && !nodes[option.target]) {
155 | handleError(createError({
156 | id: "UNKNOWN_OPTION_TARGET",
157 | nodeId: node.id,
158 | target: option.target,
159 | label: option.label,
160 | nodeLine: node.line,
161 | nodeFile: node.file,
162 | optionFile: option.file,
163 | optionLine: option.line
164 | }));
165 | }
166 | }
167 |
168 | function validateLinks(node, nodes) {
169 | node.links.forEach(function (link) {
170 | validateLink(link, node, nodes);
171 | });
172 | }
173 |
174 | function validateLink(link, node, nodes) {
175 | if (link.type === "direct_link") {
176 | validateDirectLink(link, node, nodes);
177 | }
178 | }
179 |
180 | function validateDirectLink(link, node, nodes) {
181 |
182 | if (!link.target) {
183 | handleError(createError({
184 | id: "NO_LINK_TARGET",
185 | nodeId: node.id,
186 | nodeLine: node.line,
187 | file: node.file,
188 | linkLine: link.line,
189 | label: link.label
190 | }));
191 | }
192 | else if (!(link.target in nodes)) {
193 | handleError(createError({
194 | id: "UNKNOWN_LINK_TARGET",
195 | nodeId: node.id,
196 | nodeLine: node.line,
197 | file: node.file,
198 | linkLine: link.line,
199 | target: link.target,
200 | label: link.label
201 | }));
202 | }
203 | }
204 |
205 | return {
206 | validate: validateAst,
207 | validateNodes: validateNodes,
208 | validateNode: validateNode
209 | };
210 | }
211 |
212 | return {
213 | init: init,
214 | destroy: destroy
215 | };
216 | }
217 |
218 | module.exports = {
219 | create: create
220 | };
221 |
--------------------------------------------------------------------------------
/src/builder.com.js:
--------------------------------------------------------------------------------
1 | /* global require, Buffer, process */
2 |
3 | function create(context) {
4 |
5 | var logger, packer, joinPath, normalize, gatherer, fsHelper, scriptExporter, format;
6 |
7 | var api = context.createInterface("builder", {
8 | build: build,
9 | reportErrors: reportErrors
10 | });
11 |
12 | function init() {
13 |
14 | var getModule = context.channel("getModule");
15 | var path = getModule("path");
16 |
17 | joinPath = path.join;
18 | normalize = path.normalize;
19 |
20 | format = getModule("vrep").create("{{$", "}}");
21 | logger = context.getInterface("logger", ["log", "error", "info", "success"]);
22 | packer = context.getInterface("packer", ["pack"]);
23 | gatherer = context.getInterface("toothrotGatherer", ["renderTemplate"]);
24 | scriptExporter = context.getInterface("scriptExporter", ["render"]);
25 |
26 | fsHelper = context.getInterface("fileSystem", [
27 | "copyAll",
28 | "removeRecursive",
29 | "readDirRecursive"
30 | ]);
31 |
32 | context.connectInterface(api);
33 | }
34 |
35 | function destroy() {
36 |
37 | logger = null;
38 | packer = null;
39 | gatherer = null;
40 | scriptExporter = null;
41 |
42 | context.disconnectInterface(api);
43 | }
44 |
45 | function gathererDependencyInjector(fs) {
46 |
47 | var getModule = context.channel("getModule");
48 |
49 | var modules = {
50 | fs: fs,
51 | assert: getModule("assert"),
52 | semver: getModule("semver"),
53 | minimatch: getModule("minimatch")
54 | };
55 |
56 | return function (host) {
57 | host.decorate("getModule", function (fn) {
58 | return function (name) {
59 |
60 | var result = fn(name);
61 |
62 | if (result) {
63 | return result;
64 | }
65 |
66 | return name in modules ? modules[name] : getModule(name);
67 | };
68 | });
69 | };
70 | }
71 |
72 | function gatherComponents(fs, dir) {
73 |
74 | var componentFile, template, componentTemplate;
75 | var getResource = context.channel("getResource");
76 |
77 | logger.info("Gathering components in `" + dir + "`...");
78 |
79 | template = getResource("toothrotResourcesTemplate");
80 | componentTemplate = getResource("toothrotComponentTemplate");
81 |
82 | componentFile = gatherer.renderTemplate(fs, template, componentTemplate, {
83 | paths: [dir],
84 | prepareHost: gathererDependencyInjector(fs)
85 | });
86 |
87 | logger.success("Component gathering completed.");
88 |
89 | return componentFile;
90 | }
91 |
92 | function createBootstrapFiles(inputFs, dir, outputFs, outputPath) {
93 |
94 | var runtimePath = joinPath(dir, "toothrot.js");
95 | var componentFileContent = gatherComponents(inputFs, dir);
96 | var appDestFilePath = joinPath(outputPath, "/toothrot.js");
97 | var componentFilePath = joinPath(outputPath, "/components.js");
98 |
99 | logger.info(
100 | "Bundling browser components for project in `" + dir + "`..."
101 | );
102 |
103 | logger.log("Creating bootstrap file for browser in `" + outputPath + "`...");
104 |
105 | if (!outputFs.existsSync(outputPath)) {
106 | logger.log("Creating temporary folder `" + outputPath + "`...");
107 | outputFs.mkdirSync(outputPath);
108 | }
109 |
110 | outputFs.writeFileSync(appDestFilePath, inputFs.readFileSync(runtimePath));
111 | outputFs.writeFileSync(componentFilePath, componentFileContent);
112 |
113 | logger.success("Browser component bundle written successfully.");
114 |
115 | }
116 |
117 | function build(inputFs, dir, outputFs, outputDir, then) {
118 |
119 | var rawResources, resources, indexContent, story, storyErrors;
120 |
121 | var base = normalize((dir || process.cwd()) + "/");
122 | var buildDir = normalize(outputDir || (base + "build/"));
123 | var browserDir = joinPath(buildDir, "/browser/");
124 | var scriptFilePath = joinPath(browserDir, "/scripts.js");
125 | var filesDir = joinPath(base, "/files/");
126 | var projectFile = joinPath(base, "/project.json");
127 | var project = JSON.parse("" + inputFs.readFileSync(projectFile));
128 |
129 | context.publish("builder/build.before", {
130 | inputFs: inputFs,
131 | inputDir: dir,
132 | outputFs: outputFs,
133 | outputDir: outputDir
134 | });
135 |
136 | then = then || function () {};
137 |
138 | if (!outputFs.existsSync(buildDir)) {
139 | outputFs.mkdirSync(buildDir);
140 | }
141 |
142 | if (outputFs.existsSync(browserDir)) {
143 | fsHelper.removeRecursive(outputFs, browserDir);
144 | }
145 |
146 | outputFs.mkdirSync(browserDir);
147 |
148 | createBootstrapFiles(inputFs, base, outputFs, browserDir);
149 |
150 | logger.info("Copying files from `" + filesDir + "` to `" + browserDir + "`...");
151 |
152 | fsHelper.copyAll(inputFs, filesDir, outputFs, browserDir);
153 |
154 | logger.success("Files copied to `" + browserDir + "`.");
155 |
156 | packer.pack(inputFs, base, function (error, storyPack) {
157 | storyErrors = error;
158 | rawResources = storyPack;
159 | });
160 |
161 | if (storyErrors) {
162 |
163 | // @ts-ignore
164 | if (storyErrors.isToothrotError) {
165 | then(storyErrors);
166 | // @ts-ignore
167 | logger.error(storyErrors.toothrotMessage);
168 | return;
169 | }
170 |
171 | if (Array.isArray(storyErrors)) {
172 | reportErrors(storyErrors);
173 | then(storyErrors);
174 | return;
175 | }
176 |
177 | throw storyErrors;
178 | }
179 |
180 | story = JSON.parse(rawResources).story;
181 | project.name = story.meta.title || project.name;
182 | resources = new Buffer(encodeURIComponent(rawResources)).toString("base64");
183 |
184 | indexContent = format(
185 | context.channel("getResource")("toothrotResourceFileTemplate"),
186 | {
187 | resources: resources
188 | }
189 | );
190 |
191 | outputFs.writeFileSync(joinPath(browserDir, "resources.js"), indexContent);
192 | outputFs.writeFileSync(scriptFilePath, scriptExporter.render(story));
193 | outputFs.writeFileSync(projectFile, JSON.stringify(project, null, 4));
194 |
195 | logger.success("Toothrot project built successfully in: " + browserDir);
196 |
197 | context.publish("builder/build.after", {
198 | inputFs: inputFs,
199 | inputDir: dir,
200 | outputFs: outputFs,
201 | outputDir: outputDir,
202 | browserDir: browserDir
203 | });
204 |
205 | }
206 |
207 | function reportErrors(errors) {
208 | errors.forEach(function (error) {
209 | logger.error(error.toothrotMessage || error.message);
210 | });
211 | }
212 |
213 | return {
214 | init: init,
215 | destroy: destroy
216 | };
217 | }
218 |
219 | module.exports = {
220 | create: create
221 | };
222 |
--------------------------------------------------------------------------------
/.eslintrc.json:
--------------------------------------------------------------------------------
1 | {
2 | "env": {
3 | "browser": true,
4 | "commonjs": true
5 | },
6 | "extends": "eslint:recommended",
7 | "rules": {
8 | "no-console": ["error", {"allow": ["warn", "error"]}],
9 | "accessor-pairs": "error",
10 | "array-bracket-spacing": [
11 | "error",
12 | "never"
13 | ],
14 | "array-callback-return": "error",
15 | "arrow-body-style": "error",
16 | "arrow-parens": "error",
17 | "arrow-spacing": "error",
18 | "block-scoped-var": "error",
19 | "block-spacing": "error",
20 | "brace-style": [
21 | "error",
22 | "stroustrup"
23 | ],
24 | "callback-return": "off",
25 | "camelcase": "error",
26 | "comma-dangle": "error",
27 | "comma-spacing": [
28 | "error",
29 | {
30 | "after": true,
31 | "before": false
32 | }
33 | ],
34 | "comma-style": [
35 | "error",
36 | "last"
37 | ],
38 | "complexity": "error",
39 | "computed-property-spacing": [
40 | "error",
41 | "never"
42 | ],
43 | "consistent-return": "off",
44 | "consistent-this": ["error", "self"],
45 | "curly": "error",
46 | "default-case": "error",
47 | "dot-location": [
48 | "error",
49 | "object"
50 | ],
51 | "dot-notation": [
52 | "error",
53 | {
54 | "allowKeywords": true
55 | }
56 | ],
57 | "eol-last": "error",
58 | "eqeqeq": "error",
59 | "func-names": [
60 | "error",
61 | "never"
62 | ],
63 | "func-style": "off",
64 | "generator-star-spacing": "error",
65 | "global-require": "off",
66 | "guard-for-in": "off",
67 | "handle-callback-err": "error",
68 | "id-blacklist": "error",
69 | "id-length": "off",
70 | "id-match": "error",
71 | "indent": ["error", 4],
72 | "init-declarations": "off",
73 | "jsx-quotes": "error",
74 | "key-spacing": "error",
75 | "keyword-spacing": "error",
76 | "linebreak-style": [
77 | "error",
78 | "unix"
79 | ],
80 | "lines-around-comment": "error",
81 | "max-depth": "error",
82 | "max-len": ["error", 100],
83 | "max-lines": "off",
84 | "max-nested-callbacks": "error",
85 | "max-params": "off",
86 | "max-statements": "off",
87 | "max-statements-per-line": "error",
88 | "multiline-ternary": "off",
89 | "new-cap": "error",
90 | "new-parens": "error",
91 | "newline-after-var": "off",
92 | "newline-before-return": "off",
93 | "newline-per-chained-call": "off",
94 | "no-alert": "off",
95 | "no-array-constructor": "error",
96 | "no-bitwise": "error",
97 | "no-caller": "error",
98 | "no-catch-shadow": "off",
99 | "no-confusing-arrow": "error",
100 | "no-continue": "error",
101 | "no-div-regex": "error",
102 | "no-duplicate-imports": "error",
103 | "no-else-return": "off",
104 | "no-empty-function": "off",
105 | "no-eq-null": "error",
106 | "no-eval": "error",
107 | "no-extend-native": "error",
108 | "no-extra-bind": "error",
109 | "no-extra-label": "error",
110 | "no-extra-parens": "off",
111 | "no-floating-decimal": "error",
112 | "no-implicit-globals": "error",
113 | "no-implied-eval": "error",
114 | "no-inline-comments": "off",
115 | "no-inner-declarations": [
116 | "error",
117 | "functions"
118 | ],
119 | "no-invalid-this": "error",
120 | "no-iterator": "error",
121 | "no-label-var": "error",
122 | "no-labels": "error",
123 | "no-lone-blocks": "error",
124 | "no-lonely-if": "off",
125 | "no-loop-func": "error",
126 | "no-magic-numbers": "off",
127 | "no-mixed-operators": "error",
128 | "no-mixed-requires": "error",
129 | "no-multi-spaces": "error",
130 | "no-multi-str": "error",
131 | "no-multiple-empty-lines": "error",
132 | "no-negated-condition": "off",
133 | "no-nested-ternary": "error",
134 | "no-new": "error",
135 | "no-new-func": "error",
136 | "no-new-object": "error",
137 | "no-new-require": "error",
138 | "no-new-wrappers": "error",
139 | "no-octal-escape": "error",
140 | "no-param-reassign": "off",
141 | "no-path-concat": "off",
142 | "no-plusplus": "error",
143 | "no-process-env": "error",
144 | "no-process-exit": "error",
145 | "no-proto": "error",
146 | "no-prototype-builtins": "error",
147 | "no-restricted-globals": "error",
148 | "no-restricted-imports": "error",
149 | "no-restricted-modules": "error",
150 | "no-restricted-syntax": "error",
151 | "no-return-assign": "off",
152 | "no-script-url": "error",
153 | "no-self-compare": "error",
154 | "no-sequences": "error",
155 | "no-shadow": "off",
156 | "no-shadow-restricted-names": "error",
157 | "no-spaced-func": "error",
158 | "no-sync": "off",
159 | "no-tabs": "error",
160 | "no-ternary": "off",
161 | "no-throw-literal": "error",
162 | "no-trailing-spaces": "off",
163 | "no-undef-init": "error",
164 | "no-undefined": "off",
165 | "no-underscore-dangle": "off",
166 | "no-unmodified-loop-condition": "error",
167 | "no-unneeded-ternary": "off",
168 | "no-unused-expressions": "error",
169 | "no-use-before-define": "off",
170 | "no-useless-call": "error",
171 | "no-useless-computed-key": "error",
172 | "no-useless-concat": "error",
173 | "no-useless-constructor": "error",
174 | "no-useless-escape": "off",
175 | "no-useless-rename": "error",
176 | "no-var": "off",
177 | "no-void": "error",
178 | "no-warning-comments": "error",
179 | "no-whitespace-before-property": "error",
180 | "no-with": "error",
181 | "object-curly-newline": "off",
182 | "object-curly-spacing": [
183 | "error",
184 | "never"
185 | ],
186 | "object-property-newline": [
187 | "error",
188 | {
189 | "allowMultiplePropertiesPerLine": true
190 | }
191 | ],
192 | "object-shorthand": "off",
193 | "one-var": "off",
194 | "one-var-declaration-per-line": "off",
195 | "operator-assignment": [
196 | "error",
197 | "always"
198 | ],
199 | "operator-linebreak": [
200 | "error",
201 | "after"
202 | ],
203 | "padded-blocks": "off",
204 | "prefer-arrow-callback": "off",
205 | "prefer-const": "error",
206 | "prefer-reflect": "off",
207 | "prefer-rest-params": "off",
208 | "prefer-spread": "off",
209 | "prefer-template": "off",
210 | "quote-props": "off",
211 | "quotes": "off",
212 | "radix": "error",
213 | "require-jsdoc": "off",
214 | "rest-spread-spacing": "error",
215 | "semi": "error",
216 | "semi-spacing": [
217 | "error",
218 | {
219 | "after": true,
220 | "before": false
221 | }
222 | ],
223 | "sort-imports": "error",
224 | "sort-vars": "off",
225 | "space-before-blocks": "error",
226 | "space-before-function-paren": ["error", {
227 | "anonymous": "always",
228 | "named": "never",
229 | "asyncArrow": "always"
230 | }],
231 | "space-in-parens": [
232 | "error",
233 | "never"
234 | ],
235 | "space-infix-ops": "off",
236 | "space-unary-ops": "error",
237 | "spaced-comment": [
238 | "error",
239 | "always"
240 | ],
241 | "strict": [
242 | "error",
243 | "never"
244 | ],
245 | "template-curly-spacing": "error",
246 | "unicode-bom": [
247 | "error",
248 | "never"
249 | ],
250 | "valid-jsdoc": "error",
251 | "vars-on-top": "off",
252 | "wrap-iife": "error",
253 | "wrap-regex": "error",
254 | "yield-star-spacing": "error",
255 | "yoda": [
256 | "error",
257 | "never"
258 | ]
259 | }
260 | }
--------------------------------------------------------------------------------
/src/runtime/nodes.com.js:
--------------------------------------------------------------------------------
1 |
2 | function contains(array, thing) {
3 | return (array.indexOf(thing) >= 0);
4 | }
5 |
6 | function createApi(id, data, nodes) {
7 |
8 | var api = {
9 |
10 | id: id,
11 |
12 | isA: isA,
13 | isntA: isntA,
14 | is: is,
15 | isnt: isnt,
16 | isIn: isIn,
17 | isntIn: isntIn,
18 | isSneaky: isSneaky,
19 | isntSneaky: isntSneaky,
20 | isEmpty: isEmpty,
21 | isntEmpty: isntEmpty,
22 | be: be,
23 | beSneaky: beSneaky,
24 | dontBe: dontBe,
25 | dontBeSneaky: dontBeSneaky,
26 | moveTo: moveTo,
27 | insert: insert,
28 | contains: containsNode,
29 | children: children,
30 | doesntContain: doesntContain,
31 | get: get,
32 | set: set,
33 | has: has,
34 | prop: prop,
35 | raw: raw
36 | };
37 |
38 | function get(key) {
39 | return data[key];
40 | }
41 |
42 | function has(key) {
43 | return (key in data);
44 | }
45 |
46 | function set(key, value) {
47 | data[key] = value;
48 | return api;
49 | }
50 |
51 | function isA(tag) {
52 | return contains(data.tags, tag);
53 | }
54 |
55 | function isntA(tag) {
56 | return !isA(tag);
57 | }
58 |
59 | function is(flag) {
60 | return contains(data.flags, flag);
61 | }
62 |
63 | function isnt(flag) {
64 | return !is(flag);
65 | }
66 |
67 | function isEmpty() {
68 | return data.contains.length < 1;
69 | }
70 |
71 | function isntEmpty() {
72 | return !isEmpty();
73 | }
74 |
75 | function containsNode(id) {
76 | return contains(data.contains, id);
77 | }
78 |
79 | function doesntContain(id) {
80 | return !containsNode(id);
81 | }
82 |
83 | function isIn(id) {
84 |
85 | if (!nodes.has(id)) {
86 | return false;
87 | }
88 |
89 | return nodes.get(id).contains(api.id);
90 | }
91 |
92 | function isntIn(id) {
93 | return !isIn(id);
94 | }
95 |
96 | function isSneaky() {
97 | return is("sneaky");
98 | }
99 |
100 | function isntSneaky() {
101 | return !isSneaky();
102 | }
103 |
104 | function be(flag) {
105 |
106 | if (!is(flag)) {
107 | data.flags.push(flag);
108 | }
109 |
110 | return api;
111 | }
112 |
113 | function beSneaky() {
114 | return be("sneaky");
115 | }
116 |
117 | function dontBe(flag) {
118 |
119 | if (is(flag)) {
120 | data.flags = data.flags.filter(function (nodeFlag) {
121 | return nodeFlag !== flag;
122 | });
123 | }
124 |
125 | return api;
126 | }
127 |
128 | function dontBeSneaky() {
129 | return dontBe("sneaky");
130 | }
131 |
132 | function moveTo(otherId) {
133 |
134 | var otherNode;
135 |
136 | if (!nodes.has(otherId)) {
137 | throw new Error(
138 | "Cannot move node '" + id + "' to node '" + otherId + "': " +
139 | "No such node ID!"
140 | );
141 | }
142 |
143 | otherNode = nodes.get(otherId);
144 |
145 | data.wasIn.forEach(function (itemId) {
146 |
147 | var item = nodes.get(itemId);
148 |
149 | item.set("contains", item.get("contains").filter(function (child) {
150 | return child !== id;
151 | }));
152 |
153 | });
154 |
155 | otherNode.insert(id);
156 |
157 | return api;
158 | }
159 |
160 | function insert(otherId) {
161 |
162 | var otherNode;
163 |
164 | if (!nodes.has(otherId)) {
165 | console.warn("No such node ID: " + otherId);
166 | return api;
167 | }
168 |
169 | if (!contains(otherId)) {
170 |
171 | data.contains.push(otherId);
172 |
173 | otherNode = nodes.get(otherId);
174 |
175 | if (otherNode.get("wasIn").indexOf(id) < 0) {
176 | otherNode.get("wasIn").push(id);
177 | }
178 | }
179 |
180 | return api;
181 | }
182 |
183 | function children() {
184 | return data.contains.slice();
185 | }
186 |
187 | function prop(name, value) {
188 |
189 | if (arguments.length > 1) {
190 | data[name] = value;
191 | }
192 |
193 | return data[name];
194 | }
195 |
196 | function raw() {
197 | return data;
198 | }
199 |
200 | return api;
201 | }
202 |
203 | function createKey(id) {
204 | return "__objdata_" + id;
205 | }
206 |
207 | function create(context) {
208 |
209 | var story, vars, env, clone;
210 |
211 | var api = context.createInterface("nodes", {
212 | get: get,
213 | has: has,
214 | hasData: hasData,
215 | getData: getData,
216 | resolveTagHierarchy: resolveTagHierarchy
217 | });
218 |
219 | function init() {
220 |
221 | var getModule = context.channel("getModule").call;
222 |
223 | clone = getModule("clone");
224 |
225 | context.connectInterface(api);
226 |
227 | env = context.getInterface("env", ["set"]);
228 | vars = context.getInterface("vars", ["get", "set"]);
229 | story = context.getInterface("story", ["getHierarchy", "getNode", "hasNode"]);
230 |
231 | env.set("last", function (tag) {
232 |
233 | var lastNodes = vars.get("_lastNodes") || {};
234 |
235 | return lastNodes[tag];
236 | });
237 |
238 | context.on("before_run_node", onBeforeRunNode);
239 | }
240 |
241 | function destroy() {
242 |
243 | context.removeListener("before_run_node", onBeforeRunNode);
244 | context.disconnectInterface(api);
245 |
246 | vars = null;
247 | story = null;
248 | }
249 |
250 | function onBeforeRunNode(node) {
251 |
252 | var lastNodes = vars.get("_lastNodes") || {};
253 |
254 | api.getData(node.id).tags.forEach(function (originalTag) {
255 |
256 | var allTags = api.resolveTagHierarchy(originalTag);
257 |
258 | allTags.push(originalTag);
259 |
260 | allTags.forEach(function (tag) {
261 | lastNodes[tag] = node.id;
262 | });
263 | });
264 |
265 | vars.set("_lastNodes", lastNodes);
266 | }
267 |
268 | function resolveTagHierarchy(tag) {
269 |
270 | var tags = [];
271 | var hierarchy = story.getHierarchy();
272 | var ancestors = hierarchy[tag] || [];
273 |
274 | ancestors.forEach(function (ancestor) {
275 |
276 | if (tags.indexOf(ancestor) >= 0) {
277 | return;
278 | }
279 |
280 | tags.push(ancestor);
281 |
282 | resolveTagHierarchy(ancestor).forEach(function (otherTag) {
283 | tags.push(otherTag);
284 | });
285 | });
286 |
287 | return tags;
288 | }
289 |
290 | function get(id) {
291 |
292 | var data;
293 |
294 | if (!api.has(id)) {
295 | throw new Error("No such node id: " + id);
296 | }
297 |
298 | data = api.getData(id);
299 |
300 | return createApi(id, data, context.getInterface("nodes", ["get", "has"]));
301 | }
302 |
303 | function has(id) {
304 | return api.hasData(id) || story.hasNode(id);
305 | }
306 |
307 | function hasData(id) {
308 | return !!vars.get(createKey(id));
309 | }
310 |
311 | function getData(id) {
312 |
313 | var key = createKey(id);
314 | var data = vars.get(key);
315 |
316 | if (!data) {
317 | data = clone(story.getNode(id).data);
318 | vars.set(key, data);
319 | }
320 |
321 | return data;
322 | }
323 |
324 | return {
325 | init: init,
326 | destroy: destroy
327 | };
328 | }
329 |
330 | module.exports = {
331 | name: "nodes",
332 | version: "2.0.0",
333 | application: "toothrot",
334 | applicationVersion: "2.x",
335 | applicationSteps: ["run"],
336 | environments: ["any"],
337 | create: create
338 | };
339 |
--------------------------------------------------------------------------------
88 |
111 |
144 |
89 | Tap anywhere to continue
90 |
91 |
92 |
110 |
93 |
96 |
97 |
102 |
109 |