ekms 9.6.3-beta.13 → 9.6.3-beta.14

package/common/drone.instance.json

@@ -41,6 +41,7 @@
         "([lower] (@<= arm || @<=claw))",
         "([open] (claw))",
         "([close] (claw))",
+        "([startPath|start] (path))",
         "([pathComponent])",
         "(<another> (point))",
         "([stop] ([drone|])?)",
@@ -49,6 +50,14 @@
         "((context.unit.dimension == 'time') [timeAtPoint|] (atPoint))"
       ],
       "bridges": [
+        {
+          "id": "startPath",
+          "isA": [
+            "verb"
+          ],
+          "bridge": "{ ...next(operator), path: after[0], operator: operator, interpolate: [{ property: 'operator' }, { property: 'path' }] }",
+          "semantic": "async ({context, remember, recall}) => {\n            const point = await recall({ context: { marker: 'point' } })\n            remember(context) \n            remember(point) // put the last point before the startPath so when the new path is generated this is the start point\n          }"
+        },
         {
           "id": "timeAtPoint",
           "before": [
@@ -101,7 +110,7 @@
             "repeatable"
           ],
           "bridge": "{\n            ...next(operator), operator: operator, path: after[0], interpolate: append(default(operator.interpolate, [{ property: 'operator'}]), [{ property: 'path' }])\n          }",
-          "semantic": "async ({context, e, toArray, fragments, toEValue, toFinalValue, recall, objects}) => {\n            const evaluated = await(e(context.path))\n            const path = toEValue(evaluated)\n          \n            // TODO put this in a common place for use by do+patrol \n\n            // ordinal to pause time in seconds \n            let pauseTimeInSeconds = {}\n            if (context.pause) {\n              const timeAtPoints = toArray(context.pause.timeAtPoint)\n              for (const timeAtPoint of timeAtPoints) {\n                const instantiation = await fragments(\"quantity in seconds\", { quantity: timeAtPoint.time })\n                const result = await e(instantiation)\n                const seconds = toFinalValue(toFinalValue(result).amount)\n\n                const points = await recall({ context: timeAtPoint.point.point, frameOfReference: path })\n                for (const point of toArray(points)) {\n                  pauseTimeInSeconds[point.ordinal] = seconds\n                }\n              }\n            }\n\n            // get to the start of the patrol  \n            objects.current.path.push(path.points[0])\n            objects.current.path.push({ aimOnly: true, ...path.points[1] })\n            objects.current.path.push({ repeatStart: true })\n            for (const point of path.points) {\n              objects.current.path.push(point)\n              if (pauseTimeInSeconds[point.ordinal]) {\n                objects.current.path.push({ marker: 'pause', pauseSeconds: pauseTimeInSeconds[point.ordinal] })\n              }\n            }\n            if (context.repeats) {\n              objects.current.timeRepeats = toFinalValue(context.repeats.repeats)\n            }\n            // if the patrol does not start and end at the same spot then \n            // go back to the start along the same path\n\n\n            // if the start is not the end of the patrol then go backwards along the patrol\n            if (JSON.stringify(path.points[0].point) !== JSON.stringify(path.points[path.points.length-1].point)) {\n              for (const point of [...path.points].reverse().slice(1)) {\n                objects.current.path.push(point)\n                if (pauseTimeInSeconds[point.ordinal]) {\n                  objects.current.path.push({ marker: 'pause', pauseSeconds: pauseTimeInSeconds[point.ordinal] })\n                }\n              }\n\n              const secondPoint = path.points[1]\n              objects.current.path.push({ ...secondPoint, aimOnly: true })\n\n            }\n            objects.runCommand = true\n          }"
+          "semantic": "async ({context, e, toArray, fragments, toEValue, toFinalValue, recall, objects}) => {\n            const evaluated = await(e(context.path))\n            const path = toEValue(evaluated)\n          \n            // TODO put this in a common place for use by do+patrol \n\n            // ordinal to pause time in seconds \n            const pauseTimeInSeconds = {}\n            if (context.pause) {\n              const timeAtPoints = toArray(context.pause.timeAtPoint)\n              for (const timeAtPoint of timeAtPoints) {\n                const instantiation = await fragments(\"quantity in seconds\", { quantity: timeAtPoint.time })\n                const result = await e(instantiation)\n                const seconds = toFinalValue(toFinalValue(result).amount)\n\n                const points = await recall({ context: timeAtPoint.point.point, frameOfReference: path })\n                for (const point of toArray(points)) {\n                  pauseTimeInSeconds[point.ordinal] = seconds\n                }\n              }\n            }\n\n            // get to the start of the patrol  \n            objects.current.path.push(path.points[0])\n            objects.current.path.push({ aimOnly: true, ...path.points[1] })\n            objects.current.path.push({ repeatStart: true })\n            for (const point of path.points) {\n              objects.current.path.push(point)\n              if (pauseTimeInSeconds[point.ordinal]) {\n                objects.current.path.push({ marker: 'pause', pauseSeconds: pauseTimeInSeconds[point.ordinal] })\n              }\n            }\n            if (context.repeats) {\n              objects.current.timeRepeats = toFinalValue(context.repeats.repeats)\n            }\n            // if the patrol does not start and end at the same spot then \n            // go back to the start along the same path\n\n\n            // if the start is not the end of the patrol then go backwards along the patrol\n            if (JSON.stringify(path.points[0].point) !== JSON.stringify(path.points[path.points.length-1].point)) {\n              for (const point of [...path.points].reverse().slice(1)) {\n                objects.current.path.push(point)\n                if (pauseTimeInSeconds[point.ordinal]) {\n                  objects.current.path.push({ marker: 'pause', pauseSeconds: pauseTimeInSeconds[point.ordinal] })\n                }\n              }\n\n              const secondPoint = path.points[1]\n              objects.current.path.push({ ...secondPoint, aimOnly: true })\n            }\n            objects.runCommand = true\n          }"
         },
         {
           "id": "lift",
@@ -543,11 +552,11 @@
       "semantics": [
         {
           "match": "({context}) => context.marker == 'doAction'",
-          "apply": "async ({context, fragments, e, s, toEValue, toFinalValue, objects}) => {\n            // await s({ ...context, marker: 'patrol', path: context.action})\n            if (true) {\n              const evaluated = await(e(context.action))\n              const path = toEValue(evaluated)\n              let pauseTimeInSeconds = 0\n              if (context.pause) {\n                debugger\n                const instantiation = await fragments(\"quantity in seconds\", { quantity: context.pause.timeAtPoint.time })\n                const result = await e(instantiation)\n                const seconds = toFinalValue(toFinalValue(result).amount)\n                pauseTimeInSeconds = seconds\n              }\n              for (const point of path.points) {\n                objects.current.path.push(point)\n                if (pauseTimeInSeconds) {\n                  objects.current.path.push({ marker: 'pause', pauseSeconds: pauseTimeInSeconds })\n                }\n              }\n              objects.runCommand = true\n            }\n          }"
+          "apply": "async ({context, fragments, e, s, toEValue, toFinalValue, objects}) => {\n            await s({ ...context, marker: 'patrol', path: context.action})\n          }"
         },
         {
           "match": "({context, contextHierarchy}) => {\n            if (!context.pullFromContext || !context.evaluate || contextHierarchy.under(['doAction', 'evaluate', 'patrol']) || context.instance) {\n              return false\n            }\n            \n            if (context.marker == 'path' || context.marker == 'this' || context.marker == 'that') {\n              return true\n            }\n          }",
-          "apply": "async ({context, frameOfReference, toArray, fragments, stm, objects, remember, recall, resolveEvaluate, _continue, contextHierarchy}) => {\n            const pathComponents = toArray(await recall({ context: { marker: 'pathComponent' }, all: true }))\n            const path = (await fragments('path')).contexts()[0]\n            delete path.value\n            path.instance = true\n            path.points = pathComponents.reverse()\n            frameOfReference(path, { mentioned: 'points', reversed: true })\n            await remember(path)\n\n            _continue() // let the call pick the object out from the stm\n          }"
+          "apply": "async ({context, frameOfReference, toArray, fragments, objects, remember, recall, resolveEvaluate, _continue, contextHierarchy}) => {\n            const pathComponents = toArray(await recall({ \n                                      context: { marker: 'pathComponent' }, \n                                      all: true,\n                                      stopCondition: (context) => context.marker == 'startPath',\n                                   }))\n            const path = (await fragments('path')).contexts()[0]\n            delete path.value\n            path.instance = true\n            path.points = pathComponents.reverse()\n            frameOfReference(path, { mentioned: 'points', reversed: true })\n            await remember(path)\n\n            _continue() // let the call pick the object out from the stm\n          }"
         },
         {
           "match": "({context, contextHierarchy}) => {\n            if (!context.pullFromContext || !context.evaluate || !contextHierarchy.under('call') || context.notUnderCall) {\n              return false\n            }\n            \n            if (context.marker == 'point' || context.marker == 'ordinal') {\n              return true\n            }\n          }",
@@ -561,6 +570,10 @@
           "match": "({context}) => context.evaluate && ['start', 'end'].includes(context.marker) && context.objects && context.objects[1].marker == 'path'",
           "apply": "async ({gp, s, context, objects, fragments, resolveEvaluate, api, recall}) => {\n            const path = await recall({ context: context.objects[1] })\n            if (!path?.points) {\n              return\n            }\n            if (context.marker == 'start') {\n              resolveEvaluate(context, path?.points[0])\n            } else if (context.marker == 'end') {\n              resolveEvaluate(context, path?.points[path?.points.length-1])\n            }\n          }"
         },
+        {
+          "match": "({context, contextHierarchy}) => \n              context.evaluate && \n              ['start', 'end', 'point'].includes(context.marker) && \n              !context.propertyOf && \n              contextHierarchy.under('go') &&\n              !contextHierarchy.under('call')",
+          "apply": "async ({gp, s, toArray, context, objects, fragments, resolveEvaluate, api, recall}) => {\n            const path = await recall({ context: { marker: 'path' } })\n            if (!path?.points) {\n              return\n            }\n            \n            if (context.marker == 'start') {\n              resolveEvaluate(context, path?.points[0])\n            } else if (context.marker == 'end') {\n              resolveEvaluate(context, path?.points[path?.points.length-1])\n            } else {\n              const points = await recall({ context, frameOfReference: path })\n              resolveEvaluate(context, toArray(points)[0])\n            }\n          }"
+        },
         {
           "match": "({context}) => context.marker == 'speed' && context.evaluate",
           "apply": "async ({gp, s, context, objects, fragments, resolveEvaluate, api}) => {\n            let value = objects.current.speed\n            if (context.condition) {\n              if (['highest', 'maximum'].includes(context.condition.marker)) {\n                value = api.maximumSpeedDrone()\n              } else if (['lowest', 'minimum'].includes(context.condition.marker)) {\n                value = api.minimumSpeedDrone()\n              }\n            }\n            const speed = await fragments(\"number meters per second\", { number: { marker: 'integer', value } })\n            const preferred = await s({ marker: 'preferredUnits', quantity: speed }) \n            resolveEvaluate(context, preferred.response || speed)\n          }"
@@ -55711,6 +55724,7 @@
         "([lower] (@<= arm || @<=claw))",
         "([open] (claw))",
         "([close] (claw))",
+        "([startPath|start] (path))",
         "([pathComponent])",
         "(<another> (point))",
         "([stop] ([drone|])?)",
@@ -55719,6 +55733,13 @@
         "((context.unit.dimension == 'time') [timeAtPoint|] (atPoint))"
       ],
       "bridges": [
+        {
+          "id": "startPath",
+          "isA": [
+            "verb"
+          ],
+          "bridge": "{ ...next(operator), path: after[0], operator: operator, interpolate: [{ property: 'operator' }, { property: 'path' }] }"
+        },
         {
           "id": "timeAtPoint",
           "before": [
@@ -56202,6 +56223,7 @@
         {},
         {},
         {},
+        {},
         {}
       ]
     }
@@ -59874,6 +59896,11 @@
           "thisAble",
           false
         ],
+        [
+          "startPath",
+          "verb",
+          false
+        ],
         [
           "stm_before",
           "adjective",
@@ -64304,6 +64331,11 @@
           "thisAble",
           false
         ],
+        [
+          "startPath",
+          "verb",
+          false
+        ],
         [
           "stm_before",
           "adjective",
@@ -68734,6 +68766,11 @@
           "thisAble",
           false
         ],
+        [
+          "startPath",
+          "verb",
+          false
+        ],
         [
           "stm_before",
           "adjective",
@@ -73399,6 +73436,11 @@
           "thisAble",
           false
         ],
+        [
+          "startPath",
+          "verb",
+          false
+        ],
         [
           "stm_before",
           "adjective",
@@ -78085,6 +78127,11 @@
           "thisAble",
           false
         ],
+        [
+          "startPath",
+          "verb",
+          false
+        ],
         [
           "stm_before",
           "adjective",
@@ -82514,6 +82561,11 @@
           "thisAble",
           false
         ],
+        [
+          "startPath",
+          "verb",
+          false
+        ],
         [
           "stm_before",
           "adjective",
@@ -86965,6 +87017,11 @@
           "thisAble",
           false
         ],
+        [
+          "startPath",
+          "verb",
+          false
+        ],
         [
           "stm_before",
           "adjective",
@@ -91663,6 +91720,11 @@
           "thisAble",
           false
         ],
+        [
+          "startPath",
+          "verb",
+          false
+        ],
         [
           "stm_before",
           "adjective",
@@ -95974,6 +96036,11 @@
           "thisAble",
           false
         ],
+        [
+          "startPath",
+          "verb",
+          false
+        ],
         [
           "stm_before",
           "adjective",

package/common/drone.js

@@ -1,4 +1,4 @@
-const { knowledgeModule, where } = require('./runtime').theprogrammablemind
+const { knowledgeModule, where, debug } = require('./runtime').theprogrammablemind
 const { conjugateVerb } = require('./english_helpers')
 const { OverrideCheck, defaultContextCheckProperties, defaultContextCheck, getValue, setValue } = require('./helpers')
 const drone_tests = require('./drone.test.json')
@@ -16,6 +16,10 @@ const { rotateDelta, degreesToRadians, radiansToDegrees, cartesianToPolar, small
 /*
 NEED TO CHECK ON ACTUAL DRONE
 
+  DONE fix DO so it can do all the stuff partol can do <<<<<<<<<<<<<<<<<<<
+  start again. start a new path
+  the last 3 points are called path 1
+
   stopping 2 seconds at each point
   patrols x do that again
   DONE go to the end of the patrol
@@ -25,6 +29,9 @@ NEED TO CHECK ON ACTUAL DRONE
   go to the start
   DONE node drone -q 'north 1 meter\neast 1 meter\ncall that route 2\nwhat is the second point of route 2' -g -
 
+  go to the start along the path / following the path
+  pausing 1 second at the first point and 5 at the last
+
   DONE go to the second point of route 1
   DONE do route 1 pausing 10 seconds at each point
 
@@ -885,6 +892,7 @@ const template = {
         "([lower] (@<= arm || @<=claw))",
         "([open] (claw))",
         "([close] (claw))",
+        "([startPath|start] (path))",
         "([pathComponent])",
         "(<another> (point))",
         // "([turn] (direction))",
@@ -897,20 +905,16 @@ const template = {
         // "((context.unit.dimension == 'time') [timeForRest|] (forRest))",
       ],
       bridges: [
-        /*
-        { 
-          id: 'forRest',
-          isA: ['preposition'],
-          bridge: "{ ...next(operator), rest: after[0], operator: operator, interpolate: [{ property: 'operator' }, { property: 'rest' }] }"
-        },
         { 
-          id: 'timeForRest',
-          before: ['verb'],
-          after: ['preposition'],
-          convolution: true,
-          bridge: "{ ...next(operator), time: before[0], point: after[0], operator: operator, interpolate: [{ property: 'time' }, { property: 'point' }] }"
+          id: 'startPath',
+          isA: ['verb'],
+          bridge: "{ ...next(operator), path: after[0], operator: operator, interpolate: [{ property: 'operator' }, { property: 'path' }] }",
+          semantic: async ({context, remember, recall}) => {
+            const point = await recall({ context: { marker: 'point' } })
+            remember(context) 
+            remember(point) // put the last point before the startPath so when the new path is generated this is the start point
+          },
         },
-        */
         { 
           id: 'timeAtPoint',
           before: ['verb'],
@@ -993,7 +997,6 @@ const template = {
 
               const secondPoint = path.points[1]
               objects.current.path.push({ ...secondPoint, aimOnly: true })
-
             }
             objects.runCommand = true
           }
@@ -1251,26 +1254,7 @@ const template = {
         {
           match: ({context}) => context.marker == 'doAction',
           apply: async ({context, fragments, e, s, toEValue, toFinalValue, objects}) => {
-            // await s({ ...context, marker: 'patrol', path: context.action})
-            if (true) {
-              const evaluated = await(e(context.action))
-              const path = toEValue(evaluated)
-              let pauseTimeInSeconds = 0
-              if (context.pause) {
-                debugger
-                const instantiation = await fragments("quantity in seconds", { quantity: context.pause.timeAtPoint.time })
-                const result = await e(instantiation)
-                const seconds = toFinalValue(toFinalValue(result).amount)
-                pauseTimeInSeconds = seconds
-              }
-              for (const point of path.points) {
-                objects.current.path.push(point)
-                if (pauseTimeInSeconds) {
-                  objects.current.path.push({ marker: 'pause', pauseSeconds: pauseTimeInSeconds })
-                }
-              }
-              objects.runCommand = true
-            }
+            await s({ ...context, marker: 'patrol', path: context.action})
           }
         },
         {
@@ -1283,8 +1267,12 @@ const template = {
               return true
             }
           },
-          apply: async ({context, frameOfReference, toArray, fragments, stm, objects, remember, recall, resolveEvaluate, _continue, contextHierarchy}) => {
-            const pathComponents = toArray(await recall({ context: { marker: 'pathComponent' }, all: true }))
+          apply: async ({context, frameOfReference, toArray, fragments, objects, remember, recall, resolveEvaluate, _continue, contextHierarchy}) => {
+            const pathComponents = toArray(await recall({ 
+                                      context: { marker: 'pathComponent' }, 
+                                      all: true,
+                                      stopCondition: (context) => context.marker == 'startPath',
+                                   }))
             const path = (await fragments('path')).contexts()[0]
             delete path.value
             path.instance = true
@@ -1341,6 +1329,29 @@ const template = {
             }
           }
         },
+        {
+          match: ({context, contextHierarchy}) => 
+              context.evaluate && 
+              ['start', 'end', 'point'].includes(context.marker) && 
+              !context.propertyOf && 
+              contextHierarchy.under('go') &&
+              !contextHierarchy.under('call'),
+          apply: async ({gp, s, toArray, context, objects, fragments, resolveEvaluate, api, recall}) => {
+            const path = await recall({ context: { marker: 'path' } })
+            if (!path?.points) {
+              return
+            }
+            
+            if (context.marker == 'start') {
+              resolveEvaluate(context, path?.points[0])
+            } else if (context.marker == 'end') {
+              resolveEvaluate(context, path?.points[path?.points.length-1])
+            } else {
+              const points = await recall({ context, frameOfReference: path })
+              resolveEvaluate(context, toArray(points)[0])
+            }
+          }
+        },
         {
           match: ({context}) => context.marker == 'speed' && context.evaluate,
           apply: async ({gp, s, context, objects, fragments, resolveEvaluate, api}) => {