Document not found (404)
+This URL is invalid, sorry. Please use the navigation bar or search to continue.
+ +
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
diff --git a/console.html b/console.html
new file mode 100644
index 0000000..dd03f45
--- /dev/null
+++ b/console.html
@@ -0,0 +1,247 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Components
+All in all, the framework provides the following components :
+-
+
- Analysis
+
-
+
- Visualization +
- Tracing +
- Simulatioon +
+ - Language as an entry point +
- Runtime +
- Console utility and extention +
Scripts
+That section describes the language and a way how the users can describe the logic of the trees:
+Tree lang
+The scripts. They are usually can be stored as a folder with one or more root node which will be executed afterwords.
+The syntax of the language takes a vast part of the book and described in the following chapter
Validations and Optimizations
+These parts come with static analyzer and are conducted when the users compile the scripts into the runtime tree. +They are described in the corresponding sections Validations and Optimizations
+Tools
+There are some number of extensions for ides to alleviate the writing scripts and running the trees. +The detailed description is in the chapter Tools
+Runtime
+That is the central part of the framework. The runtime orchestrates the tree execution alongside
+with the storing and manipulating some data and actions.
Engine
+The main orchestrator. It is described in the chapter Engine
+Blackboard
+The component which is responsible for the storing the intermediate data that can be passing across the tree. +The mechanism of working is described in that chapter
+ActionKeeper
+The component stores and processes the user implemented actions (tasks or conditions). +The chapter Action describes how to interact with ActionKeeper.
+Analysis
+This component helps to analyse the trees and also interacts with them in an easy way
+Visualization
+The users can visualize the tree using graphviz format. +This section explains how to do that.
+Tracing
+The users can turn on some extra logging that can float up some extra meta information \ +helpful to design and debug the trees. This page explains how to handle the tracing.
+Simulation
+The users can run the tree with some stubs instead of the real implementations of the actions. \ +It can help swiftly define and correct the behavior of the tree itself. +This chapter describes it.
+ +
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
diff --git a/css/chrome.css b/css/chrome.css
new file mode 100644
index 0000000..83b7969
--- /dev/null
+++ b/css/chrome.css
@@ -0,0 +1,604 @@
+/* CSS for UI elements (a.k.a. chrome) */
+
+html {
+ scrollbar-color: var(--scrollbar) var(--bg);
+}
+#searchresults a,
+.content a:link,
+a:visited,
+a > .hljs {
+ color: var(--links);
+}
+
+/*
+ body-container is necessary because mobile browsers don't seem to like
+ overflow-x on the body tag when there is a tag.
+*/
+#body-container {
+ /*
+ This is used when the sidebar pushes the body content off the side of
+ the screen on small screens. Without it, dragging on mobile Safari
+ will want to reposition the viewport in a weird way.
+ */
+ overflow-x: clip;
+}
+
+/* Menu Bar */
+
+#menu-bar,
+#menu-bar-hover-placeholder {
+ z-index: 101;
+ margin: auto calc(0px - var(--page-padding));
+}
+#menu-bar {
+ position: relative;
+ display: flex;
+ flex-wrap: wrap;
+ background-color: var(--bg);
+ border-block-end-color: var(--bg);
+ border-block-end-width: 1px;
+ border-block-end-style: solid;
+}
+#menu-bar.sticky,
+.js #menu-bar-hover-placeholder:hover + #menu-bar,
+.js #menu-bar:hover,
+.js.sidebar-visible #menu-bar {
+ position: -webkit-sticky;
+ position: sticky;
+ top: 0 !important;
+}
+#menu-bar-hover-placeholder {
+ position: sticky;
+ position: -webkit-sticky;
+ top: 0;
+ height: var(--menu-bar-height);
+}
+#menu-bar.bordered {
+ border-block-end-color: var(--table-border-color);
+}
+#menu-bar i, #menu-bar .icon-button {
+ position: relative;
+ padding: 0 8px;
+ z-index: 10;
+ line-height: var(--menu-bar-height);
+ cursor: pointer;
+ transition: color 0.5s;
+}
+@media only screen and (max-width: 420px) {
+ #menu-bar i, #menu-bar .icon-button {
+ padding: 0 5px;
+ }
+}
+
+.icon-button {
+ border: none;
+ background: none;
+ padding: 0;
+ color: inherit;
+}
+.icon-button i {
+ margin: 0;
+}
+
+.right-buttons {
+ margin: 0 15px;
+}
+.right-buttons a {
+ text-decoration: none;
+}
+
+.left-buttons {
+ display: flex;
+ margin: 0 5px;
+}
+.no-js .left-buttons button {
+ display: none;
+}
+
+.menu-title {
+ display: inline-block;
+ font-weight: 200;
+ font-size: 2.4rem;
+ line-height: var(--menu-bar-height);
+ text-align: center;
+ margin: 0;
+ flex: 1;
+ white-space: nowrap;
+ overflow: hidden;
+ text-overflow: ellipsis;
+}
+.js .menu-title {
+ cursor: pointer;
+}
+
+.menu-bar,
+.menu-bar:visited,
+.nav-chapters,
+.nav-chapters:visited,
+.mobile-nav-chapters,
+.mobile-nav-chapters:visited,
+.menu-bar .icon-button,
+.menu-bar a i {
+ color: var(--icons);
+}
+
+.menu-bar i:hover,
+.menu-bar .icon-button:hover,
+.nav-chapters:hover,
+.mobile-nav-chapters i:hover {
+ color: var(--icons-hover);
+}
+
+/* Nav Icons */
+
+.nav-chapters {
+ font-size: 2.5em;
+ text-align: center;
+ text-decoration: none;
+
+ position: fixed;
+ top: 0;
+ bottom: 0;
+ margin: 0;
+ max-width: 150px;
+ min-width: 90px;
+
+ display: flex;
+ justify-content: center;
+ align-content: center;
+ flex-direction: column;
+
+ transition: color 0.5s, background-color 0.5s;
+}
+
+.nav-chapters:hover {
+ text-decoration: none;
+ background-color: var(--theme-hover);
+ transition: background-color 0.15s, color 0.15s;
+}
+
+.nav-wrapper {
+ margin-block-start: 50px;
+ display: none;
+}
+
+.mobile-nav-chapters {
+ font-size: 2.5em;
+ text-align: center;
+ text-decoration: none;
+ width: 90px;
+ border-radius: 5px;
+ background-color: var(--sidebar-bg);
+}
+
+/* Only Firefox supports flow-relative values */
+.previous { float: left; }
+[dir=rtl] .previous { float: right; }
+
+/* Only Firefox supports flow-relative values */
+.next {
+ float: right;
+ right: var(--page-padding);
+}
+[dir=rtl] .next {
+ float: left;
+ right: unset;
+ left: var(--page-padding);
+}
+
+/* Use the correct buttons for RTL layouts*/
+[dir=rtl] .previous i.fa-angle-left:before {content:"\f105";}
+[dir=rtl] .next i.fa-angle-right:before { content:"\f104"; }
+
+@media only screen and (max-width: 1080px) {
+ .nav-wide-wrapper { display: none; }
+ .nav-wrapper { display: block; }
+}
+
+/* sidebar-visible */
+@media only screen and (max-width: 1380px) {
+ #sidebar-toggle-anchor:checked ~ .page-wrapper .nav-wide-wrapper { display: none; }
+ #sidebar-toggle-anchor:checked ~ .page-wrapper .nav-wrapper { display: block; }
+}
+
+/* Inline code */
+
+:not(pre) > .hljs {
+ display: inline;
+ padding: 0.1em 0.3em;
+ border-radius: 3px;
+}
+
+:not(pre):not(a) > .hljs {
+ color: var(--inline-code-color);
+ overflow-x: initial;
+}
+
+a:hover > .hljs {
+ text-decoration: underline;
+}
+
+pre {
+ position: relative;
+}
+pre > .buttons {
+ position: absolute;
+ z-index: 100;
+ right: 0px;
+ top: 2px;
+ margin: 0px;
+ padding: 2px 0px;
+
+ color: var(--sidebar-fg);
+ cursor: pointer;
+ visibility: hidden;
+ opacity: 0;
+ transition: visibility 0.1s linear, opacity 0.1s linear;
+}
+pre:hover > .buttons {
+ visibility: visible;
+ opacity: 1
+}
+pre > .buttons :hover {
+ color: var(--sidebar-active);
+ border-color: var(--icons-hover);
+ background-color: var(--theme-hover);
+}
+pre > .buttons i {
+ margin-inline-start: 8px;
+}
+pre > .buttons button {
+ cursor: inherit;
+ margin: 0px 5px;
+ padding: 3px 5px;
+ font-size: 14px;
+
+ border-style: solid;
+ border-width: 1px;
+ border-radius: 4px;
+ border-color: var(--icons);
+ background-color: var(--theme-popup-bg);
+ transition: 100ms;
+ transition-property: color,border-color,background-color;
+ color: var(--icons);
+}
+@media (pointer: coarse) {
+ pre > .buttons button {
+ /* On mobile, make it easier to tap buttons. */
+ padding: 0.3rem 1rem;
+ }
+
+ .sidebar-resize-indicator {
+ /* Hide resize indicator on devices with limited accuracy */
+ display: none;
+ }
+}
+pre > code {
+ display: block;
+ padding: 1rem;
+}
+
+/* FIXME: ACE editors overlap their buttons because ACE does absolute
+ positioning within the code block which breaks padding. The only solution I
+ can think of is to move the padding to the outer pre tag (or insert a div
+ wrapper), but that would require fixing a whole bunch of CSS rules.
+*/
+.hljs.ace_editor {
+ padding: 0rem 0rem;
+}
+
+pre > .result {
+ margin-block-start: 10px;
+}
+
+/* Search */
+
+#searchresults a {
+ text-decoration: none;
+}
+
+mark {
+ border-radius: 2px;
+ padding-block-start: 0;
+ padding-block-end: 1px;
+ padding-inline-start: 3px;
+ padding-inline-end: 3px;
+ margin-block-start: 0;
+ margin-block-end: -1px;
+ margin-inline-start: -3px;
+ margin-inline-end: -3px;
+ background-color: var(--search-mark-bg);
+ transition: background-color 300ms linear;
+ cursor: pointer;
+}
+
+mark.fade-out {
+ background-color: rgba(0,0,0,0) !important;
+ cursor: auto;
+}
+
+.searchbar-outer {
+ margin-inline-start: auto;
+ margin-inline-end: auto;
+ max-width: var(--content-max-width);
+}
+
+#searchbar {
+ width: 100%;
+ margin-block-start: 5px;
+ margin-block-end: 0;
+ margin-inline-start: auto;
+ margin-inline-end: auto;
+ padding: 10px 16px;
+ transition: box-shadow 300ms ease-in-out;
+ border: 1px solid var(--searchbar-border-color);
+ border-radius: 3px;
+ background-color: var(--searchbar-bg);
+ color: var(--searchbar-fg);
+}
+#searchbar:focus,
+#searchbar.active {
+ box-shadow: 0 0 3px var(--searchbar-shadow-color);
+}
+
+.searchresults-header {
+ font-weight: bold;
+ font-size: 1em;
+ padding-block-start: 18px;
+ padding-block-end: 0;
+ padding-inline-start: 5px;
+ padding-inline-end: 0;
+ color: var(--searchresults-header-fg);
+}
+
+.searchresults-outer {
+ margin-inline-start: auto;
+ margin-inline-end: auto;
+ max-width: var(--content-max-width);
+ border-block-end: 1px dashed var(--searchresults-border-color);
+}
+
+ul#searchresults {
+ list-style: none;
+ padding-inline-start: 20px;
+}
+ul#searchresults li {
+ margin: 10px 0px;
+ padding: 2px;
+ border-radius: 2px;
+}
+ul#searchresults li.focus {
+ background-color: var(--searchresults-li-bg);
+}
+ul#searchresults span.teaser {
+ display: block;
+ clear: both;
+ margin-block-start: 5px;
+ margin-block-end: 0;
+ margin-inline-start: 20px;
+ margin-inline-end: 0;
+ font-size: 0.8em;
+}
+ul#searchresults span.teaser em {
+ font-weight: bold;
+ font-style: normal;
+}
+
+/* Sidebar */
+
+.sidebar {
+ position: fixed;
+ left: 0;
+ top: 0;
+ bottom: 0;
+ width: var(--sidebar-width);
+ font-size: 0.875em;
+ box-sizing: border-box;
+ -webkit-overflow-scrolling: touch;
+ overscroll-behavior-y: contain;
+ background-color: var(--sidebar-bg);
+ color: var(--sidebar-fg);
+}
+[dir=rtl] .sidebar { left: unset; right: 0; }
+.sidebar-resizing {
+ -moz-user-select: none;
+ -webkit-user-select: none;
+ -ms-user-select: none;
+ user-select: none;
+}
+.no-js .sidebar,
+.js:not(.sidebar-resizing) .sidebar {
+ transition: transform 0.3s; /* Animation: slide away */
+}
+.sidebar code {
+ line-height: 2em;
+}
+.sidebar .sidebar-scrollbox {
+ overflow-y: auto;
+ position: absolute;
+ top: 0;
+ bottom: 0;
+ left: 0;
+ right: 0;
+ padding: 10px 10px;
+}
+.sidebar .sidebar-resize-handle {
+ position: absolute;
+ cursor: col-resize;
+ width: 0;
+ right: calc(var(--sidebar-resize-indicator-width) * -1);
+ top: 0;
+ bottom: 0;
+ display: flex;
+ align-items: center;
+}
+
+.sidebar-resize-handle .sidebar-resize-indicator {
+ width: 100%;
+ height: 12px;
+ background-color: var(--icons);
+ margin-inline-start: var(--sidebar-resize-indicator-space);
+}
+
+[dir=rtl] .sidebar .sidebar-resize-handle {
+ left: calc(var(--sidebar-resize-indicator-width) * -1);
+ right: unset;
+}
+.js .sidebar .sidebar-resize-handle {
+ cursor: col-resize;
+ width: calc(var(--sidebar-resize-indicator-width) - var(--sidebar-resize-indicator-space));
+}
+/* sidebar-hidden */
+#sidebar-toggle-anchor:not(:checked) ~ .sidebar {
+ transform: translateX(calc(0px - var(--sidebar-width) - var(--sidebar-resize-indicator-width)));
+ z-index: -1;
+}
+[dir=rtl] #sidebar-toggle-anchor:not(:checked) ~ .sidebar {
+ transform: translateX(calc(var(--sidebar-width) + var(--sidebar-resize-indicator-width)));
+}
+.sidebar::-webkit-scrollbar {
+ background: var(--sidebar-bg);
+}
+.sidebar::-webkit-scrollbar-thumb {
+ background: var(--scrollbar);
+}
+
+/* sidebar-visible */
+#sidebar-toggle-anchor:checked ~ .page-wrapper {
+ transform: translateX(calc(var(--sidebar-width) + var(--sidebar-resize-indicator-width)));
+}
+[dir=rtl] #sidebar-toggle-anchor:checked ~ .page-wrapper {
+ transform: translateX(calc(0px - var(--sidebar-width) - var(--sidebar-resize-indicator-width)));
+}
+@media only screen and (min-width: 620px) {
+ #sidebar-toggle-anchor:checked ~ .page-wrapper {
+ transform: none;
+ margin-inline-start: calc(var(--sidebar-width) + var(--sidebar-resize-indicator-width));
+ }
+ [dir=rtl] #sidebar-toggle-anchor:checked ~ .page-wrapper {
+ transform: none;
+ }
+}
+
+.chapter {
+ list-style: none outside none;
+ padding-inline-start: 0;
+ line-height: 2.2em;
+}
+
+.chapter ol {
+ width: 100%;
+}
+
+.chapter li {
+ display: flex;
+ color: var(--sidebar-non-existant);
+}
+.chapter li a {
+ display: block;
+ padding: 0;
+ text-decoration: none;
+ color: var(--sidebar-fg);
+}
+
+.chapter li a:hover {
+ color: var(--sidebar-active);
+}
+
+.chapter li a.active {
+ color: var(--sidebar-active);
+}
+
+.chapter li > a.toggle {
+ cursor: pointer;
+ display: block;
+ margin-inline-start: auto;
+ padding: 0 10px;
+ user-select: none;
+ opacity: 0.68;
+}
+
+.chapter li > a.toggle div {
+ transition: transform 0.5s;
+}
+
+/* collapse the section */
+.chapter li:not(.expanded) + li > ol {
+ display: none;
+}
+
+.chapter li.chapter-item {
+ line-height: 1.5em;
+ margin-block-start: 0.6em;
+}
+
+.chapter li.expanded > a.toggle div {
+ transform: rotate(90deg);
+}
+
+.spacer {
+ width: 100%;
+ height: 3px;
+ margin: 5px 0px;
+}
+.chapter .spacer {
+ background-color: var(--sidebar-spacer);
+}
+
+@media (-moz-touch-enabled: 1), (pointer: coarse) {
+ .chapter li a { padding: 5px 0; }
+ .spacer { margin: 10px 0; }
+}
+
+.section {
+ list-style: none outside none;
+ padding-inline-start: 20px;
+ line-height: 1.9em;
+}
+
+/* Theme Menu Popup */
+
+.theme-popup {
+ position: absolute;
+ left: 10px;
+ top: var(--menu-bar-height);
+ z-index: 1000;
+ border-radius: 4px;
+ font-size: 0.7em;
+ color: var(--fg);
+ background: var(--theme-popup-bg);
+ border: 1px solid var(--theme-popup-border);
+ margin: 0;
+ padding: 0;
+ list-style: none;
+ display: none;
+ /* Don't let the children's background extend past the rounded corners. */
+ overflow: hidden;
+}
+[dir=rtl] .theme-popup { left: unset; right: 10px; }
+.theme-popup .default {
+ color: var(--icons);
+}
+.theme-popup .theme {
+ width: 100%;
+ border: 0;
+ margin: 0;
+ padding: 2px 20px;
+ line-height: 25px;
+ white-space: nowrap;
+ text-align: start;
+ cursor: pointer;
+ color: inherit;
+ background: inherit;
+ font-size: inherit;
+}
+.theme-popup .theme:hover {
+ background-color: var(--theme-hover);
+}
+
+.theme-selected::before {
+ display: inline-block;
+ content: "✓";
+ margin-inline-start: -14px;
+ width: 14px;
+}
diff --git a/css/general.css b/css/general.css
new file mode 100644
index 0000000..7670b08
--- /dev/null
+++ b/css/general.css
@@ -0,0 +1,232 @@
+/* Base styles and content styles */
+
+:root {
+ /* Browser default font-size is 16px, this way 1 rem = 10px */
+ font-size: 62.5%;
+ color-scheme: var(--color-scheme);
+}
+
+html {
+ font-family: "Open Sans", sans-serif;
+ color: var(--fg);
+ background-color: var(--bg);
+ text-size-adjust: none;
+ -webkit-text-size-adjust: none;
+}
+
+body {
+ margin: 0;
+ font-size: 1.6rem;
+ overflow-x: hidden;
+}
+
+code {
+ font-family: var(--mono-font) !important;
+ font-size: var(--code-font-size);
+ direction: ltr !important;
+}
+
+/* make long words/inline code not x overflow */
+main {
+ overflow-wrap: break-word;
+}
+
+/* make wide tables scroll if they overflow */
+.table-wrapper {
+ overflow-x: auto;
+}
+
+/* Don't change font size in headers. */
+h1 code, h2 code, h3 code, h4 code, h5 code, h6 code {
+ font-size: unset;
+}
+
+.left { float: left; }
+.right { float: right; }
+.boring { opacity: 0.6; }
+.hide-boring .boring { display: none; }
+.hidden { display: none !important; }
+
+h2, h3 { margin-block-start: 2.5em; }
+h4, h5 { margin-block-start: 2em; }
+
+.header + .header h3,
+.header + .header h4,
+.header + .header h5 {
+ margin-block-start: 1em;
+}
+
+h1:target::before,
+h2:target::before,
+h3:target::before,
+h4:target::before,
+h5:target::before,
+h6:target::before {
+ display: inline-block;
+ content: "»";
+ margin-inline-start: -30px;
+ width: 30px;
+}
+
+/* This is broken on Safari as of version 14, but is fixed
+ in Safari Technology Preview 117 which I think will be Safari 14.2.
+ https://bugs.webkit.org/show_bug.cgi?id=218076
+*/
+:target {
+ /* Safari does not support logical properties */
+ scroll-margin-top: calc(var(--menu-bar-height) + 0.5em);
+}
+
+.page {
+ outline: 0;
+ padding: 0 var(--page-padding);
+ margin-block-start: calc(0px - var(--menu-bar-height)); /* Compensate for the #menu-bar-hover-placeholder */
+}
+.page-wrapper {
+ box-sizing: border-box;
+ background-color: var(--bg);
+}
+.no-js .page-wrapper,
+.js:not(.sidebar-resizing) .page-wrapper {
+ transition: margin-left 0.3s ease, transform 0.3s ease; /* Animation: slide away */
+}
+[dir=rtl] .js:not(.sidebar-resizing) .page-wrapper {
+ transition: margin-right 0.3s ease, transform 0.3s ease; /* Animation: slide away */
+}
+
+.content {
+ overflow-y: auto;
+ padding: 0 5px 50px 5px;
+}
+.content main {
+ margin-inline-start: auto;
+ margin-inline-end: auto;
+ max-width: var(--content-max-width);
+}
+.content p { line-height: 1.45em; }
+.content ol { line-height: 1.45em; }
+.content ul { line-height: 1.45em; }
+.content a { text-decoration: none; }
+.content a:hover { text-decoration: underline; }
+.content img, .content video { max-width: 100%; }
+.content .header:link,
+.content .header:visited {
+ color: var(--fg);
+}
+.content .header:link,
+.content .header:visited:hover {
+ text-decoration: none;
+}
+
+table {
+ margin: 0 auto;
+ border-collapse: collapse;
+}
+table td {
+ padding: 3px 20px;
+ border: 1px var(--table-border-color) solid;
+}
+table thead {
+ background: var(--table-header-bg);
+}
+table thead td {
+ font-weight: 700;
+ border: none;
+}
+table thead th {
+ padding: 3px 20px;
+}
+table thead tr {
+ border: 1px var(--table-header-bg) solid;
+}
+/* Alternate background colors for rows */
+table tbody tr:nth-child(2n) {
+ background: var(--table-alternate-bg);
+}
+
+
+blockquote {
+ margin: 20px 0;
+ padding: 0 20px;
+ color: var(--fg);
+ background-color: var(--quote-bg);
+ border-block-start: .1em solid var(--quote-border);
+ border-block-end: .1em solid var(--quote-border);
+}
+
+.warning {
+ margin: 20px;
+ padding: 0 20px;
+ border-inline-start: 2px solid var(--warning-border);
+}
+
+.warning:before {
+ position: absolute;
+ width: 3rem;
+ height: 3rem;
+ margin-inline-start: calc(-1.5rem - 21px);
+ content: "ⓘ";
+ text-align: center;
+ background-color: var(--bg);
+ color: var(--warning-border);
+ font-weight: bold;
+ font-size: 2rem;
+}
+
+blockquote .warning:before {
+ background-color: var(--quote-bg);
+}
+
+kbd {
+ background-color: var(--table-border-color);
+ border-radius: 4px;
+ border: solid 1px var(--theme-popup-border);
+ box-shadow: inset 0 -1px 0 var(--theme-hover);
+ display: inline-block;
+ font-size: var(--code-font-size);
+ font-family: var(--mono-font);
+ line-height: 10px;
+ padding: 4px 5px;
+ vertical-align: middle;
+}
+
+:not(.footnote-definition) + .footnote-definition,
+.footnote-definition + :not(.footnote-definition) {
+ margin-block-start: 2em;
+}
+.footnote-definition {
+ font-size: 0.9em;
+ margin: 0.5em 0;
+}
+.footnote-definition p {
+ display: inline;
+}
+
+.tooltiptext {
+ position: absolute;
+ visibility: hidden;
+ color: #fff;
+ background-color: #333;
+ transform: translateX(-50%); /* Center by moving tooltip 50% of its width left */
+ left: -8px; /* Half of the width of the icon */
+ top: -35px;
+ font-size: 0.8em;
+ text-align: center;
+ border-radius: 6px;
+ padding: 5px 8px;
+ margin: 5px;
+ z-index: 1000;
+}
+.tooltipped .tooltiptext {
+ visibility: visible;
+}
+
+.chapter li.part-title {
+ color: var(--sidebar-fg);
+ margin: 5px 0px;
+ font-weight: bold;
+}
+
+.result-no-output {
+ font-style: italic;
+}
diff --git a/css/print.css b/css/print.css
new file mode 100644
index 0000000..80ec3a5
--- /dev/null
+++ b/css/print.css
@@ -0,0 +1,50 @@
+
+#sidebar,
+#menu-bar,
+.nav-chapters,
+.mobile-nav-chapters {
+ display: none;
+}
+
+#page-wrapper.page-wrapper {
+ transform: none !important;
+ margin-inline-start: 0px;
+ overflow-y: initial;
+}
+
+#content {
+ max-width: none;
+ margin: 0;
+ padding: 0;
+}
+
+.page {
+ overflow-y: initial;
+}
+
+code {
+ direction: ltr !important;
+}
+
+pre > .buttons {
+ z-index: 2;
+}
+
+a, a:visited, a:active, a:hover {
+ color: #4183c4;
+ text-decoration: none;
+}
+
+h1, h2, h3, h4, h5, h6 {
+ page-break-inside: avoid;
+ page-break-after: avoid;
+}
+
+pre, code {
+ page-break-inside: avoid;
+ white-space: pre-wrap;
+}
+
+.fa {
+ display: none !important;
+}
diff --git a/css/variables.css b/css/variables.css
new file mode 100644
index 0000000..0da55e8
--- /dev/null
+++ b/css/variables.css
@@ -0,0 +1,279 @@
+
+/* Globals */
+
+:root {
+ --sidebar-width: 300px;
+ --sidebar-resize-indicator-width: 8px;
+ --sidebar-resize-indicator-space: 2px;
+ --page-padding: 15px;
+ --content-max-width: 750px;
+ --menu-bar-height: 50px;
+ --mono-font: "Source Code Pro", Consolas, "Ubuntu Mono", Menlo, "DejaVu Sans Mono", monospace, monospace;
+ --code-font-size: 0.875em /* please adjust the ace font size accordingly in editor.js */
+}
+
+/* Themes */
+
+.ayu {
+ --bg: hsl(210, 25%, 8%);
+ --fg: #c5c5c5;
+
+ --sidebar-bg: #14191f;
+ --sidebar-fg: #c8c9db;
+ --sidebar-non-existant: #5c6773;
+ --sidebar-active: #ffb454;
+ --sidebar-spacer: #2d334f;
+
+ --scrollbar: var(--sidebar-fg);
+
+ --icons: #737480;
+ --icons-hover: #b7b9cc;
+
+ --links: #0096cf;
+
+ --inline-code-color: #ffb454;
+
+ --theme-popup-bg: #14191f;
+ --theme-popup-border: #5c6773;
+ --theme-hover: #191f26;
+
+ --quote-bg: hsl(226, 15%, 17%);
+ --quote-border: hsl(226, 15%, 22%);
+
+ --warning-border: #ff8e00;
+
+ --table-border-color: hsl(210, 25%, 13%);
+ --table-header-bg: hsl(210, 25%, 28%);
+ --table-alternate-bg: hsl(210, 25%, 11%);
+
+ --searchbar-border-color: #848484;
+ --searchbar-bg: #424242;
+ --searchbar-fg: #fff;
+ --searchbar-shadow-color: #d4c89f;
+ --searchresults-header-fg: #666;
+ --searchresults-border-color: #888;
+ --searchresults-li-bg: #252932;
+ --search-mark-bg: #e3b171;
+
+ --color-scheme: dark;
+}
+
+.coal {
+ --bg: hsl(200, 7%, 8%);
+ --fg: #98a3ad;
+
+ --sidebar-bg: #292c2f;
+ --sidebar-fg: #a1adb8;
+ --sidebar-non-existant: #505254;
+ --sidebar-active: #3473ad;
+ --sidebar-spacer: #393939;
+
+ --scrollbar: var(--sidebar-fg);
+
+ --icons: #43484d;
+ --icons-hover: #b3c0cc;
+
+ --links: #2b79a2;
+
+ --inline-code-color: #c5c8c6;
+
+ --theme-popup-bg: #141617;
+ --theme-popup-border: #43484d;
+ --theme-hover: #1f2124;
+
+ --quote-bg: hsl(234, 21%, 18%);
+ --quote-border: hsl(234, 21%, 23%);
+
+ --warning-border: #ff8e00;
+
+ --table-border-color: hsl(200, 7%, 13%);
+ --table-header-bg: hsl(200, 7%, 28%);
+ --table-alternate-bg: hsl(200, 7%, 11%);
+
+ --searchbar-border-color: #aaa;
+ --searchbar-bg: #b7b7b7;
+ --searchbar-fg: #000;
+ --searchbar-shadow-color: #aaa;
+ --searchresults-header-fg: #666;
+ --searchresults-border-color: #98a3ad;
+ --searchresults-li-bg: #2b2b2f;
+ --search-mark-bg: #355c7d;
+
+ --color-scheme: dark;
+}
+
+.light {
+ --bg: hsl(0, 0%, 100%);
+ --fg: hsl(0, 0%, 0%);
+
+ --sidebar-bg: #fafafa;
+ --sidebar-fg: hsl(0, 0%, 0%);
+ --sidebar-non-existant: #aaaaaa;
+ --sidebar-active: #1f1fff;
+ --sidebar-spacer: #f4f4f4;
+
+ --scrollbar: #8F8F8F;
+
+ --icons: #747474;
+ --icons-hover: #000000;
+
+ --links: #20609f;
+
+ --inline-code-color: #301900;
+
+ --theme-popup-bg: #fafafa;
+ --theme-popup-border: #cccccc;
+ --theme-hover: #e6e6e6;
+
+ --quote-bg: hsl(197, 37%, 96%);
+ --quote-border: hsl(197, 37%, 91%);
+
+ --warning-border: #ff8e00;
+
+ --table-border-color: hsl(0, 0%, 95%);
+ --table-header-bg: hsl(0, 0%, 80%);
+ --table-alternate-bg: hsl(0, 0%, 97%);
+
+ --searchbar-border-color: #aaa;
+ --searchbar-bg: #fafafa;
+ --searchbar-fg: #000;
+ --searchbar-shadow-color: #aaa;
+ --searchresults-header-fg: #666;
+ --searchresults-border-color: #888;
+ --searchresults-li-bg: #e4f2fe;
+ --search-mark-bg: #a2cff5;
+
+ --color-scheme: light;
+}
+
+.navy {
+ --bg: hsl(226, 23%, 11%);
+ --fg: #bcbdd0;
+
+ --sidebar-bg: #282d3f;
+ --sidebar-fg: #c8c9db;
+ --sidebar-non-existant: #505274;
+ --sidebar-active: #2b79a2;
+ --sidebar-spacer: #2d334f;
+
+ --scrollbar: var(--sidebar-fg);
+
+ --icons: #737480;
+ --icons-hover: #b7b9cc;
+
+ --links: #2b79a2;
+
+ --inline-code-color: #c5c8c6;
+
+ --theme-popup-bg: #161923;
+ --theme-popup-border: #737480;
+ --theme-hover: #282e40;
+
+ --quote-bg: hsl(226, 15%, 17%);
+ --quote-border: hsl(226, 15%, 22%);
+
+ --warning-border: #ff8e00;
+
+ --table-border-color: hsl(226, 23%, 16%);
+ --table-header-bg: hsl(226, 23%, 31%);
+ --table-alternate-bg: hsl(226, 23%, 14%);
+
+ --searchbar-border-color: #aaa;
+ --searchbar-bg: #aeaec6;
+ --searchbar-fg: #000;
+ --searchbar-shadow-color: #aaa;
+ --searchresults-header-fg: #5f5f71;
+ --searchresults-border-color: #5c5c68;
+ --searchresults-li-bg: #242430;
+ --search-mark-bg: #a2cff5;
+
+ --color-scheme: dark;
+}
+
+.rust {
+ --bg: hsl(60, 9%, 87%);
+ --fg: #262625;
+
+ --sidebar-bg: #3b2e2a;
+ --sidebar-fg: #c8c9db;
+ --sidebar-non-existant: #505254;
+ --sidebar-active: #e69f67;
+ --sidebar-spacer: #45373a;
+
+ --scrollbar: var(--sidebar-fg);
+
+ --icons: #737480;
+ --icons-hover: #262625;
+
+ --links: #2b79a2;
+
+ --inline-code-color: #6e6b5e;
+
+ --theme-popup-bg: #e1e1db;
+ --theme-popup-border: #b38f6b;
+ --theme-hover: #99908a;
+
+ --quote-bg: hsl(60, 5%, 75%);
+ --quote-border: hsl(60, 5%, 70%);
+
+ --warning-border: #ff8e00;
+
+ --table-border-color: hsl(60, 9%, 82%);
+ --table-header-bg: #b3a497;
+ --table-alternate-bg: hsl(60, 9%, 84%);
+
+ --searchbar-border-color: #aaa;
+ --searchbar-bg: #fafafa;
+ --searchbar-fg: #000;
+ --searchbar-shadow-color: #aaa;
+ --searchresults-header-fg: #666;
+ --searchresults-border-color: #888;
+ --searchresults-li-bg: #dec2a2;
+ --search-mark-bg: #e69f67;
+
+ --color-scheme: light;
+}
+
+@media (prefers-color-scheme: dark) {
+ .light.no-js {
+ --bg: hsl(200, 7%, 8%);
+ --fg: #98a3ad;
+
+ --sidebar-bg: #292c2f;
+ --sidebar-fg: #a1adb8;
+ --sidebar-non-existant: #505254;
+ --sidebar-active: #3473ad;
+ --sidebar-spacer: #393939;
+
+ --scrollbar: var(--sidebar-fg);
+
+ --icons: #43484d;
+ --icons-hover: #b3c0cc;
+
+ --links: #2b79a2;
+
+ --inline-code-color: #c5c8c6;
+
+ --theme-popup-bg: #141617;
+ --theme-popup-border: #43484d;
+ --theme-hover: #1f2124;
+
+ --quote-bg: hsl(234, 21%, 18%);
+ --quote-border: hsl(234, 21%, 23%);
+
+ --warning-border: #ff8e00;
+
+ --table-border-color: hsl(200, 7%, 13%);
+ --table-header-bg: hsl(200, 7%, 28%);
+ --table-alternate-bg: hsl(200, 7%, 11%);
+
+ --searchbar-border-color: #aaa;
+ --searchbar-bg: #b7b7b7;
+ --searchbar-fg: #000;
+ --searchbar-shadow-color: #aaa;
+ --searchresults-header-fg: #666;
+ --searchresults-border-color: #98a3ad;
+ --searchresults-li-bg: #2b2b2f;
+ --search-mark-bg: #355c7d;
+ }
+}
diff --git a/daemons.html b/daemons.html
new file mode 100644
index 0000000..7ad1ec7
--- /dev/null
+++ b/daemons.html
@@ -0,0 +1,321 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Console f-tree
+The console utility f-tree can be installed using cargo and can be used to simulate and visualize the tree.
The Intellij plugin basically wraps this utility and provides the same functionality.
+cargo install f-tree
+and then be used with
+~ f-tree --help
+Usage: f-tree [OPTIONS] <COMMAND>
+
+Commands:
+ print-std-actions Print the list of std actions from 'import std::actions'
+ print-ros-nav2 Print the list of ros actions from 'import ros::nav2'
+ sim Runs simulation. Expects a simulation profile
+ vis Runs visualization. Output is in svg format.
+ nav2 Convert to the xml compatable format of nav ros2.
+ help Print this message or the help of the given subcommand(s)
+
+Options:
+ -d, --debug Print debug logs
+ -h, --help Print help
+ -V, --version Print version
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
diff --git a/decorators.html b/decorators.html
new file mode 100644
index 0000000..abe8409
--- /dev/null
+++ b/decorators.html
@@ -0,0 +1,320 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Daemons
+Forester provides the conception of the background processes called daemons.
+Daemons are used to perform some actions in the background.
+For example, it can be used to publish some messages or subscribe to the topics from the external system
+or to perform some actions on the blackboard in the background.
The daemons are executed at the same runtime environment +as a tree thus the daemons can affect the performance of the tree directly.
+Daemon definition
+The enum Daemon encapsulates a daemon function and provides the following variants:
-
+
- sync - the daemon function is synchronous and will be wrapped into async function. +
- async - the daemon function is asynchronous and will be executed as is. +
How to stop the daemon
+Since, the daemon is supposed to be a long-living background process, there is no way to predict when it will be stopped.
+Therefore, depending on the daemon type, the engine provides the following ways to stop the daemon:
Sync daemon
+The sync daemon function accepts the StopSignal as an argument.
+The StopSignal is a simple atomic boolean that initially false and when it switches to true, the daemon should be stopped.
Async daemon
+The async daemon function accepts the CancellationToken as an argument.
+The CancellationToken is a mechanism from tokio that allows to stop the async function.(one shot channel)
Examples of the daemon
++#![allow(unused)] +fn main() { +struct DaemonSync; + +impl DaemonFn for DaemonSync { + fn perform(&mut self, ctx: DaemonContext, signal: StopFlag) { + while !signal.load(Relaxed) { + std::thread::sleep(std::time::Duration::from_millis(50)); + let mut bb = ctx.bb.lock().unwrap(); + let v = bb.get("test".to_string()).expect("no errors") + .cloned().unwrap_or(RtValue::int(0)); + + bb.put("test_daemon".to_string(), v).unwrap(); + } + } +} + +impl AsyncDaemonFn for DaemonSync { + fn prepare(&mut self, ctx: DaemonContext, signal: CancellationToken) -> Pin<Box<dyn Future<Output=()> + Send>> { + Box::pin(async move { + loop { + tokio::select! { + _ = signal.cancelled() => { + return; + } + _ = tokio::time::sleep(std::time::Duration::from_millis(10)) => { + let mut bb = ctx.bb.lock().unwrap(); + let v = bb.get("test".to_string()).expect("no errors") + .cloned().unwrap_or(RtValue::int(0)); + + bb.put("test_daemon".to_string(), v).unwrap(); + } + } + } + }) + } +} +}
Daemon registration
+The daemon can be registered as follows:
+Using the tree builder
++#![allow(unused)] + +fn main() { +fn register(fb:ForesterBuilder){ + let signal = Arc::new(AtomicBool::new(false)); + fb.register_named_daemon("daemon".to_string(), Daemon::sync(DaemonSync)); + fb.register_daemon(DaemonSync(signal)); +} + + +}
Using the runtime environment
++#![allow(unused)] +fn main() { +impl Impl for Action { + fn tick(&self, args: RtArgs, ctx: TreeContextRef) -> Tick { + let env = ctx.env().lock()?; + env.start_daemon(Daemon::a_sync(DaemonSync), ctx.into()); + Ok(TickResult::success()) + } +} +}
BuiltIn actions
+There are 2 built-in actions that can be used to control the daemons:
+-
+
stop_daemon- stops the daemon by the name
+daemon_alive- check if the daemon is alive by the name
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
diff --git a/definitions.html b/definitions.html
new file mode 100644
index 0000000..d02c06a
--- /dev/null
+++ b/definitions.html
@@ -0,0 +1,244 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Decorators
+The decorators are the specific type of node, +that transforms the result of its child. +Every decorator has a specific keyword and set of parameters.
+** Every decorator should have solely one child **
+Inverter
+The keyword is inverter.
+The decorator inverts the result of the child.
+Only the final results are inverted, for running the result will be
+running as well
main root sequence {
+ inverter check_condition() // inverts the result
+}
+ForceSuccess
+The keyword is force_success.
+Always returns success regardless of the child response
ForceFail
+The keyword is force_fail.
+Always returns failure regardless of the child response
Repeat
+The keyword is repeat
+It repeats the child so the number of times according to the passing parameter
-
+
- count: the number of repetitions. 0 by default +
- if the count is 0 the repeat becomes an infinite loop +
// the job will be performed INF times
+root main_idle repeat {
+ job()
+}
+
+// the job will be performed 5 times
+root main repeat(5) {
+ job()
+}
+Retry
+The keyword is retry
+If the child returns failure, the decorator tries to run it again.
+The number of attempts is restricted by the given argument
-
+
- attempt: the number of repetitions. 0 by default +
- if the attempt is 0 the Retry becomes an infinite loop +
// 0 by default. will be never failed.
+root main retry {
+ sequence {
+ job1()
+ job2()
+ }
+}
+
+// the decorator will try to repeat the sequence upt to 10 times if it returns failure
+root main_with_retry retry(10) {
+ sequence {
+ job1()
+ job2()
+ }
+}
+Timeout
+The keyword is timeout
+The decorator tries to measure how long the child is running and shut id down if it exceeds the limit.
+For now, it works only for asynchronous actions since the decorator measures time when the child returns running
-
+
- limit: the threshold in milliseconds. 1000 by default. +
// if the squence works asynchonously (returns running)
+// the timeout will count up the time of the first start
+// and then recheck it every time when the child returns running
+root main_with_retry timeout {
+ sequence {
+ job1()
+ job2()
+ }
+}
+Delay
+The keyword is delay
+The decorator delays the initial run of the child for the given as a parameter time.
-
+
- wait: the delay time in milliseconds. 0 by default. +
// the delay is zero
+root main delay job()
+
+// the delay is 1 second
+root main_d delay(1000) job()
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
diff --git a/elasticlunr.min.js b/elasticlunr.min.js
new file mode 100644
index 0000000..94b20dd
--- /dev/null
+++ b/elasticlunr.min.js
@@ -0,0 +1,10 @@
+/**
+ * elasticlunr - http://weixsong.github.io
+ * Lightweight full-text search engine in Javascript for browser search and offline search. - 0.9.5
+ *
+ * Copyright (C) 2017 Oliver Nightingale
+ * Copyright (C) 2017 Wei Song
+ * MIT Licensed
+ * @license
+ */
+!function(){function e(e){if(null===e||"object"!=typeof e)return e;var t=e.constructor();for(var n in e)e.hasOwnProperty(n)&&(t[n]=e[n]);return t}var t=function(e){var n=new t.Index;return n.pipeline.add(t.trimmer,t.stopWordFilter,t.stemmer),e&&e.call(n,n),n};t.version="0.9.5",lunr=t,t.utils={},t.utils.warn=function(e){return function(t){e.console&&console.warn&&console.warn(t)}}(this),t.utils.toString=function(e){return void 0===e||null===e?"":e.toString()},t.EventEmitter=function(){this.events={}},t.EventEmitter.prototype.addListener=function(){var e=Array.prototype.slice.call(arguments),t=e.pop(),n=e;if("function"!=typeof t)throw new TypeError("last argument must be a function");n.forEach(function(e){this.hasHandler(e)||(this.events[e]=[]),this.events[e].push(t)},this)},t.EventEmitter.prototype.removeListener=function(e,t){if(this.hasHandler(e)){var n=this.events[e].indexOf(t);-1!==n&&(this.events[e].splice(n,1),0==this.events[e].length&&delete this.events[e])}},t.EventEmitter.prototype.emit=function(e){if(this.hasHandler(e)){var t=Array.prototype.slice.call(arguments,1);this.events[e].forEach(function(e){e.apply(void 0,t)},this)}},t.EventEmitter.prototype.hasHandler=function(e){return e in this.events},t.tokenizer=function(e){if(!arguments.length||null===e||void 0===e)return[];if(Array.isArray(e)){var n=e.filter(function(e){return null===e||void 0===e?!1:!0});n=n.map(function(e){return t.utils.toString(e).toLowerCase()});var i=[];return n.forEach(function(e){var n=e.split(t.tokenizer.seperator);i=i.concat(n)},this),i}return e.toString().trim().toLowerCase().split(t.tokenizer.seperator)},t.tokenizer.defaultSeperator=/[\s\-]+/,t.tokenizer.seperator=t.tokenizer.defaultSeperator,t.tokenizer.setSeperator=function(e){null!==e&&void 0!==e&&"object"==typeof e&&(t.tokenizer.seperator=e)},t.tokenizer.resetSeperator=function(){t.tokenizer.seperator=t.tokenizer.defaultSeperator},t.tokenizer.getSeperator=function(){return t.tokenizer.seperator},t.Pipeline=function(){this._queue=[]},t.Pipeline.registeredFunctions={},t.Pipeline.registerFunction=function(e,n){n in t.Pipeline.registeredFunctions&&t.utils.warn("Overwriting existing registered function: "+n),e.label=n,t.Pipeline.registeredFunctions[n]=e},t.Pipeline.getRegisteredFunction=function(e){return e in t.Pipeline.registeredFunctions!=!0?null:t.Pipeline.registeredFunctions[e]},t.Pipeline.warnIfFunctionNotRegistered=function(e){var n=e.label&&e.label in this.registeredFunctions;n||t.utils.warn("Function is not registered with pipeline. This may cause problems when serialising the index.\n",e)},t.Pipeline.load=function(e){var n=new t.Pipeline;return e.forEach(function(e){var i=t.Pipeline.getRegisteredFunction(e);if(!i)throw new Error("Cannot load un-registered function: "+e);n.add(i)}),n},t.Pipeline.prototype.add=function(){var e=Array.prototype.slice.call(arguments);e.forEach(function(e){t.Pipeline.warnIfFunctionNotRegistered(e),this._queue.push(e)},this)},t.Pipeline.prototype.after=function(e,n){t.Pipeline.warnIfFunctionNotRegistered(n);var i=this._queue.indexOf(e);if(-1===i)throw new Error("Cannot find existingFn");this._queue.splice(i+1,0,n)},t.Pipeline.prototype.before=function(e,n){t.Pipeline.warnIfFunctionNotRegistered(n);var i=this._queue.indexOf(e);if(-1===i)throw new Error("Cannot find existingFn");this._queue.splice(i,0,n)},t.Pipeline.prototype.remove=function(e){var t=this._queue.indexOf(e);-1!==t&&this._queue.splice(t,1)},t.Pipeline.prototype.run=function(e){for(var t=[],n=e.length,i=this._queue.length,o=0;n>o;o++){for(var r=e[o],s=0;i>s&&(r=this._queue[s](r,o,e),void 0!==r&&null!==r);s++);void 0!==r&&null!==r&&t.push(r)}return t},t.Pipeline.prototype.reset=function(){this._queue=[]},t.Pipeline.prototype.get=function(){return this._queue},t.Pipeline.prototype.toJSON=function(){return this._queue.map(function(e){return t.Pipeline.warnIfFunctionNotRegistered(e),e.label})},t.Index=function(){this._fields=[],this._ref="id",this.pipeline=new t.Pipeline,this.documentStore=new t.DocumentStore,this.index={},this.eventEmitter=new t.EventEmitter,this._idfCache={},this.on("add","remove","update",function(){this._idfCache={}}.bind(this))},t.Index.prototype.on=function(){var e=Array.prototype.slice.call(arguments);return this.eventEmitter.addListener.apply(this.eventEmitter,e)},t.Index.prototype.off=function(e,t){return this.eventEmitter.removeListener(e,t)},t.Index.load=function(e){e.version!==t.version&&t.utils.warn("version mismatch: current "+t.version+" importing "+e.version);var n=new this;n._fields=e.fields,n._ref=e.ref,n.documentStore=t.DocumentStore.load(e.documentStore),n.pipeline=t.Pipeline.load(e.pipeline),n.index={};for(var i in e.index)n.index[i]=t.InvertedIndex.load(e.index[i]);return n},t.Index.prototype.addField=function(e){return this._fields.push(e),this.index[e]=new t.InvertedIndex,this},t.Index.prototype.setRef=function(e){return this._ref=e,this},t.Index.prototype.saveDocument=function(e){return this.documentStore=new t.DocumentStore(e),this},t.Index.prototype.addDoc=function(e,n){if(e){var n=void 0===n?!0:n,i=e[this._ref];this.documentStore.addDoc(i,e),this._fields.forEach(function(n){var o=this.pipeline.run(t.tokenizer(e[n]));this.documentStore.addFieldLength(i,n,o.length);var r={};o.forEach(function(e){e in r?r[e]+=1:r[e]=1},this);for(var s in r){var u=r[s];u=Math.sqrt(u),this.index[n].addToken(s,{ref:i,tf:u})}},this),n&&this.eventEmitter.emit("add",e,this)}},t.Index.prototype.removeDocByRef=function(e){if(e&&this.documentStore.isDocStored()!==!1&&this.documentStore.hasDoc(e)){var t=this.documentStore.getDoc(e);this.removeDoc(t,!1)}},t.Index.prototype.removeDoc=function(e,n){if(e){var n=void 0===n?!0:n,i=e[this._ref];this.documentStore.hasDoc(i)&&(this.documentStore.removeDoc(i),this._fields.forEach(function(n){var o=this.pipeline.run(t.tokenizer(e[n]));o.forEach(function(e){this.index[n].removeToken(e,i)},this)},this),n&&this.eventEmitter.emit("remove",e,this))}},t.Index.prototype.updateDoc=function(e,t){var t=void 0===t?!0:t;this.removeDocByRef(e[this._ref],!1),this.addDoc(e,!1),t&&this.eventEmitter.emit("update",e,this)},t.Index.prototype.idf=function(e,t){var n="@"+t+"/"+e;if(Object.prototype.hasOwnProperty.call(this._idfCache,n))return this._idfCache[n];var i=this.index[t].getDocFreq(e),o=1+Math.log(this.documentStore.length/(i+1));return this._idfCache[n]=o,o},t.Index.prototype.getFields=function(){return this._fields.slice()},t.Index.prototype.search=function(e,n){if(!e)return[];e="string"==typeof e?{any:e}:JSON.parse(JSON.stringify(e));var i=null;null!=n&&(i=JSON.stringify(n));for(var o=new t.Configuration(i,this.getFields()).get(),r={},s=Object.keys(e),u=0;u
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Tree definition
+The tree definition denotes a part of the tree (so-called subtree) that defines an independent description and can
+-
+
- have the input parameters and accept arguments including other trees definitions +
- invoke other tree definitions and get invoked by others (except
root)
+
There are the following types of the definitions:
+-
+
- Flow: +the core part of the behavior tree framework. +The nodes define a logic of processing the tree itself, navigating for the next step. +
- Lambda: The anonymous definition of subtree with instant invocation at this place. +
- Decorator: the atomic built-in tree definition that has one child and can enrich or transform the child result according to its type. +
- Actions: the leaves of the tree bearing the business logic. +
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
diff --git a/engine_intro.html b/engine_intro.html
new file mode 100644
index 0000000..b07d79a
--- /dev/null
+++ b/engine_intro.html
@@ -0,0 +1,270 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Engine
+The runtime engine of the framework is Forester.
+It encompasses several components:
-
+
- Blackboard +
- ActionKeeper +
- Runtime Env +
- Tracer +
Example
++#![allow(unused)] +fn main() { + use std::path::PathBuf; + use forester::tracer::Tracer; + use forester::runtime::builder::ForesterBuilder; + use forester::runtime::action::Action; + use forester::runtime::action::builtin::data::StoreData; + use forester_rs::runtime::action::Action; + use forester_rs::runtime::action::builtin::data::StoreData; + use forester_rs::runtime::builder::ForesterBuilder; + use forester_rs::tracer::Tracer; + fn test(root:PathBuf){ + let mut root = PathBuf::new(); + + let mut fb = ForesterBuilder::new(); + fb.main_file("main.tree".to_string()); + fb.root(root); + fb.register_action("store", Action::sync(StoreData)); + + fb.tracer(Tracer::default()); + fb.bb_load("db/db.json".to_string()); + let forester = fb.build().unwrap(); + + forester.run(); // forester.run_until( Some(100)); + } + +}
Tick limitation
+Forester allows limiting how many ticks will be done by running run_with(Some(number))
Runtime environment
+The framework uses tokio as a platform to orchestrate threads and parallelize the job.
+By default, it creates its own tokio runtime env.
+Nevertheless, if there is existing env, it can be provided in ForesterBuilder
Http Server
+The server provides an option to set up the http server to interact with the tree. +The server exposes the access to the blackboard and the tracer.
+To turn on the server, it is required to provide the port number in the ForesterBuilder.
+When the forester finishes the execution of the tree, the server will be shut down.
+#![allow(unused)] +fn main() { + fn serv(fb:ForesterBuilder){ + fb.http_serv(10000); // the port then will be sent to the remote actions as well + } +}
The API
+The server exposes the following endpoints:
+-
+
GET /tracer/print- print the tracer
+POST /tracer/custom- add a custom message to the tracer. It accepts the json body withCustomEvent
+GET /bb/:key/lock- lock the key
+GET /bb/:key/unlock- unlock the key
+GET /bb/:key/locked- check if the key is locked
+GET /bb/:key/contains- check if the key is in the bb
+GET /bb/:key/take- take the key from the bb
+POST /bb/:key- put the key to the bb. It accepts the json body fromRtValue
+GET /bb/:key- get the key from the bb
+GET /- health check. Returns 'Ok'
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
diff --git a/f_examples.html b/f_examples.html
new file mode 100644
index 0000000..beedd5a
--- /dev/null
+++ b/f_examples.html
@@ -0,0 +1,229 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Runtime engine
+The runtime part executes the given tree.
+There are 3 major components of the engine part
+-
+
- Engine itself (Forester) +
- Blackboard +
- Actions(including ActionKeeper) +
The runtime is predominantly synchronous with asynchronous environment for the async actions. +The blackboard is in-memory for now.
+General api
+The entry point is a ForesterBuilder that allows to build Forester in a safe way.
+Also, it is highly customizable.
+ +#![allow(unused)] +fn main() { + use std::path::PathBuf; + use forester::tracer::Tracer; + use forester::runtime::builder::ForesterBuilder; + use forester::runtime::action::Action; + use forester::runtime::action::builtin::data::StoreData; + use forester_rs::runtime::action::builtin::data::StoreData; + use forester_rs::runtime::builder::ForesterBuilder; + use forester_rs::tracer::Tracer; + +fn test(root:PathBuf){ + let mut root = PathBuf::new(); + + let mut fb = ForesterBuilder::new(); + fb.main_file("main.tree".to_string()); + fb.root(root); + fb.register_action("store", Action::sync(StoreData)); + + fb.tracer(Tracer::default()); + fb.bb_load("db/db.json".to_string()); + let forester = fb.build().unwrap(); + + let r = forester.run().unwrap(); + } + + +}
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
diff --git a/falls.html b/falls.html
new file mode 100644
index 0000000..3de55f3
--- /dev/null
+++ b/falls.html
@@ -0,0 +1,296 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
diff --git a/favicon.png b/favicon.png
new file mode 100644
index 0000000..a5b1aa1
Binary files /dev/null and b/favicon.png differ
diff --git a/favicon.svg b/favicon.svg
new file mode 100644
index 0000000..90e0ea5
--- /dev/null
+++ b/favicon.svg
@@ -0,0 +1,22 @@
+
+
diff --git a/flow.html b/flow.html
new file mode 100644
index 0000000..a079f4d
--- /dev/null
+++ b/flow.html
@@ -0,0 +1,238 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Fallback
+A Fallback ticks children sequentially until someone returns a Success.
+Otherwise, if all children return Failure, the node returns Failure.
In the language, the tree definitions and lambda invocations of this element are marked with the key word fallback.
cond is_busy()
+impl take_from_others()
+
+root main {
+ fallback {
+ any_tasks() // goes farther if the first actions is failure
+ do_it()
+ }
+}
+Common behavior
+-
+
- When it gets the first
tickit switches to staterunning
+ - When a child returns
successit stops the execution and returnssuccess
+ - If a child returns
running, the node returnsrunningas well
+ - If a child returns
failure, the node proceeds to the next child +-
+
- if this is a final child, it returns
failure
+
+ - if this is a final child, it returns
- When a node is restarted or halted the process starts from the beginning +
Intention
+Often, it is used for making conditions. +The script below emulates a simple condition that needs to do before
+cond can_take(sub:object)
+impl move_to(sub:object)
+impl take(sub:object)
+
+root main sequence {
+ fallback {
+ can_take(item)
+ move_to(item)
+ }
+ take(item)
+
+}
+using a programming language, it could be the following:
++fn main(item:String){ + if !can_take(item) { + move_to(item) + } + take(item) +}
Subtypes
+There is one subtype that brings a few subtleties to the common process
+Reactive Fallback
+This Fallback defines in the language with the keyword r_fallback and has the following peculiarity:
+The fallback restarts all children on the next tick if someone returned running:
...
+root main {
+ r_fallback {
+ needs_to_charge() // returns failure
+ action() // returns running
+ fin_and_save()
+ }
+}
+The node action returns running and the whole sequence returns running
+but on the next tick it starts from the node needs_to_charge again.
r_fallback will halt the running child to allow a graceful shutdown if a prior child changes from failure to success. In the above example, if needs_to_change returned success on the second tick then action would be halted before r_fallback returned success itself.
Halting must be performed as quickly as possible. Note that currently only build-in flow, built-in decorator and sync action nodes are halted, async and remote actions are not.
+ +
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
diff --git a/fonts/OPEN-SANS-LICENSE.txt b/fonts/OPEN-SANS-LICENSE.txt
new file mode 100644
index 0000000..d645695
--- /dev/null
+++ b/fonts/OPEN-SANS-LICENSE.txt
@@ -0,0 +1,202 @@
+
+ Apache License
+ Version 2.0, January 2004
+ http://www.apache.org/licenses/
+
+ TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+ 1. Definitions.
+
+ "License" shall mean the terms and conditions for use, reproduction,
+ and distribution as defined by Sections 1 through 9 of this document.
+
+ "Licensor" shall mean the copyright owner or entity authorized by
+ the copyright owner that is granting the License.
+
+ "Legal Entity" shall mean the union of the acting entity and all
+ other entities that control, are controlled by, or are under common
+ control with that entity. For the purposes of this definition,
+ "control" means (i) the power, direct or indirect, to cause the
+ direction or management of such entity, whether by contract or
+ otherwise, or (ii) ownership of fifty percent (50%) or more of the
+ outstanding shares, or (iii) beneficial ownership of such entity.
+
+ "You" (or "Your") shall mean an individual or Legal Entity
+ exercising permissions granted by this License.
+
+ "Source" form shall mean the preferred form for making modifications,
+ including but not limited to software source code, documentation
+ source, and configuration files.
+
+ "Object" form shall mean any form resulting from mechanical
+ transformation or translation of a Source form, including but
+ not limited to compiled object code, generated documentation,
+ and conversions to other media types.
+
+ "Work" shall mean the work of authorship, whether in Source or
+ Object form, made available under the License, as indicated by a
+ copyright notice that is included in or attached to the work
+ (an example is provided in the Appendix below).
+
+ "Derivative Works" shall mean any work, whether in Source or Object
+ form, that is based on (or derived from) the Work and for which the
+ editorial revisions, annotations, elaborations, or other modifications
+ represent, as a whole, an original work of authorship. For the purposes
+ of this License, Derivative Works shall not include works that remain
+ separable from, or merely link (or bind by name) to the interfaces of,
+ the Work and Derivative Works thereof.
+
+ "Contribution" shall mean any work of authorship, including
+ the original version of the Work and any modifications or additions
+ to that Work or Derivative Works thereof, that is intentionally
+ submitted to Licensor for inclusion in the Work by the copyright owner
+ or by an individual or Legal Entity authorized to submit on behalf of
+ the copyright owner. For the purposes of this definition, "submitted"
+ means any form of electronic, verbal, or written communication sent
+ to the Licensor or its representatives, including but not limited to
+ communication on electronic mailing lists, source code control systems,
+ and issue tracking systems that are managed by, or on behalf of, the
+ Licensor for the purpose of discussing and improving the Work, but
+ excluding communication that is conspicuously marked or otherwise
+ designated in writing by the copyright owner as "Not a Contribution."
+
+ "Contributor" shall mean Licensor and any individual or Legal Entity
+ on behalf of whom a Contribution has been received by Licensor and
+ subsequently incorporated within the Work.
+
+ 2. Grant of Copyright License. Subject to the terms and conditions of
+ this License, each Contributor hereby grants to You a perpetual,
+ worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+ copyright license to reproduce, prepare Derivative Works of,
+ publicly display, publicly perform, sublicense, and distribute the
+ Work and such Derivative Works in Source or Object form.
+
+ 3. Grant of Patent License. Subject to the terms and conditions of
+ this License, each Contributor hereby grants to You a perpetual,
+ worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+ (except as stated in this section) patent license to make, have made,
+ use, offer to sell, sell, import, and otherwise transfer the Work,
+ where such license applies only to those patent claims licensable
+ by such Contributor that are necessarily infringed by their
+ Contribution(s) alone or by combination of their Contribution(s)
+ with the Work to which such Contribution(s) was submitted. If You
+ institute patent litigation against any entity (including a
+ cross-claim or counterclaim in a lawsuit) alleging that the Work
+ or a Contribution incorporated within the Work constitutes direct
+ or contributory patent infringement, then any patent licenses
+ granted to You under this License for that Work shall terminate
+ as of the date such litigation is filed.
+
+ 4. Redistribution. You may reproduce and distribute copies of the
+ Work or Derivative Works thereof in any medium, with or without
+ modifications, and in Source or Object form, provided that You
+ meet the following conditions:
+
+ (a) You must give any other recipients of the Work or
+ Derivative Works a copy of this License; and
+
+ (b) You must cause any modified files to carry prominent notices
+ stating that You changed the files; and
+
+ (c) You must retain, in the Source form of any Derivative Works
+ that You distribute, all copyright, patent, trademark, and
+ attribution notices from the Source form of the Work,
+ excluding those notices that do not pertain to any part of
+ the Derivative Works; and
+
+ (d) If the Work includes a "NOTICE" text file as part of its
+ distribution, then any Derivative Works that You distribute must
+ include a readable copy of the attribution notices contained
+ within such NOTICE file, excluding those notices that do not
+ pertain to any part of the Derivative Works, in at least one
+ of the following places: within a NOTICE text file distributed
+ as part of the Derivative Works; within the Source form or
+ documentation, if provided along with the Derivative Works; or,
+ within a display generated by the Derivative Works, if and
+ wherever such third-party notices normally appear. The contents
+ of the NOTICE file are for informational purposes only and
+ do not modify the License. You may add Your own attribution
+ notices within Derivative Works that You distribute, alongside
+ or as an addendum to the NOTICE text from the Work, provided
+ that such additional attribution notices cannot be construed
+ as modifying the License.
+
+ You may add Your own copyright statement to Your modifications and
+ may provide additional or different license terms and conditions
+ for use, reproduction, or distribution of Your modifications, or
+ for any such Derivative Works as a whole, provided Your use,
+ reproduction, and distribution of the Work otherwise complies with
+ the conditions stated in this License.
+
+ 5. Submission of Contributions. Unless You explicitly state otherwise,
+ any Contribution intentionally submitted for inclusion in the Work
+ by You to the Licensor shall be under the terms and conditions of
+ this License, without any additional terms or conditions.
+ Notwithstanding the above, nothing herein shall supersede or modify
+ the terms of any separate license agreement you may have executed
+ with Licensor regarding such Contributions.
+
+ 6. Trademarks. This License does not grant permission to use the trade
+ names, trademarks, service marks, or product names of the Licensor,
+ except as required for reasonable and customary use in describing the
+ origin of the Work and reproducing the content of the NOTICE file.
+
+ 7. Disclaimer of Warranty. Unless required by applicable law or
+ agreed to in writing, Licensor provides the Work (and each
+ Contributor provides its Contributions) on an "AS IS" BASIS,
+ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+ implied, including, without limitation, any warranties or conditions
+ of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+ PARTICULAR PURPOSE. You are solely responsible for determining the
+ appropriateness of using or redistributing the Work and assume any
+ risks associated with Your exercise of permissions under this License.
+
+ 8. Limitation of Liability. In no event and under no legal theory,
+ whether in tort (including negligence), contract, or otherwise,
+ unless required by applicable law (such as deliberate and grossly
+ negligent acts) or agreed to in writing, shall any Contributor be
+ liable to You for damages, including any direct, indirect, special,
+ incidental, or consequential damages of any character arising as a
+ result of this License or out of the use or inability to use the
+ Work (including but not limited to damages for loss of goodwill,
+ work stoppage, computer failure or malfunction, or any and all
+ other commercial damages or losses), even if such Contributor
+ has been advised of the possibility of such damages.
+
+ 9. Accepting Warranty or Additional Liability. While redistributing
+ the Work or Derivative Works thereof, You may choose to offer,
+ and charge a fee for, acceptance of support, warranty, indemnity,
+ or other liability obligations and/or rights consistent with this
+ License. However, in accepting such obligations, You may act only
+ on Your own behalf and on Your sole responsibility, not on behalf
+ of any other Contributor, and only if You agree to indemnify,
+ defend, and hold each Contributor harmless for any liability
+ incurred by, or claims asserted against, such Contributor by reason
+ of your accepting any such warranty or additional liability.
+
+ END OF TERMS AND CONDITIONS
+
+ APPENDIX: How to apply the Apache License to your work.
+
+ To apply the Apache License to your work, attach the following
+ boilerplate notice, with the fields enclosed by brackets "[]"
+ replaced with your own identifying information. (Don't include
+ the brackets!) The text should be enclosed in the appropriate
+ comment syntax for the file format. We also recommend that a
+ file or class name and description of purpose be included on the
+ same "printed page" as the copyright notice for easier
+ identification within third-party archives.
+
+ Copyright [yyyy] [name of copyright owner]
+
+ Licensed under the Apache License, Version 2.0 (the "License");
+ you may not use this file except in compliance with the License.
+ You may obtain a copy of the License at
+
+ http://www.apache.org/licenses/LICENSE-2.0
+
+ Unless required by applicable law or agreed to in writing, software
+ distributed under the License is distributed on an "AS IS" BASIS,
+ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ See the License for the specific language governing permissions and
+ limitations under the License.
diff --git a/fonts/SOURCE-CODE-PRO-LICENSE.txt b/fonts/SOURCE-CODE-PRO-LICENSE.txt
new file mode 100644
index 0000000..366206f
--- /dev/null
+++ b/fonts/SOURCE-CODE-PRO-LICENSE.txt
@@ -0,0 +1,93 @@
+Copyright 2010, 2012 Adobe Systems Incorporated (http://www.adobe.com/), with Reserved Font Name 'Source'. All Rights Reserved. Source is a trademark of Adobe Systems Incorporated in the United States and/or other countries.
+
+This Font Software is licensed under the SIL Open Font License, Version 1.1.
+This license is copied below, and is also available with a FAQ at:
+http://scripts.sil.org/OFL
+
+
+-----------------------------------------------------------
+SIL OPEN FONT LICENSE Version 1.1 - 26 February 2007
+-----------------------------------------------------------
+
+PREAMBLE
+The goals of the Open Font License (OFL) are to stimulate worldwide
+development of collaborative font projects, to support the font creation
+efforts of academic and linguistic communities, and to provide a free and
+open framework in which fonts may be shared and improved in partnership
+with others.
+
+The OFL allows the licensed fonts to be used, studied, modified and
+redistributed freely as long as they are not sold by themselves. The
+fonts, including any derivative works, can be bundled, embedded,
+redistributed and/or sold with any software provided that any reserved
+names are not used by derivative works. The fonts and derivatives,
+however, cannot be released under any other type of license. The
+requirement for fonts to remain under this license does not apply
+to any document created using the fonts or their derivatives.
+
+DEFINITIONS
+"Font Software" refers to the set of files released by the Copyright
+Holder(s) under this license and clearly marked as such. This may
+include source files, build scripts and documentation.
+
+"Reserved Font Name" refers to any names specified as such after the
+copyright statement(s).
+
+"Original Version" refers to the collection of Font Software components as
+distributed by the Copyright Holder(s).
+
+"Modified Version" refers to any derivative made by adding to, deleting,
+or substituting -- in part or in whole -- any of the components of the
+Original Version, by changing formats or by porting the Font Software to a
+new environment.
+
+"Author" refers to any designer, engineer, programmer, technical
+writer or other person who contributed to the Font Software.
+
+PERMISSION & CONDITIONS
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of the Font Software, to use, study, copy, merge, embed, modify,
+redistribute, and sell modified and unmodified copies of the Font
+Software, subject to the following conditions:
+
+1) Neither the Font Software nor any of its individual components,
+in Original or Modified Versions, may be sold by itself.
+
+2) Original or Modified Versions of the Font Software may be bundled,
+redistributed and/or sold with any software, provided that each copy
+contains the above copyright notice and this license. These can be
+included either as stand-alone text files, human-readable headers or
+in the appropriate machine-readable metadata fields within text or
+binary files as long as those fields can be easily viewed by the user.
+
+3) No Modified Version of the Font Software may use the Reserved Font
+Name(s) unless explicit written permission is granted by the corresponding
+Copyright Holder. This restriction only applies to the primary font name as
+presented to the users.
+
+4) The name(s) of the Copyright Holder(s) or the Author(s) of the Font
+Software shall not be used to promote, endorse or advertise any
+Modified Version, except to acknowledge the contribution(s) of the
+Copyright Holder(s) and the Author(s) or with their explicit written
+permission.
+
+5) The Font Software, modified or unmodified, in part or in whole,
+must be distributed entirely under this license, and must not be
+distributed under any other license. The requirement for fonts to
+remain under this license does not apply to any document created
+using the Font Software.
+
+TERMINATION
+This license becomes null and void if any of the above conditions are
+not met.
+
+DISCLAIMER
+THE FONT SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO ANY WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT
+OF COPYRIGHT, PATENT, TRADEMARK, OR OTHER RIGHT. IN NO EVENT SHALL THE
+COPYRIGHT HOLDER BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+INCLUDING ANY GENERAL, SPECIAL, INDIRECT, INCIDENTAL, OR CONSEQUENTIAL
+DAMAGES, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+FROM, OUT OF THE USE OR INABILITY TO USE THE FONT SOFTWARE OR FROM
+OTHER DEALINGS IN THE FONT SOFTWARE.
diff --git a/fonts/fonts.css b/fonts/fonts.css
new file mode 100644
index 0000000..858efa5
--- /dev/null
+++ b/fonts/fonts.css
@@ -0,0 +1,100 @@
+/* Open Sans is licensed under the Apache License, Version 2.0. See http://www.apache.org/licenses/LICENSE-2.0 */
+/* Source Code Pro is under the Open Font License. See https://scripts.sil.org/cms/scripts/page.php?site_id=nrsi&id=OFL */
+
+/* open-sans-300 - latin_vietnamese_latin-ext_greek-ext_greek_cyrillic-ext_cyrillic */
+@font-face {
+ font-family: 'Open Sans';
+ font-style: normal;
+ font-weight: 300;
+ src: local('Open Sans Light'), local('OpenSans-Light'),
+ url('open-sans-v17-all-charsets-300.woff2') format('woff2');
+}
+
+/* open-sans-300italic - latin_vietnamese_latin-ext_greek-ext_greek_cyrillic-ext_cyrillic */
+@font-face {
+ font-family: 'Open Sans';
+ font-style: italic;
+ font-weight: 300;
+ src: local('Open Sans Light Italic'), local('OpenSans-LightItalic'),
+ url('open-sans-v17-all-charsets-300italic.woff2') format('woff2');
+}
+
+/* open-sans-regular - latin_vietnamese_latin-ext_greek-ext_greek_cyrillic-ext_cyrillic */
+@font-face {
+ font-family: 'Open Sans';
+ font-style: normal;
+ font-weight: 400;
+ src: local('Open Sans Regular'), local('OpenSans-Regular'),
+ url('open-sans-v17-all-charsets-regular.woff2') format('woff2');
+}
+
+/* open-sans-italic - latin_vietnamese_latin-ext_greek-ext_greek_cyrillic-ext_cyrillic */
+@font-face {
+ font-family: 'Open Sans';
+ font-style: italic;
+ font-weight: 400;
+ src: local('Open Sans Italic'), local('OpenSans-Italic'),
+ url('open-sans-v17-all-charsets-italic.woff2') format('woff2');
+}
+
+/* open-sans-600 - latin_vietnamese_latin-ext_greek-ext_greek_cyrillic-ext_cyrillic */
+@font-face {
+ font-family: 'Open Sans';
+ font-style: normal;
+ font-weight: 600;
+ src: local('Open Sans SemiBold'), local('OpenSans-SemiBold'),
+ url('open-sans-v17-all-charsets-600.woff2') format('woff2');
+}
+
+/* open-sans-600italic - latin_vietnamese_latin-ext_greek-ext_greek_cyrillic-ext_cyrillic */
+@font-face {
+ font-family: 'Open Sans';
+ font-style: italic;
+ font-weight: 600;
+ src: local('Open Sans SemiBold Italic'), local('OpenSans-SemiBoldItalic'),
+ url('open-sans-v17-all-charsets-600italic.woff2') format('woff2');
+}
+
+/* open-sans-700 - latin_vietnamese_latin-ext_greek-ext_greek_cyrillic-ext_cyrillic */
+@font-face {
+ font-family: 'Open Sans';
+ font-style: normal;
+ font-weight: 700;
+ src: local('Open Sans Bold'), local('OpenSans-Bold'),
+ url('open-sans-v17-all-charsets-700.woff2') format('woff2');
+}
+
+/* open-sans-700italic - latin_vietnamese_latin-ext_greek-ext_greek_cyrillic-ext_cyrillic */
+@font-face {
+ font-family: 'Open Sans';
+ font-style: italic;
+ font-weight: 700;
+ src: local('Open Sans Bold Italic'), local('OpenSans-BoldItalic'),
+ url('open-sans-v17-all-charsets-700italic.woff2') format('woff2');
+}
+
+/* open-sans-800 - latin_vietnamese_latin-ext_greek-ext_greek_cyrillic-ext_cyrillic */
+@font-face {
+ font-family: 'Open Sans';
+ font-style: normal;
+ font-weight: 800;
+ src: local('Open Sans ExtraBold'), local('OpenSans-ExtraBold'),
+ url('open-sans-v17-all-charsets-800.woff2') format('woff2');
+}
+
+/* open-sans-800italic - latin_vietnamese_latin-ext_greek-ext_greek_cyrillic-ext_cyrillic */
+@font-face {
+ font-family: 'Open Sans';
+ font-style: italic;
+ font-weight: 800;
+ src: local('Open Sans ExtraBold Italic'), local('OpenSans-ExtraBoldItalic'),
+ url('open-sans-v17-all-charsets-800italic.woff2') format('woff2');
+}
+
+/* source-code-pro-500 - latin_vietnamese_latin-ext_greek_cyrillic-ext_cyrillic */
+@font-face {
+ font-family: 'Source Code Pro';
+ font-style: normal;
+ font-weight: 500;
+ src: url('source-code-pro-v11-all-charsets-500.woff2') format('woff2');
+}
diff --git a/fonts/open-sans-v17-all-charsets-300.woff2 b/fonts/open-sans-v17-all-charsets-300.woff2
new file mode 100644
index 0000000..9f51be3
Binary files /dev/null and b/fonts/open-sans-v17-all-charsets-300.woff2 differ
diff --git a/fonts/open-sans-v17-all-charsets-300italic.woff2 b/fonts/open-sans-v17-all-charsets-300italic.woff2
new file mode 100644
index 0000000..2f54544
Binary files /dev/null and b/fonts/open-sans-v17-all-charsets-300italic.woff2 differ
diff --git a/fonts/open-sans-v17-all-charsets-600.woff2 b/fonts/open-sans-v17-all-charsets-600.woff2
new file mode 100644
index 0000000..f503d55
Binary files /dev/null and b/fonts/open-sans-v17-all-charsets-600.woff2 differ
diff --git a/fonts/open-sans-v17-all-charsets-600italic.woff2 b/fonts/open-sans-v17-all-charsets-600italic.woff2
new file mode 100644
index 0000000..c99aabe
Binary files /dev/null and b/fonts/open-sans-v17-all-charsets-600italic.woff2 differ
diff --git a/fonts/open-sans-v17-all-charsets-700.woff2 b/fonts/open-sans-v17-all-charsets-700.woff2
new file mode 100644
index 0000000..421a1ab
Binary files /dev/null and b/fonts/open-sans-v17-all-charsets-700.woff2 differ
diff --git a/fonts/open-sans-v17-all-charsets-700italic.woff2 b/fonts/open-sans-v17-all-charsets-700italic.woff2
new file mode 100644
index 0000000..12ce3d2
Binary files /dev/null and b/fonts/open-sans-v17-all-charsets-700italic.woff2 differ
diff --git a/fonts/open-sans-v17-all-charsets-800.woff2 b/fonts/open-sans-v17-all-charsets-800.woff2
new file mode 100644
index 0000000..c94a223
Binary files /dev/null and b/fonts/open-sans-v17-all-charsets-800.woff2 differ
diff --git a/fonts/open-sans-v17-all-charsets-800italic.woff2 b/fonts/open-sans-v17-all-charsets-800italic.woff2
new file mode 100644
index 0000000..eed7d3c
Binary files /dev/null and b/fonts/open-sans-v17-all-charsets-800italic.woff2 differ
diff --git a/fonts/open-sans-v17-all-charsets-italic.woff2 b/fonts/open-sans-v17-all-charsets-italic.woff2
new file mode 100644
index 0000000..398b68a
Binary files /dev/null and b/fonts/open-sans-v17-all-charsets-italic.woff2 differ
diff --git a/fonts/open-sans-v17-all-charsets-regular.woff2 b/fonts/open-sans-v17-all-charsets-regular.woff2
new file mode 100644
index 0000000..8383e94
Binary files /dev/null and b/fonts/open-sans-v17-all-charsets-regular.woff2 differ
diff --git a/fonts/source-code-pro-v11-all-charsets-500.woff2 b/fonts/source-code-pro-v11-all-charsets-500.woff2
new file mode 100644
index 0000000..7222456
Binary files /dev/null and b/fonts/source-code-pro-v11-all-charsets-500.woff2 differ
diff --git a/highlight.css b/highlight.css
new file mode 100644
index 0000000..ba57b82
--- /dev/null
+++ b/highlight.css
@@ -0,0 +1,82 @@
+/*
+ * An increased contrast highlighting scheme loosely based on the
+ * "Base16 Atelier Dune Light" theme by Bram de Haan
+ * (http://atelierbram.github.io/syntax-highlighting/atelier-schemes/dune)
+ * Original Base16 color scheme by Chris Kempson
+ * (https://github.com/chriskempson/base16)
+ */
+
+/* Comment */
+.hljs-comment,
+.hljs-quote {
+ color: #575757;
+}
+
+/* Red */
+.hljs-variable,
+.hljs-template-variable,
+.hljs-attribute,
+.hljs-tag,
+.hljs-name,
+.hljs-regexp,
+.hljs-link,
+.hljs-name,
+.hljs-selector-id,
+.hljs-selector-class {
+ color: #d70025;
+}
+
+/* Orange */
+.hljs-number,
+.hljs-meta,
+.hljs-built_in,
+.hljs-builtin-name,
+.hljs-literal,
+.hljs-type,
+.hljs-params {
+ color: #b21e00;
+}
+
+/* Green */
+.hljs-string,
+.hljs-symbol,
+.hljs-bullet {
+ color: #008200;
+}
+
+/* Blue */
+.hljs-title,
+.hljs-section {
+ color: #0030f2;
+}
+
+/* Purple */
+.hljs-keyword,
+.hljs-selector-tag {
+ color: #9d00ec;
+}
+
+.hljs {
+ display: block;
+ overflow-x: auto;
+ background: #f6f7f6;
+ color: #000;
+}
+
+.hljs-emphasis {
+ font-style: italic;
+}
+
+.hljs-strong {
+ font-weight: bold;
+}
+
+.hljs-addition {
+ color: #22863a;
+ background-color: #f0fff4;
+}
+
+.hljs-deletion {
+ color: #b31d28;
+ background-color: #ffeef0;
+}
diff --git a/highlight.js b/highlight.js
new file mode 100644
index 0000000..2b35ef7
--- /dev/null
+++ b/highlight.js
@@ -0,0 +1,1974 @@
+/*!
+ Highlight.js v11.7.0 (git: 82688fad18)
+ (c) 2006-2022 undefined and other contributors
+ License: BSD-3-Clause
+ */
+var hljs = function () {
+ "use strict";
+ var e = {exports: {}};
+
+ function t(e) {
+ return e instanceof Map ? e.clear = e.delete = e.set = () => {
+ throw Error("map is read-only")
+ } : e instanceof Set && (e.add = e.clear = e.delete = () => {
+ throw Error("set is read-only")
+ }), Object.freeze(e), Object.getOwnPropertyNames(e).forEach((n => {
+ var i = e[n]
+ ;"object" != typeof i || Object.isFrozen(i) || t(i)
+ })), e
+ }
+
+ e.exports = t, e.exports.default = t;
+
+ class n {
+ constructor(e) {
+ void 0 === e.data && (e.data = {}), this.data = e.data, this.isMatchIgnored = !1
+ }
+
+ ignoreMatch() {
+ this.isMatchIgnored = !0
+ }
+ }
+
+ function i(e) {
+ return e.replace(/&/g, "&").replace(//g, ">").replace(/"/g, """).replace(/'/g, "'")
+ }
+
+ function r(e, ...t) {
+ const n = Object.create(null);
+ for (const t in e) n[t] = e[t]
+ ;
+ return t.forEach((e => {
+ for (const t in e) n[t] = e[t]
+ })), n
+ }
+
+ const s = e => !!e.scope || e.sublanguage && e.language;
+
+ class o {
+ constructor(e, t) {
+ this.buffer = "", this.classPrefix = t.classPrefix, e.walk(this)
+ }
+
+ addText(e) {
+ this.buffer += i(e)
+ }
+
+ openNode(e) {
+ if (!s(e)) return;
+ let t = ""
+ ;t = e.sublanguage ? "language-" + e.language : ((e, {prefix: t}) => {
+ if (e.includes(".")) {
+ const n = e.split(".")
+ ;
+ return [`${t}${n.shift()}`, ...n.map(((e, t) => `${e}${"_".repeat(t + 1)}`))].join(" ")
+ }
+ return `${t}${e}`
+ })(e.scope, {prefix: this.classPrefix}), this.span(t)
+ }
+
+ closeNode(e) {
+ s(e) && (this.buffer += "")
+ }
+
+ value() {
+ return this.buffer
+ }
+
+ span(e) {
+ this.buffer += ``
+ }
+ }
+
+ const a = (e = {}) => {
+ const t = {children: []}
+ ;
+ return Object.assign(t, e), t
+ };
+
+ class c {
+ constructor() {
+ this.rootNode = a(), this.stack = [this.rootNode]
+ }
+
+ get top() {
+ return this.stack[this.stack.length - 1]
+ }
+
+ get root() {
+ return this.rootNode
+ }
+
+ add(e) {
+ this.top.children.push(e)
+ }
+
+ openNode(e) {
+ const t = a({scope: e})
+ ;this.add(t), this.stack.push(t)
+ }
+
+ closeNode() {
+ if (this.stack.length > 1) return this.stack.pop()
+ }
+
+ closeAllNodes() {
+ for (; this.closeNode();) ;
+ }
+
+ toJSON() {
+ return JSON.stringify(this.rootNode, null, 4)
+ }
+
+ walk(e) {
+ return this.constructor._walk(e, this.rootNode)
+ }
+
+ static _walk(e, t) {
+ return "string" == typeof t ? e.addText(t) : t.children && (e.openNode(t),
+ t.children.forEach((t => this._walk(e, t))), e.closeNode(t)), e
+ }
+
+ static _collapse(e) {
+ "string" != typeof e && e.children && (e.children.every((e => "string" == typeof e)) ? e.children = [e.children.join("")] : e.children.forEach((e => {
+ c._collapse(e)
+ })))
+ }
+ }
+
+ class l extends c {
+ constructor(e) {
+ super(), this.options = e
+ }
+
+ addKeyword(e, t) {
+ "" !== e && (this.openNode(t), this.addText(e), this.closeNode())
+ }
+
+ addText(e) {
+ "" !== e && this.add(e)
+ }
+
+ addSublanguage(e, t) {
+ const n = e.root
+ ;n.sublanguage = !0, n.language = t, this.add(n)
+ }
+
+ toHTML() {
+ return new o(this, this.options).value()
+ }
+
+ finalize() {
+ return !0
+ }
+ }
+
+ function g(e) {
+ return e ? "string" == typeof e ? e : e.source : null
+ }
+
+ function d(e) {
+ return p("(?=", e, ")")
+ }
+
+ function u(e) {
+ return p("(?:", e, ")*")
+ }
+
+ function h(e) {
+ return p("(?:", e, ")?")
+ }
+
+ function p(...e) {
+ return e.map((e => g(e))).join("")
+ }
+
+ function f(...e) {
+ const t = (e => {
+ const t = e[e.length - 1]
+ ;
+ return "object" == typeof t && t.constructor === Object ? (e.splice(e.length - 1, 1), t) : {}
+ })(e);
+ return "(" + (t.capture ? "" : "?:") + e.map((e => g(e))).join("|") + ")"
+ }
+
+ function b(e) {
+ return RegExp(e.toString() + "|").exec("").length - 1
+ }
+
+ const m = /\[(?:[^\\\]]|\\.)*\]|\(\??|\\([1-9][0-9]*)|\\./
+ ;
+
+ function E(e, {joinWith: t}) {
+ let n = 0;
+ return e.map((e => {
+ n += 1;
+ const t = n
+ ;let i = g(e), r = "";
+ for (; i.length > 0;) {
+ const e = m.exec(i);
+ if (!e) {
+ r += i;
+ break
+ }
+ r += i.substring(0, e.index),
+ i = i.substring(e.index + e[0].length), "\\" === e[0][0] && e[1] ? r += "\\" + (Number(e[1]) + t) : (r += e[0],
+ "(" === e[0] && n++)
+ }
+ return r
+ })).map((e => `(${e})`)).join(t)
+ }
+
+ const x = "[a-zA-Z]\\w*", w = "[a-zA-Z_]\\w*", y = "\\b\\d+(\\.\\d+)?",
+ _ = "(-?)(\\b0[xX][a-fA-F0-9]+|(\\b\\d+(\\.\\d*)?|\\.\\d+)([eE][-+]?\\d+)?)", O = "\\b(0b[01]+)", v = {
+ begin: "\\\\[\\s\\S]", relevance: 0
+ }, N = {
+ scope: "string", begin: "'", end: "'",
+ illegal: "\\n", contains: [v]
+ }, k = {
+ scope: "string", begin: '"', end: '"', illegal: "\\n",
+ contains: [v]
+ }, M = (e, t, n = {}) => {
+ const i = r({
+ scope: "comment", begin: e, end: t,
+ contains: []
+ }, n);
+ i.contains.push({
+ scope: "doctag",
+ begin: "[ ]*(?=(TODO|FIXME|NOTE|BUG|OPTIMIZE|HACK|XXX):)",
+ end: /(TODO|FIXME|NOTE|BUG|OPTIMIZE|HACK|XXX):/, excludeBegin: !0, relevance: 0
+ })
+ ;const s = f("I", "a", "is", "so", "us", "to", "at", "if", "in", "it", "on", /[A-Za-z]+['](d|ve|re|ll|t|s|n)/, /[A-Za-z]+[-][a-z]+/, /[A-Za-z][a-z]{2,}/)
+ ;
+ return i.contains.push({begin: p(/[ ]+/, "(", s, /[.]?[:]?([.][ ]|[ ])/, "){3}")}), i
+ }, S = M("//", "$"), R = M("/\\*", "\\*/"), j = M("#", "$");
+ var A = Object.freeze({
+ __proto__: null, MATCH_NOTHING_RE: /\b\B/, IDENT_RE: x, UNDERSCORE_IDENT_RE: w,
+ NUMBER_RE: y, C_NUMBER_RE: _, BINARY_NUMBER_RE: O,
+ RE_STARTERS_RE: "!|!=|!==|%|%=|&|&&|&=|\\*|\\*=|\\+|\\+=|,|-|-=|/=|/|:|;|<<|<<=|<=|<|===|==|=|>>>=|>>=|>=|>>>|>>|>|\\?|\\[|\\{|\\(|\\^|\\^=|\\||\\|=|\\|\\||~",
+ SHEBANG: (e = {}) => {
+ const t = /^#![ ]*\//
+ ;
+ return e.binary && (e.begin = p(t, /.*\b/, e.binary, /\b.*/)), r({
+ scope: "meta", begin: t,
+ end: /$/, relevance: 0, "on:begin": (e, t) => {
+ 0 !== e.index && t.ignoreMatch()
+ }
+ }, e)
+ },
+ BACKSLASH_ESCAPE: v, APOS_STRING_MODE: N, QUOTE_STRING_MODE: k, PHRASAL_WORDS_MODE: {
+ begin: /\b(a|an|the|are|I'm|isn't|don't|doesn't|won't|but|just|should|pretty|simply|enough|gonna|going|wtf|so|such|will|you|your|they|like|more)\b/
+ }, COMMENT: M, C_LINE_COMMENT_MODE: S, C_BLOCK_COMMENT_MODE: R, HASH_COMMENT_MODE: j,
+ NUMBER_MODE: {scope: "number", begin: y, relevance: 0}, C_NUMBER_MODE: {
+ scope: "number",
+ begin: _, relevance: 0
+ }, BINARY_NUMBER_MODE: {scope: "number", begin: O, relevance: 0},
+ REGEXP_MODE: {
+ begin: /(?=\/[^/\n]*\/)/, contains: [{
+ scope: "regexp", begin: /\//,
+ end: /\/[gimuy]*/, illegal: /\n/, contains: [v, {
+ begin: /\[/, end: /\]/, relevance: 0,
+ contains: [v]
+ }]
+ }]
+ }, TITLE_MODE: {scope: "title", begin: x, relevance: 0},
+ UNDERSCORE_TITLE_MODE: {scope: "title", begin: w, relevance: 0}, METHOD_GUARD: {
+ begin: "\\.\\s*[a-zA-Z_]\\w*", relevance: 0
+ }, END_SAME_AS_BEGIN: e => Object.assign(e, {
+ "on:begin": (e, t) => {
+ t.data._beginMatch = e[1]
+ }, "on:end": (e, t) => {
+ t.data._beginMatch !== e[1] && t.ignoreMatch()
+ }
+ })
+ });
+
+ function I(e, t) {
+ "." === e.input[e.index - 1] && t.ignoreMatch()
+ }
+
+ function T(e, t) {
+ void 0 !== e.className && (e.scope = e.className, delete e.className)
+ }
+
+ function L(e, t) {
+ t && e.beginKeywords && (e.begin = "\\b(" + e.beginKeywords.split(" ").join("|") + ")(?!\\.)(?=\\b|\\s)",
+ e.__beforeBegin = I, e.keywords = e.keywords || e.beginKeywords, delete e.beginKeywords,
+ void 0 === e.relevance && (e.relevance = 0))
+ }
+
+ function B(e, t) {
+ Array.isArray(e.illegal) && (e.illegal = f(...e.illegal))
+ }
+
+ function D(e, t) {
+ if (e.match) {
+ if (e.begin || e.end) throw Error("begin & end are not supported with match")
+ ;
+ e.begin = e.match, delete e.match
+ }
+ }
+
+ function H(e, t) {
+ void 0 === e.relevance && (e.relevance = 1)
+ }
+
+ const P = (e, t) => {
+ if (!e.beforeMatch) return
+ ;
+ if (e.starts) throw Error("beforeMatch cannot be used with starts")
+ ;
+ const n = Object.assign({}, e);
+ Object.keys(e).forEach((t => {
+ delete e[t]
+ })), e.keywords = n.keywords, e.begin = p(n.beforeMatch, d(n.begin)), e.starts = {
+ relevance: 0, contains: [Object.assign(n, {endsParent: !0})]
+ }, e.relevance = 0, delete n.beforeMatch
+ }, C = ["of", "and", "for", "in", "not", "or", "if", "then", "parent", "list", "value"]
+ ;
+
+ function $(e, t, n = "keyword") {
+ const i = Object.create(null)
+ ;
+ return "string" == typeof e ? r(n, e.split(" ")) : Array.isArray(e) ? r(n, e) : Object.keys(e).forEach((n => {
+ Object.assign(i, $(e[n], t, n))
+ })), i;
+
+ function r(e, n) {
+ t && (n = n.map((e => e.toLowerCase()))), n.forEach((t => {
+ const n = t.split("|")
+ ;i[n[0]] = [e, U(n[0], n[1])]
+ }))
+ }
+ }
+
+ function U(e, t) {
+ return t ? Number(t) : (e => C.includes(e.toLowerCase()))(e) ? 0 : 1
+ }
+
+ const z = {}, K = e => {
+ console.error(e)
+ }, W = (e, ...t) => {
+ console.log("WARN: " + e, ...t)
+ }, X = (e, t) => {
+ z[`${e}/${t}`] || (console.log(`Deprecated as of ${e}. ${t}`), z[`${e}/${t}`] = !0)
+ }, G = Error();
+
+ function Z(e, t, {key: n}) {
+ let i = 0;
+ const r = e[n], s = {}, o = {}
+ ;
+ for (let e = 1; e <= t.length; e++) o[e + i] = r[e], s[e + i] = !0, i += b(t[e - 1])
+ ;
+ e[n] = o, e[n]._emit = s, e[n]._multi = !0
+ }
+
+ function F(e) {
+ (e => {
+ e.scope && "object" == typeof e.scope && null !== e.scope && (e.beginScope = e.scope,
+ delete e.scope)
+ })(e), "string" == typeof e.beginScope && (e.beginScope = {
+ _wrap: e.beginScope
+ }), "string" == typeof e.endScope && (e.endScope = {
+ _wrap: e.endScope
+ }), (e => {
+ if (Array.isArray(e.begin)) {
+ if (e.skip || e.excludeBegin || e.returnBegin) throw K("skip, excludeBegin, returnBegin not compatible with beginScope: {}"),
+ G
+ ;
+ if ("object" != typeof e.beginScope || null === e.beginScope) throw K("beginScope must be object"),
+ G;
+ Z(e, e.begin, {key: "beginScope"}), e.begin = E(e.begin, {joinWith: ""})
+ }
+ })(e), (e => {
+ if (Array.isArray(e.end)) {
+ if (e.skip || e.excludeEnd || e.returnEnd) throw K("skip, excludeEnd, returnEnd not compatible with endScope: {}"),
+ G
+ ;
+ if ("object" != typeof e.endScope || null === e.endScope) throw K("endScope must be object"),
+ G;
+ Z(e, e.end, {key: "endScope"}), e.end = E(e.end, {joinWith: ""})
+ }
+ })(e)
+ }
+
+ function V(e) {
+ function t(t, n) {
+ return RegExp(g(t), "m" + (e.case_insensitive ? "i" : "") + (e.unicodeRegex ? "u" : "") + (n ? "g" : ""))
+ }
+
+ class n {
+ constructor() {
+ this.matchIndexes = {}, this.regexes = [], this.matchAt = 1, this.position = 0
+ }
+
+ addRule(e, t) {
+ t.position = this.position++, this.matchIndexes[this.matchAt] = t, this.regexes.push([t, e]),
+ this.matchAt += b(e) + 1
+ }
+
+ compile() {
+ 0 === this.regexes.length && (this.exec = () => null)
+ ;const e = this.regexes.map((e => e[1]));
+ this.matcherRe = t(E(e, {
+ joinWith: "|"
+ }), !0), this.lastIndex = 0
+ }
+
+ exec(e) {
+ this.matcherRe.lastIndex = this.lastIndex
+ ;const t = this.matcherRe.exec(e);
+ if (!t) return null
+ ;
+ const n = t.findIndex(((e, t) => t > 0 && void 0 !== e)), i = this.matchIndexes[n]
+ ;
+ return t.splice(0, n), Object.assign(t, i)
+ }
+ }
+
+ class i {
+ constructor() {
+ this.rules = [], this.multiRegexes = [],
+ this.count = 0, this.lastIndex = 0, this.regexIndex = 0
+ }
+
+ getMatcher(e) {
+ if (this.multiRegexes[e]) return this.multiRegexes[e];
+ const t = new n
+ ;
+ return this.rules.slice(e).forEach((([e, n]) => t.addRule(e, n))),
+ t.compile(), this.multiRegexes[e] = t, t
+ }
+
+ resumingScanAtSamePosition() {
+ return 0 !== this.regexIndex
+ }
+
+ considerAll() {
+ this.regexIndex = 0
+ }
+
+ addRule(e, t) {
+ this.rules.push([e, t]), "begin" === t.type && this.count++
+ }
+
+ exec(e) {
+ const t = this.getMatcher(this.regexIndex);
+ t.lastIndex = this.lastIndex
+ ;let n = t.exec(e)
+ ;
+ if (this.resumingScanAtSamePosition()) if (n && n.index === this.lastIndex) ; else {
+ const t = this.getMatcher(0);
+ t.lastIndex = this.lastIndex + 1, n = t.exec(e)
+ }
+ return n && (this.regexIndex += n.position + 1,
+ this.regexIndex === this.count && this.considerAll()), n
+ }
+ }
+
+ if (e.compilerExtensions || (e.compilerExtensions = []),
+ e.contains && e.contains.includes("self")) throw Error("ERR: contains `self` is not supported at the top-level of a language. See documentation.")
+ ;
+ return e.classNameAliases = r(e.classNameAliases || {}), function n(s, o) {
+ const a = s
+ ;
+ if (s.isCompiled) return a
+ ;
+ [T, D, F, P].forEach((e => e(s, o))), e.compilerExtensions.forEach((e => e(s, o))),
+ s.__beforeBegin = null, [L, B, H].forEach((e => e(s, o))), s.isCompiled = !0;
+ let c = null
+ ;
+ return "object" == typeof s.keywords && s.keywords.$pattern && (s.keywords = Object.assign({}, s.keywords),
+ c = s.keywords.$pattern,
+ delete s.keywords.$pattern), c = c || /\w+/, s.keywords && (s.keywords = $(s.keywords, e.case_insensitive)),
+ a.keywordPatternRe = t(c, !0),
+ o && (s.begin || (s.begin = /\B|\b/), a.beginRe = t(a.begin), s.end || s.endsWithParent || (s.end = /\B|\b/),
+ s.end && (a.endRe = t(a.end)),
+ a.terminatorEnd = g(a.end) || "", s.endsWithParent && o.terminatorEnd && (a.terminatorEnd += (s.end ? "|" : "") + o.terminatorEnd)),
+ s.illegal && (a.illegalRe = t(s.illegal)),
+ s.contains || (s.contains = []), s.contains = [].concat(...s.contains.map((e => (e => (e.variants && !e.cachedVariants && (e.cachedVariants = e.variants.map((t => r(e, {
+ variants: null
+ }, t)))), e.cachedVariants ? e.cachedVariants : q(e) ? r(e, {
+ starts: e.starts ? r(e.starts) : null
+ }) : Object.isFrozen(e) ? r(e) : e))("self" === e ? s : e)))), s.contains.forEach((e => {
+ n(e, a)
+ })), s.starts && n(s.starts, o), a.matcher = (e => {
+ const t = new i
+ ;
+ return e.contains.forEach((e => t.addRule(e.begin, {
+ rule: e, type: "begin"
+ }))), e.terminatorEnd && t.addRule(e.terminatorEnd, {
+ type: "end"
+ }), e.illegal && t.addRule(e.illegal, {type: "illegal"}), t
+ })(a), a
+ }(e)
+ }
+
+ function q(e) {
+ return !!e && (e.endsWithParent || q(e.starts))
+ }
+
+ class J extends Error {
+ constructor(e, t) {
+ super(e), this.name = "HTMLInjectionError", this.html = t
+ }
+ }
+
+ const Y = i, Q = r, ee = Symbol("nomatch");
+ var te = (t => {
+ const i = Object.create(null), r = Object.create(null), s = [];
+ let o = !0
+ ;const a = "Could not find the language '{}', did you forget to load/include a language module?", c = {
+ disableAutodetect: !0, name: "Plain text", contains: []
+ };
+ let g = {
+ ignoreUnescapedHTML: !1, throwUnescapedHTML: !1, noHighlightRe: /^(no-?highlight)$/i,
+ languageDetectRe: /\blang(?:uage)?-([\w-]+)\b/i, classPrefix: "hljs-",
+ cssSelector: "pre code", languages: null, __emitter: l
+ };
+
+ function b(e) {
+ return g.noHighlightRe.test(e)
+ }
+
+ function m(e, t, n) {
+ let i = "", r = ""
+ ;"object" == typeof t ? (i = e,
+ n = t.ignoreIllegals, r = t.language) : (X("10.7.0", "highlight(lang, code, ...args) has been deprecated."),
+ X("10.7.0", "Please use highlight(code, options) instead.\nhttps://github.com/highlightjs/highlight.js/issues/2277"),
+ r = e, i = t), void 0 === n && (n = !0);
+ const s = {code: i, language: r};
+ k("before:highlight", s)
+ ;const o = s.result ? s.result : E(s.language, s.code, n)
+ ;
+ return o.code = s.code, k("after:highlight", o), o
+ }
+
+ function E(e, t, r, s) {
+ const c = Object.create(null);
+
+ function l() {
+ if (!N.keywords) return void M.addText(S)
+ ;
+ let e = 0;
+ N.keywordPatternRe.lastIndex = 0;
+ let t = N.keywordPatternRe.exec(S), n = ""
+ ;
+ for (; t;) {
+ n += S.substring(e, t.index)
+ ;const r = y.case_insensitive ? t[0].toLowerCase() : t[0], s = (i = r, N.keywords[i]);
+ if (s) {
+ const [e, i] = s
+ ;
+ if (M.addText(n), n = "", c[r] = (c[r] || 0) + 1, c[r] <= 7 && (R += i), e.startsWith("_")) n += t[0]; else {
+ const n = y.classNameAliases[e] || e;
+ M.addKeyword(t[0], n)
+ }
+ } else n += t[0]
+ ;
+ e = N.keywordPatternRe.lastIndex, t = N.keywordPatternRe.exec(S)
+ }
+ var i
+ ;n += S.substring(e), M.addText(n)
+ }
+
+ function d() {
+ null != N.subLanguage ? (() => {
+ if ("" === S) return;
+ let e = null;
+ if ("string" == typeof N.subLanguage) {
+ if (!i[N.subLanguage]) return void M.addText(S)
+ ;
+ e = E(N.subLanguage, S, !0, k[N.subLanguage]), k[N.subLanguage] = e._top
+ } else e = x(S, N.subLanguage.length ? N.subLanguage : null)
+ ;
+ N.relevance > 0 && (R += e.relevance), M.addSublanguage(e._emitter, e.language)
+ })() : l(), S = ""
+ }
+
+ function u(e, t) {
+ let n = 1;
+ const i = t.length - 1;
+ for (; n <= i;) {
+ if (!e._emit[n]) {
+ n++;
+ continue
+ }
+ const i = y.classNameAliases[e[n]] || e[n], r = t[n]
+ ;i ? M.addKeyword(r, i) : (S = r, l(), S = ""), n++
+ }
+ }
+
+ function h(e, t) {
+ return e.scope && "string" == typeof e.scope && M.openNode(y.classNameAliases[e.scope] || e.scope),
+ e.beginScope && (e.beginScope._wrap ? (M.addKeyword(S, y.classNameAliases[e.beginScope._wrap] || e.beginScope._wrap),
+ S = "") : e.beginScope._multi && (u(e.beginScope, t), S = "")), N = Object.create(e, {
+ parent: {
+ value: N
+ }
+ }), N
+ }
+
+ function p(e, t, i) {
+ let r = ((e, t) => {
+ const n = e && e.exec(t)
+ ;
+ return n && 0 === n.index
+ })(e.endRe, i);
+ if (r) {
+ if (e["on:end"]) {
+ const i = new n(e)
+ ;e["on:end"](t, i), i.isMatchIgnored && (r = !1)
+ }
+ if (r) {
+ for (; e.endsParent && e.parent;) e = e.parent;
+ return e
+ }
+ }
+ if (e.endsWithParent) return p(e.parent, t, i)
+ }
+
+ function f(e) {
+ return 0 === N.matcher.regexIndex ? (S += e[0], 1) : (I = !0, 0)
+ }
+
+ function b(e) {
+ const n = e[0], i = t.substring(e.index), r = p(N, e, i);
+ if (!r) return ee;
+ const s = N
+ ;N.endScope && N.endScope._wrap ? (d(),
+ M.addKeyword(n, N.endScope._wrap)) : N.endScope && N.endScope._multi ? (d(),
+ u(N.endScope, e)) : s.skip ? S += n : (s.returnEnd || s.excludeEnd || (S += n),
+ d(), s.excludeEnd && (S = n));
+ do {
+ N.scope && M.closeNode(), N.skip || N.subLanguage || (R += N.relevance), N = N.parent
+ } while (N !== r.parent);
+ return r.starts && h(r.starts, e), s.returnEnd ? 0 : n.length
+ }
+
+ let m = {};
+
+ function w(i, s) {
+ const a = s && s[0];
+ if (S += i, null == a) return d(), 0
+ ;
+ if ("begin" === m.type && "end" === s.type && m.index === s.index && "" === a) {
+ if (S += t.slice(s.index, s.index + 1), !o) {
+ const t = Error(`0 width match regex (${e})`)
+ ;
+ throw t.languageName = e, t.badRule = m.rule, t
+ }
+ return 1
+ }
+ if (m = s, "begin" === s.type) return (e => {
+ const t = e[0], i = e.rule, r = new n(i), s = [i.__beforeBegin, i["on:begin"]]
+ ;
+ for (const n of s) if (n && (n(e, r), r.isMatchIgnored)) return f(t)
+ ;
+ return i.skip ? S += t : (i.excludeBegin && (S += t),
+ d(), i.returnBegin || i.excludeBegin || (S = t)), h(i, e), i.returnBegin ? 0 : t.length
+ })(s)
+ ;
+ if ("illegal" === s.type && !r) {
+ const e = Error('Illegal lexeme "' + a + '" for mode "' + (N.scope || "
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Flow tree definitions
+The flow tree definitions describe the way how the tree will be traversed. +There are 2 basic types which get broken down afterward:
+-
+
- sequences: A Sequence performs every child as long as they are return
Success. +If otherwise, the sequence instantly stops with thefailurestatus
+ - fallbacks: A fallback performs children until the first
Success.
+
Combining the aforementioned flow trees, we can get any type of logic.
+ +
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
diff --git a/imports.html b/imports.html
new file mode 100644
index 0000000..bb42f7f
--- /dev/null
+++ b/imports.html
@@ -0,0 +1,279 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Higher order tree
+The definitions can be passed as arguments in invocations for other definitions.
+The definitions should accept tree as a parameter.
To invoke the definition, coming from parameters, the definition should have a name and '(..)' after,
+like that:operation(..)
Motivation
+To reduce the amount of redundancy in implementing some logic. +The higher order tree enables to construct abstractions that will be easily +used in the next tree definitions reducing the amount of code.
+Syntax
+...
+
+// the checked_task declares acceptance of 2 tree definitions
+fallback checked_task(cond:tree, task:tree){
+ // invoke a tree definition from parameters
+ cond(..)
+ // invoke a tree definition from parameters
+ task(..)
+}
+
+sequence handle(item:object) {
+ // higher order invocation in arguments
+ checked_task(close_enough(item), approach(item))
+ checked_task(is_graspable(item), grasp(item))
+ // The lambdas can be used as higher-order tree as well
+ checked_task(enough_space(item), sequence {
+ move(item)
+ save(tem)
+ })
+}
+Parameters
+For now, the tree does not perform the parameter capturing. +It means the following:
+-
+
- static constants are passed as is +
- pointers are resolved at the moment of invocation +
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
diff --git a/index.html b/index.html
new file mode 100644
index 0000000..aad2ebb
--- /dev/null
+++ b/index.html
@@ -0,0 +1,271 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Imports
+The code of the trees can be organized as a project, breaking down the tree definitions into different files. +It enables the project to be organized logically avoiding redundancy.
+Therefore, the imports can appear in the file anywhere but are mostly grouped at the top, forming a sort of header.
+Syntax
+The whole file
+To import the whole file, the following syntax needs to be applied:
+import "nested/impls.tree"
+import "/usr/home/projects/impls.tree"
+import "C:\projects\forester\tree\tests\plain_project\nested\impls.tree"
+The definition with alias
+import "nested/impls.tree" {
+ grasp => grasp_ball,
+}
+Import path
+The path of the imports can be:
+-
+
- absolute :
C:\plain_project\nested\impls.tree
+ - relative :
nested/impls.tree
+
Absolute path
+import "C:\projects\forester\tree\tests\plain_project\nested\impls.tree"
+Relative path
+The relative path relates to the root of the project, that is pointed out in the start. +Typically, the structure is the following:
+- project_folder
+ - main.tree // the file that has a root tree
+ - .. folders
+ - folder
+ - def.tree
+ - folder_nested
+ - another_nested
+ - file.tree
+Here the import of the file.tree can be
import "folder_nested/another_nested/file.tree"
+in any other file.
+Aliases
+To avoid the problem of ambiguous names when several tree definitions with the same name can be imported, +the aliases can come to the rescue.
+They allow renaming tree definition while imports:
+import "/robot_specific_ops/cv.tree" // has a tree def cv
+import "/common_ops/cv.tree" { // also has a tree def cv
+ cv => com_cv // to avoid ambiguity, we can rename it using an alias.
+}
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
diff --git a/intellij.html b/intellij.html
new file mode 100644
index 0000000..0afc5d4
--- /dev/null
+++ b/intellij.html
@@ -0,0 +1,280 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ 
Forester
+Forester represents a framework that provides the set of tools to perform the effective orchestration of the set of tasks.
+The tasks can be performed synchronously or asynchronously, locally or remotely.
+Forester takes care of the correct performance and distribution of the tasks.
+the main concept of the framework
+is the flow based on the behavior trees
+it can be effectively used in the game, ai, robotic areas, or anywhere where the workflow engine can be applied.
Why Forester
+The main idea and the target of Forester is to make the process of chaining a complex logic
+of the different tasks together effective and easy.
The following set of features is summoned to highlight the framework among the others.
+The dsl to describe the logic
+One of the problems that Forester endeavours to solve is to isolate the logic of the orchestration \
+from the logic of the tasks implementations and therefore the dsl ('Tree') is provided.
+The Dsl is script based and supports a number of features that can alleviate the writing of the big trees.
The framework provides the ability to create async and sync tasks
+The tasks (leaves of the tree) can be fulfilled with the asynchronous and synchronous logic. +The difference here is the async tasks will not block the tree while sync tasks will block the tree.
+The framework provides the ability to create remote and local tasks (TBD)
+The tasks can represent as a local stateless/stateful blocks of logic as the remote servers or procedures.
+The tooling to visualize and trace the execution of the tree
+The tree can be visualized and traced in order to see how it is supposed to be executed.
+The simulation mode is supposed to aid with the design decisions
+The special simulation mode aims to help, quickly to see how the tree will be unfolding and how it can be designed.
+The optimizations and analysis of the tree (TBD)
+The language provides a set of optimizations and validations to either ensure the logic is correct
+or perform some validations on it.
The validations engine allows the users to create the manually defined validations (TBD)
+The user-defined validations can be useful to restrict some features of the framework.
+Integrations (TBD)
+Why behavior trees
+Firstly, they provide a strong math abstraction over the orchestration logic
+and enables to separate the business logic and the tree logic itself.
+One of the great advantages of the behavior trees is that they provide a good conception of modularity.
+On the other hand, they have only a small set of logically conjucted components making the design easier,
Articles that introduce into the basics of the behaviour trees
+-
+
- Chris Simpson’s Behavior trees for AI: How they work +
- Introduction to behavior trees +
- State Machines vs Behavior Trees +
Useful libraries
+-
+
- BehaviorTree.CPP : the brilliant library provides the implementation on CPP. +
- Beehave : behavior tree AI for Godot Engine. +
- Bonsai : the great library for behavior trees in rust. +
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
diff --git a/intro.html b/intro.html
new file mode 100644
index 0000000..aad2ebb
--- /dev/null
+++ b/intro.html
@@ -0,0 +1,271 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Intellij plugin
+Introduction
+This plugin enriches your development experience by providing seamless task orchestration capabilities, +allowing you to perform tasks synchronously or asynchronously, +locally or remotely, all within the familiar IntelliJ environment. +Whether you are working on game development, artificial intelligence, robotics, or any domain requiring efficient task management, +the Forester-IntelliJ Plugin is here to simplify your workflow and boost productivity.
+Installation
+To install the Forester-IntelliJ Plugin, follow these simple steps:
+-
+
- Open your IntelliJ IDE. +
- Go to "Settings" or "Preferences" from the main menu. +
- Choose "Plugins" from the left-hand side menu. +
- Click on the "Marketplace" or "Browse repositories" button. +
- Search for "Forester-IntelliJ Plugin." +
- Click "Install" and restart the IDE to activate the plugin. +
Features
+Syntax Highlighting
+The Forester-IntelliJ Plugin includes specialized syntax highlighting, making it easier for you to identify and distinguish Forester-related elements in your code. +This feature helps improve code readability and ensures that your tasks are accurately represented.
+Folding
+With the folding feature, you can conveniently collapse sections of your behavior trees, making complex task structures more manageable. +Folding enhances code organization and enables you to focus on specific parts of the task tree as needed.
+Structure View
+The plugin provides an intuitive Structure View that displays the hierarchical organization of your behavior trees. +Quickly navigate through the task structure, identify parent-child relationships, and easily access specific sections of your tasks with ease.
+Task Visualization
+The Forester-IntelliJ Plugin offers a task to visualize the tree that brings behavior trees to life. +Gain valuable insights into your task flows and dependencies through interactive graphical representations. +This visual aid fosters a better understanding of your task hierarchy, facilitating effective task organization and management.
+Task Simulation
+With the task simulation feature, you can run and test your behavior trees directly within the IntelliJ IDE. +Simulate task executions to verify their correctness and efficiency, enabling you to fine-tune your task orchestration process.
+Usage
+Creating a New Task
+-
+
- Navigate to the "Edit configurations" menu in your IntelliJ IDE. +
- Select "New Task" to create a new task. +
Running Simulation and Visualization Task
+-
+
- Open the behavior tree you want to simulate. +
- Click on the "Run Simulation" button to initiate the simulation process (on the gutter on the root tree) +
- Observe the execution flow and identify any potential issues or optimizations. +
Links
+ + +
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
diff --git a/intro_lang.html b/intro_lang.html
new file mode 100644
index 0000000..b21a9ba
--- /dev/null
+++ b/intro_lang.html
@@ -0,0 +1,256 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
Forester
+Forester represents a framework that provides the set of tools to perform the effective orchestration of the set of tasks.
+The tasks can be performed synchronously or asynchronously, locally or remotely.
+Forester takes care of the correct performance and distribution of the tasks.
+the main concept of the framework
+is the flow based on the behavior trees
+it can be effectively used in the game, ai, robotic areas, or anywhere where the workflow engine can be applied.
Why Forester
+The main idea and the target of Forester is to make the process of chaining a complex logic
+of the different tasks together effective and easy.
The following set of features is summoned to highlight the framework among the others.
+The dsl to describe the logic
+One of the problems that Forester endeavours to solve is to isolate the logic of the orchestration \
+from the logic of the tasks implementations and therefore the dsl ('Tree') is provided.
+The Dsl is script based and supports a number of features that can alleviate the writing of the big trees.
The framework provides the ability to create async and sync tasks
+The tasks (leaves of the tree) can be fulfilled with the asynchronous and synchronous logic. +The difference here is the async tasks will not block the tree while sync tasks will block the tree.
+The framework provides the ability to create remote and local tasks (TBD)
+The tasks can represent as a local stateless/stateful blocks of logic as the remote servers or procedures.
+The tooling to visualize and trace the execution of the tree
+The tree can be visualized and traced in order to see how it is supposed to be executed.
+The simulation mode is supposed to aid with the design decisions
+The special simulation mode aims to help, quickly to see how the tree will be unfolding and how it can be designed.
+The optimizations and analysis of the tree (TBD)
+The language provides a set of optimizations and validations to either ensure the logic is correct
+or perform some validations on it.
The validations engine allows the users to create the manually defined validations (TBD)
+The user-defined validations can be useful to restrict some features of the framework.
+Integrations (TBD)
+Why behavior trees
+Firstly, they provide a strong math abstraction over the orchestration logic
+and enables to separate the business logic and the tree logic itself.
+One of the great advantages of the behavior trees is that they provide a good conception of modularity.
+On the other hand, they have only a small set of logically conjucted components making the design easier,
Articles that introduce into the basics of the behaviour trees
+-
+
- Chris Simpson’s Behavior trees for AI: How they work +
- Introduction to behavior trees +
- State Machines vs Behavior Trees +
Useful libraries
+-
+
- BehaviorTree.CPP : the brilliant library provides the implementation on CPP. +
- Beehave : behavior tree AI for Godot Engine. +
- Bonsai : the great library for behavior trees in rust. +
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
diff --git a/invoc_intro.html b/invoc_intro.html
new file mode 100644
index 0000000..e320c25
--- /dev/null
+++ b/invoc_intro.html
@@ -0,0 +1,263 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Tree language
+The tree language is a frontend for the framework itself.
+Generally, the language is a simple dsl encompassing the basic abstractions
+and enabling to create of the building block upon the abstractions \
Why the language is needed
+The basic idea behind the language is an attempt to provide a set of generalizations
+which will alleviate the redundancy in some cases.
-
+
- The language allows creating the tree definitions accepting other trees as parameters (higher order trees) +
- The language provides lambda definitions +
The syntax of the language is very simple and is described in this chapter.
+Structure of the project
+The scripts are supposed to be in the folder which is marked as root directory.
+All imports start from the root and represent a path relating to the root directory:
- project_folder
+ - main.tree
+ - gripper.tree
+ - cv.tree
+ - utility
+ - utility.tree
+ - helpers.tree
+The project should have at least one root tree definition. If the project has several,
+the one that is supposed to run needs to be pointed out to.
File extension
+The files have the extension tree.
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
diff --git a/lambda.html b/lambda.html
new file mode 100644
index 0000000..862c1ea
--- /dev/null
+++ b/lambda.html
@@ -0,0 +1,294 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Invocations
+The language provides the possibility to invoke the definitions +or lambdas in the body of the other definitions
+
+import "std::actions"
+
+impl handle_distance(item:object);
+
+sequence main_seq {
+ inverter fail("for test")
+ success()
+}
+
+sequence check_distance(item:object){
+ store("log","start")
+ handle_distance(item)
+ store("log","end")
+}
+
+// definition
+root main sequence {
+ // invocation
+ main_seq()
+
+ // another invocation
+ check_distance({"x":1,"y":2})
+}
+Other types of invocation
+The other types of invocation are described in the following sections but briefly are:
+-
+
- higher order tree invocation: a possibility to pass a tree definition as parameter +
- lambda invocation: an anonymous definition that creates and gets invoked at the same time. +
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
diff --git a/mark.min.js b/mark.min.js
new file mode 100644
index 0000000..1636231
--- /dev/null
+++ b/mark.min.js
@@ -0,0 +1,7 @@
+/*!***************************************************
+* mark.js v8.11.1
+* https://markjs.io/
+* Copyright (c) 2014–2018, Julian Kühnel
+* Released under the MIT license https://git.io/vwTVl
+*****************************************************/
+!function(e,t){"object"==typeof exports&&"undefined"!=typeof module?module.exports=t():"function"==typeof define&&define.amd?define(t):e.Mark=t()}(this,function(){"use strict";var e="function"==typeof Symbol&&"symbol"==typeof Symbol.iterator?function(e){return typeof e}:function(e){return e&&"function"==typeof Symbol&&e.constructor===Symbol&&e!==Symbol.prototype?"symbol":typeof e},t=function(e,t){if(!(e instanceof t))throw new TypeError("Cannot call a class as a function")},n=function(){function e(e,t){for(var n=0;n
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Lambda
+The anonymous definitions can be defined and instantly invoked at the same time. +The definitions are unique and every time the new definition is created.
+-
+
- They don't have a name +
- They are unique +
- They don't have arguments +
Only the elements of Flow can be used in lambdas +The actions always have to be defined explicitly.
+impl job();
+
+root main {
+ // lambda invocation
+ sequence {
+ job()
+ job()
+ job()
+ }
+ // another lambda invocation
+ fallback {
+ sequence {
+ job()
+ job()
+ }
+ // the second level of lambda
+ sequence {
+ job()
+ // also lambda, but the backets are omitted.
+ r_sequence job()
+ }
+ }
+
+}
+Parameter
+Lambda can be used as parameters as well.
+impl savepoint();
+impl job();
+
+sequence wrapper(item:tree){
+ savepoint()
+ item(..)
+ savepoint()
+}
+
+root main sequence {
+ wrapper(
+ sequence {
+ job()
+ job()
+ job()
+ }
+ )
+ wrapper(
+ item =
+ fallback {
+ job()
+ job()
+ job()
+ }
+ )
+
+}
+"),zk=t=>t.replace(If,"#br#"),aG=t=>{let e="";return t&&(e=window.location.protocol+"//"+window.location.host+window.location.pathname+window.location.search,e=e.replaceAll(/\(/g,"\\("),e=e.replaceAll(/\)/g,"\\)")),e},Mr=t=>!(t===!1||["false","null","0"].includes(String(t).trim().toLowerCase())),ja=function(t){let e=t;return t.indexOf("~")!==-1?(e=e.replace(/~([^~].*)/,"<$1"),e=e.replace(/~([^~]*)$/,">$1"),ja(e)):e},pe={getRows:tG,sanitizeText:ai,sanitizeTextOrArray:eG,hasBreaks:rG,splitBreaks:nG,lineBreakRegex:If,removeScript:qk,getUrl:aG,evaluate:Mr},Nf={min:{r:0,g:0,b:0,s:0,l:0,a:0},max:{r:255,g:255,b:255,h:360,s:100,l:100,a:1},clamp:{r:t=>t>=255?255:t<0?0:t,g:t=>t>=255?255:t<0?0:t,b:t=>t>=255?255:t<0?0:t,h:t=>t%360,s:t=>t>=100?100:t<0?0:t,l:t=>t>=100?100:t<0?0:t,a:t=>t>=1?1:t<0?0:t},toLinear:t=>{const e=t/255;return t>.03928?Math.pow((e+.055)/1.055,2.4):e/12.92},hue2rgb:(t,e,r)=>(r<0&&(r+=1),r>1&&(r-=1),r<1/6?t+(e-t)*6*r:r<1/2?e:r<2/3?t+(e-t)*(2/3-r)*6:t),hsl2rgb:({h:t,s:e,l:r},n)=>{if(!e)return r*2.55;t/=360,e/=100,r/=100;const i=r<.5?r*(1+e):r+e-r*e,a=2*r-i;switch(n){case"r":return Nf.hue2rgb(a,i,t+1/3)*255;case"g":return Nf.hue2rgb(a,i,t)*255;case"b":return Nf.hue2rgb(a,i,t-1/3)*255}},rgb2hsl:({r:t,g:e,b:r},n)=>{t/=255,e/=255,r/=255;const i=Math.max(t,e,r),a=Math.min(t,e,r),s=(i+a)/2;if(n==="l")return s*100;if(i===a)return 0;const o=i-a,l=s>.5?o/(2-i-a):o/(i+a);if(n==="s")return l*100;switch(i){case t:return((e-r)/o+(e
"},r),pe.lineBreakRegex.test(t)))return t;const n=t.split(" "),i=[];let a="";return n.forEach((s,o)=>{const l=Bi(`${s} `,r),u=Bi(a,r);if(l>e){const{hyphenatedStrings:f,remainingWord:p}=lX(s,e,"-",r);i.push(a,...f),a=p}else u+l>=e?(i.push(a),a=s):a=[a,s].filter(Boolean).join(" ");o+1===n.length&&i.push(a)}),i.filter(s=>s!=="").join(r.joinWith)},(t,e,r)=>`${t}${e}${r.fontSize}${r.fontWeight}${r.fontFamily}${r.joinWith}`),lX=Gf((t,e,r="-",n)=>{n=Object.assign({fontSize:12,fontWeight:400,fontFamily:"Arial",margin:0},n);const i=t.split(""),a=[];let s="";return i.forEach((o,l)=>{const u=`${s}${o}`;if(Bi(u,n)>=e){const d=l+1,f=i.length===d,p=`${u}${r}`;a.push(f?u:p),s=""}else s=u}),{hyphenatedStrings:a,remainingWord:s}},(t,e,r="-",n)=>`${t}${e}${r}${n.fontSize}${n.fontWeight}${n.fontFamily}`),eg=function(t,e){return e=Object.assign({fontSize:12,fontWeight:400,fontFamily:"Arial",margin:15},e),rg(t,e).height},Bi=function(t,e){return e=Object.assign({fontSize:12,fontWeight:400,fontFamily:"Arial"},e),rg(t,e).width},rg=Gf(function(t,e){e=Object.assign({fontSize:12,fontWeight:400,fontFamily:"Arial"},e);const{fontSize:r,fontFamily:n,fontWeight:i}=e;if(!t)return{width:0,height:0};const a=["sans-serif",n],s=t.split(pe.lineBreakRegex),o=[],l=St("body");if(!l.remove)return{width:0,height:0,lineHeight:0};const u=l.append("svg");for(const d of a){let f=0;const p={width:0,height:0,lineHeight:0};for(const m of s){const _=sX();_.text=m;const y=oX(u,_).style("font-size",r).style("font-weight",i).style("font-family",d),b=(y._groups||y)[0][0].getBBox();p.width=Math.round(Math.max(p.width,b.width)),f=Math.round(b.height),p.height+=f,p.lineHeight=Math.round(Math.max(p.lineHeight,f))}o.push(p)}u.remove();const h=isNaN(o[1].height)||isNaN(o[1].width)||isNaN(o[1].lineHeight)||o[0].height>o[1].height&&o[0].width>o[1].width&&o[0].lineHeight>o[1].lineHeight?0:1;return o[h]},(t,e)=>`${t}${e.fontSize}${e.fontWeight}${e.fontFamily}`),cX=class{constructor(e,r){this.deterministic=e,this.seed=r,this.count=r?r.length:0}next(){return this.deterministic?this.count++:Date.now()}};let jf;const uX=function(t){return jf=jf||document.createElement("div"),t=escape(t).replace(/%26/g,"&").replace(/%23/g,"#").replace(/%3B/g,";"),jf.innerHTML=t,unescape(jf.textContent)},Vs=t=>{if(H.debug("directiveSanitizer called with",t),typeof t=="object"&&(t.length?t.forEach(e=>Vs(e)):Object.keys(t).forEach(e=>{H.debug("Checking key",e),e.indexOf("__")===0&&(H.debug("sanitize deleting __ option",e),delete t[e]),e.indexOf("proto")>=0&&(H.debug("sanitize deleting proto option",e),delete t[e]),e.indexOf("constr")>=0&&(H.debug("sanitize deleting constr option",e),delete t[e]),e.indexOf("themeCSS")>=0&&(H.debug("sanitizing themeCss option"),t[e]=$f(t[e])),e.indexOf("fontFamily")>=0&&(H.debug("sanitizing fontFamily option"),t[e]=$f(t[e])),e.indexOf("altFontFamily")>=0&&(H.debug("sanitizing altFontFamily option"),t[e]=$f(t[e])),vG.indexOf(e)<0?(H.debug("sanitize deleting option",e),delete t[e]):typeof t[e]=="object"&&(H.debug("sanitize deleting object",e),Vs(t[e]))})),t.themeVariables){const e=Object.keys(t.themeVariables);for(let r=0;r