ekms 9.6.3-beta.11 → 9.6.3-beta.13

package/common/drone.js

@@ -16,14 +16,17 @@ const { rotateDelta, degreesToRadians, radiansToDegrees, cartesianToPolar, small
 /*
 NEED TO CHECK ON ACTUAL DRONE
 
+  stopping 2 seconds at each point
   patrols x do that again
   DONE go to the end of the patrol
-  patrol x three times
+  DONE patrol x three times
+  patrol x continuously
   patrol x for 5 minutes
-  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
+  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 second point of route 1
-  do route 1 pausing 10 seconds at each point
+  DONE go to the second point of route 1
+  DONE do route 1 pausing 10 seconds at each point
 
   what is the drone's position
 DONE go back
@@ -41,7 +44,7 @@ TODO should there be two hierarchy one as a concept car is a vehicle and one as
 
 turn left\nturn back
 
-do route 1 pausing 10 seconds at each point
+DONE do route 1 pausing 10 seconds at each point
 do route 1 pausing 1 second at point 1 and 2 seconds for the rest
 
 forward 1 foot\nwest 1 foot\ngo back to the start         <<<<<<<<  turn the longer way not he shorter way
@@ -455,13 +458,14 @@ class API {
     }
 
     if (objects.current.path.length > 0) {
-      if (objects.current.timeRepeats) {
-        this.startRepeats(objects.current.timeRepeats)
-      }
       let currentPoint = (await this.args.recall({ context: { marker: 'point' } })).point
       this._objects.history.push({ marker: 'history', debug: 'doing path' })
-      for (const pathComponent of objects.current.path) {
-        if (pathComponent.marker == 'pause') {
+      for (const [pathIndex, pathComponent] of objects.current.path.entries()) {
+        if (pathComponent.repeatStart) {
+          if (objects.current.timeRepeats) {
+            this.startRepeats(objects.current.timeRepeats)
+          }
+        } else if (pathComponent.marker == 'pause') {
           this.pause(pathComponent.pauseSeconds, { batched: true })
         } else {
           const points = this.args.toArray(pathComponent)
@@ -475,12 +479,12 @@ class API {
             // const angleDelta = (destinationAngleInRadians - objects.current.angleInRadians)
             const angleDelta = rotateDelta(objects.current.angleInRadians, destinationAngleInRadians)
             await this.rotate(angleDelta, { batched: true })
-            if (!pathComponent .aimOnly) {
+            if (!pathComponent.aimOnly) {
               await this.forward(objects.current.speed, { batched: true })
               await stopAtDistance("forward", polar.radius)
+              currentPoint = destinationPoint
             }
           }
-          currentPoint = destinationPoint
         }
       }
       if (objects.current.timeRepeats) {
@@ -608,6 +612,7 @@ class API {
     const ordinal = this.currentOrdinal()
     const currentPoint = await this.args.recall({ context: { marker: 'point' }, condition: (context) => context.ordinal == ordinal })
     const lastPoint = await this.args.recall({ context: { marker: 'point' }, condition: (context) => context.ordinal == ordinal-1 })
+    current.path.push({ repeatStart: true })
     current.path.push(lastPoint)
     current.path.push(currentPoint)
     objects.runCommand = true
@@ -808,7 +813,22 @@ const template = {
     "around, forward, left, right, back, forth and backward are directions",
     "paths are nameable and memorable",
     "start and end are properties of path",
+    ({apis}) => {
+      apis('properties').addHierarchyWatcher({
+        match: ({childId}) => childId == 'point',
+        apply: ({config, childId}) => {
+          config.updateBridge(childId, ({ bridge }) => {
+            if (!bridge.init) {
+              bridge.init = {}
+            }
+            bridge.init['notConjunctableWith'] = ['quantity']
+          })
+        }
+      })
+    },
+
     "start and end are points",
+    "rest and remaining are concepts",
     {
       hierarchy: [
         ['point', 'distributable'],
@@ -872,8 +892,33 @@ const template = {
         "([stop] ([drone|])?)",
         "([toPoint|to] (point))",
         "([atPoint|at] (point))",
+        // "([forRest|for] (rest/* || remaining/*))",
+        "((context.unit.dimension == 'time') [timeAtPoint|] (atPoint))",
+        // "((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: 'timeAtPoint',
+          before: ['verb'],
+          after: ['preposition'],
+          convolution: true,
+          bridge: "{ ...next(operator), time: before[0], point: after[0], operator: operator, interpolate: [{ property: 'time' }, { property: 'point' }] }",
+          check: defaultContextCheckProperties(['time', 'point']),
+        },
         { 
           id: 'atPoint',
           isA: ['preposition'],
@@ -898,34 +943,57 @@ const template = {
           bridge: `{
             ...next(operator), operator: operator, path: after[0], interpolate: append(default(operator.interpolate, [{ property: 'operator'}]), [{ property: 'path' }])
           }`,
-          semantic: async ({context, e, fragments, toEValue, toFinalValue, objects}) => {
+          semantic: async ({context, e, toArray, fragments, toEValue, toFinalValue, recall, objects}) => {
             const evaluated = await(e(context.path))
             const path = toEValue(evaluated)
+          
+            // TODO put this in a common place for use by do+patrol 
+
+            // ordinal to pause time in seconds 
+            const pauseTimeInSeconds = {}
+            if (context.pause) {
+              const timeAtPoints = toArray(context.pause.timeAtPoint)
+              for (const timeAtPoint of timeAtPoints) {
+                const instantiation = await fragments("quantity in seconds", { quantity: timeAtPoint.time })
+                const result = await e(instantiation)
+                const seconds = toFinalValue(toFinalValue(result).amount)
+
+                const points = await recall({ context: timeAtPoint.point.point, frameOfReference: path })
+                for (const point of toArray(points)) {
+                  pauseTimeInSeconds[point.ordinal] = seconds
+                }
+              }
+            }
+
+            // get to the start of the patrol  
+            objects.current.path.push(path.points[0])
+            objects.current.path.push({ aimOnly: true, ...path.points[1] })
+            objects.current.path.push({ repeatStart: true })
             for (const point of path.points) {
               objects.current.path.push(point)
+              if (pauseTimeInSeconds[point.ordinal]) {
+                objects.current.path.push({ marker: 'pause', pauseSeconds: pauseTimeInSeconds[point.ordinal] })
+              }
             }
             if (context.repeats) {
-              objects.current.timeRepeats = toFinalValue(context.repeats)
+              objects.current.timeRepeats = toFinalValue(context.repeats.repeats)
             }
             // if the patrol does not start and end at the same spot then 
             // go back to the start along the same path
 
 
-            let pauseTimeInSeconds
-            if (context.pause) {
-              const instantiation = await fragments("quantity in seconds", { quantity: context.pause.time })
-              const result = await e(instantiation)
-              const seconds = toFinalValue(toFinalValue(result).amount)
-              pauseTimeInSeconds = seconds
-            }
-
+            // if the start is not the end of the patrol then go backwards along the patrol
             if (JSON.stringify(path.points[0].point) !== JSON.stringify(path.points[path.points.length-1].point)) {
-              for (const point of [...path.points].reverse()) {
+              for (const point of [...path.points].reverse().slice(1)) {
                 objects.current.path.push(point)
-                if (pauseTimeInSeconds) {
-                  objects.current.path.push({ marker: 'pause', pauseSeconds: pauseTimeInSeconds })
+                if (pauseTimeInSeconds[point.ordinal]) {
+                  objects.current.path.push({ marker: 'pause', pauseSeconds: pauseTimeInSeconds[point.ordinal] })
                 }
               }
+
+              const secondPoint = path.points[1]
+              objects.current.path.push({ ...secondPoint, aimOnly: true })
+
             }
             objects.runCommand = true
           }
@@ -1117,17 +1185,22 @@ const template = {
           words: [
             ...conjugateVerb('pause'),
           ],
-          bridge: "{ ...next(operator), time: or(time?, forTime), operator: operator, atPoint: atPoint?, interpolate: [{ property: 'operator' }, { property: 'time' }, { property: 'atPoint' }] }",
-          check: defaultContextCheckProperties(['time']),
+          bridge: "{ ...next(operator), timeAtPoint: timeAtPoint?, time: or(time?, forTime?), operator: operator, atPoint: atPoint?, interpolate: [{ property: 'operator' }, { property: 'time' }, { property: 'forTime' }, { property: 'atPoint' }, { property: 'timeAtPoint' } ] }",
+          check: defaultContextCheckProperties(['timeAtPoint']),
           selector: {
             arguments: {
               forTime: "(@<= 'forQuantity' && context.quantity.unit.dimension == 'time')",
               time: "(@<= 'quantity' && context.unit.dimension == 'time')",
               atPoint: "(@<= 'atPoint')",
+              timeAtPoint: "(@<= 'timeAtPoint')",
             },
           },
           semantic: async ({context, remember, api, e, fragments, toFinalValue}) => {
             let time = context.time 
+            if (!time) {
+              return
+            }
+            debugger
             if (time.marker == 'forQuantity') {
               time = time.quantity
             }
@@ -1184,7 +1257,8 @@ const template = {
               const path = toEValue(evaluated)
               let pauseTimeInSeconds = 0
               if (context.pause) {
-                const instantiation = await fragments("quantity in seconds", { quantity: context.pause.time })
+                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
@@ -1201,7 +1275,7 @@ const template = {
         },
         {
           match: ({context, contextHierarchy}) => {
-            if (!context.pullFromContext || !context.evaluate || contextHierarchy.under(['doAction', 'evaluate', 'patrol'])) {
+            if (!context.pullFromContext || !context.evaluate || contextHierarchy.under(['doAction', 'evaluate', 'patrol']) || context.instance) {
               return false
             }