ekms 9.6.0-beta.10 → 9.6.0-beta.12

package/common/characters.js

@@ -1,4 +1,4 @@
-const { knowledgeModule, where, process:clientProcess } = require('./runtime').theprogrammablemind
+const { debug, knowledgeModule, where, process:clientProcess } = require('./runtime').theprogrammablemind
 const { defaultContextCheck } = require('./helpers')
 const gdefaults = require('./gdefaults.js')
 const createCurrencyKM = require('./currency.js')
@@ -173,22 +173,20 @@ function initializeApi(config, api) {
 }
 
 
-async function initializer({isModule, km}) {
-  if (!isModule) {
-    const timeKM = await createTimeKM()
-    const currencyKM = await createCurrencyKM()
-    const config = km('characters')
-    const api = new Sally(timeKM)
-    const api2 = new Bob(currencyKM)
-    await config.setApi(() => api2)
-    await config.setApi(() => api)
-  }
+async function demoInitializer(config) {
+  const timeKM = await createTimeKM()
+  const currencyKM = await createCurrencyKM()
+  const api = new Sally(timeKM)
+  const api2 = new Bob(currencyKM)
+  await config.setApi(() => api2)
+  await config.setApi(() => api)
 }
+
 // mode this to non-module init only
 knowledgeModule({
   config,
   includes: [gdefaults],
-  initializer,
+  demoInitializer,
   multiApiInitializer: initializeApi,
 
   module,

package/common/drone.instance.json

@@ -11,6 +11,7 @@
     {
       "operators": [
         "([back])",
+        "([forth])",
         "([turn] (direction))",
         "([pause] ([number]))",
         "([stop] ([drone|])?)",
@@ -23,7 +24,13 @@
           "isA": [
             "noun"
           ],
-          "semantic": "async ({objects, mentions, api, e, context}) => {\n            objects.runCommand = true\n            const ordinal = api.currentOrdinal() - 1\n            const lastPoint = mentions({ context: { marker: 'point' }, condition: (context) => context.ordinal == ordinal })\n            objects.current.destination = lastPoint\n          }"
+          "semantic": "async ({objects, mentions, api, e, context}) => {\n            objects.runCommand = true\n            const ordinal = api.currentOrdinal() - 1\n            const lastPoint = mentions({ context: { marker: 'point' }, condition: (context) => context.ordinal == ordinal })\n            objects.current.path.push(lastPoint)\n          }"
+        },
+        {
+          "id": "forth",
+          "isA": [
+            "noun"
+          ]
         },
         {
           "id": "toPoint",
@@ -31,7 +38,7 @@
             "preposition"
           ],
           "bridge": "{ ...next(operator), operator: operator, point: after[0], interpolate: [{ property: 'operator' }, { property: 'point' }] }",
-          "semantic": "async ({objects, api, e, context}) => {\n            objects.runCommand = true\n            const point = await e(context.point)\n            objects.current.destination = point.evalue\n          }"
+          "semantic": "async ({objects, api, e, context}) => {\n            objects.runCommand = true\n            const point = await e(context.point)\n            objects.current.path.push(point.evalue)\n          }"
         },
         {
           "id": "go"
@@ -70,7 +77,12 @@
           "apply": "() => ''"
         }
       ],
-      "semantics": []
+      "semantics": [
+        {
+          "match": "({context, toArray}) => {\n            if (context.marker !== 'list') {\n              return false\n            }\n\n            const array = toArray(context)\n            if (array[0].marker == 'back' && array[1].marker == 'forth') {\n              return true\n            }\n          }",
+          "apply": "({context, objects, api, mentions}) => {\n            objects.runCommand = true\n            objects.current.backAndForth = true\n            const ordinal = api.currentOrdinal()\n            const currentPoint = mentions({ context: { marker: 'point' }, condition: (context) => context.ordinal == ordinal })\n            const lastPoint = mentions({ context: { marker: 'point' }, condition: (context) => context.ordinal == ordinal-1 })\n            objects.current.path.push(lastPoint)\n            objects.current.path.push(currentPoint)\n          }"
+        }
+      ]
     }
   ],
   "resultss": [
@@ -15677,6 +15689,7 @@
       "extraConfig": true,
       "operators": [
         "([back])",
+        "([forth])",
         "([turn] (direction))",
         "([pause] ([number]))",
         "([stop] ([drone|])?)",
@@ -15690,6 +15703,12 @@
             "noun"
           ]
         },
+        {
+          "id": "forth",
+          "isA": [
+            "noun"
+          ]
+        },
         {
           "id": "toPoint",
           "isA": [
@@ -15728,7 +15747,9 @@
       "generators": [
         {}
       ],
-      "semantics": []
+      "semantics": [
+        {}
+      ]
     }
   ],
   "fragments": [
@@ -16304,6 +16325,11 @@
           "queryable",
           false
         ],
+        [
+          "forth",
+          "noun",
+          false
+        ],
         [
           "forward",
           "direction",
@@ -19090,6 +19116,11 @@
           "queryable",
           false
         ],
+        [
+          "forth",
+          "noun",
+          false
+        ],
         [
           "forward",
           "direction",
@@ -22147,6 +22178,11 @@
           "queryable",
           false
         ],
+        [
+          "forth",
+          "noun",
+          false
+        ],
         [
           "forward",
           "direction",
@@ -25124,6 +25160,11 @@
           "queryable",
           false
         ],
+        [
+          "forth",
+          "noun",
+          false
+        ],
         [
           "forward",
           "direction",

package/common/drone.js

@@ -110,6 +110,10 @@ https://www.amazon.ca/Freenove-Raspberry-Tracking-Avoidance-Ultrasonic/dp/B0BNDQ
   go forward for 1 second\nbackward 2 meters (implicit stop)
 
   go back
+
+  go back and forth 3 times
+  go back and forth 2 meters
+  go back and forth 1 second
 */
 
 function expectDirection(args) {
@@ -190,6 +194,7 @@ class API {
 
     objects.current = {
       angleInRadians: 0,
+      path: [],
       speed: this.minimumSpeedDrone(),
       ordinal: 0,                 // ordinal of the current point or the current point that the recent movement started at
     }
@@ -269,31 +274,41 @@ class API {
     }
 
     const stopAtDistance = async (direction, distanceMeters) => {
-      const speed_meters_per_second = this._objects.current.speed
+      const speed_meters_per_second = objects.current.speed
       const duration_seconds = distanceMeters / speed_meters_per_second
       await this.pause(duration_seconds, { batched: true })
-      await this.stop()
+      await this.stop({ batched: true })
       this.markCurrentPoint()
     }
 
-    if (this._objects.current.destination) {
-      const currentPoint = this.args.mentions({ context: { marker: 'point' } }).point
-      const destinationPoint = this._objects.current.destination.point
-      if (currentPoint.x == destinationPoint.x && currentPoint.y == destinationPoint.y) {
-        // already there
-      } else {
-        const polar = cartesianToPolar(currentPoint, destinationPoint)
-        const destinationAngleInRadians = polar.angle
-        const angleDelta = (destinationAngleInRadians - this._objects.current.angleInRadians)
-        await this.rotate(angleDelta)
-        await this.forward(this._objects.current.speed)
-        await stopAtDistance("forward", polar.radius)
-        this._objects.current.destination = undefined
+    if (objects.current.path.length > 0) {
+      if (objects.current.timeRepeats) {
+        this.startRepeats(objects.current.timeRepeats)
+      }
+      for (const destination of objects.current.path) {
+        const destinationPoint = destination.point
+        const currentPoint = this.args.mentions({ context: { marker: 'point' } }).point
+        if (currentPoint.x == destinationPoint.x && currentPoint.y == destinationPoint.y) {
+          // already there
+        } else {
+          const polar = cartesianToPolar(currentPoint, destinationPoint)
+          const destinationAngleInRadians = polar.angle
+          const angleDelta = (destinationAngleInRadians - objects.current.angleInRadians)
+          await this.rotate(angleDelta)
+          await this.forward(objects.current.speed)
+          await stopAtDistance("forward", polar.radius)
+        }
       }
+      if (objects.current.timeRepeats) {
+        this.endRepeats()
+      }
+      await this.sendBatch()
+      objects.current.path = []
+      objects.current.timeRepeats = 0
       return
     }
 
-    const command = { speed: this._objects.current.speed, ...this._objects.current }
+    const command = { speed: objects.current.speed, ...objects.current }
     switch (command.direction) {
       case 'forward':
         await this.forward(command.speed, { batched: command.distance })
@@ -315,9 +330,22 @@ class API {
     if (command.distance) {
       const distanceMeters = command.distance
       await stopAtDistance(command.direction, distanceMeters)
+      await this.sendBatch()
     }
   }
 
+  async startRepeats(n) {
+    await this.startRepeatsDrone()
+  }
+
+  async endRepeats(n) {
+    await this.endRepeatsDrone()
+  }
+
+  async sendBatch() {
+    await this.sendBatchDrone()
+  }
+
   async forward(speed, options) {
     await this.forwardDrone(speed, options)
     const time = this.now()
@@ -367,6 +395,18 @@ class API {
 
   // subclass and override the remaining to call the drone
 
+  async startRepeats(n) {
+    this._objects.history.push({ marker: 'startRepeats', n })
+  }
+
+  async endRepeats(n) {
+    this._objects.history.push({ marker: 'endRepeats', })
+  }
+
+  async sendBatchDrone(durationInSeconds, options) {
+    this._objects.history.push({ marker: 'sendBatch', pause: durationInSeconds, ...options })
+  }
+
   async pauseDrone(durationInSeconds, options) {
     this._objects.history.push({ marker: 'history', pause: durationInSeconds, ...options })
     this.testDate = new Date(this.testDate.getTime() + (durationInSeconds-1)*1000)
@@ -537,6 +577,7 @@ const template = {
     {
       operators: [
         "([back])",
+        "([forth])",
         "([turn] (direction))",
         "([pause] ([number]))",
         "([stop] ([drone|])?)",
@@ -551,9 +592,13 @@ const template = {
             objects.runCommand = true
             const ordinal = api.currentOrdinal() - 1
             const lastPoint = mentions({ context: { marker: 'point' }, condition: (context) => context.ordinal == ordinal })
-            objects.current.destination = lastPoint
+            objects.current.path.push(lastPoint)
           }
         },
+        {
+          id: "forth",
+          isA: ['noun'],
+        },
         { 
           id: "toPoint",
           isA: ['preposition'],
@@ -561,7 +606,7 @@ const template = {
           semantic: async ({objects, api, e, context}) => {
             objects.runCommand = true
             const point = await e(context.point)
-            objects.current.destination = point.evalue
+            objects.current.path.push(point.evalue)
           }
         },
         { id: "go" },
@@ -605,7 +650,34 @@ const template = {
         },
       ],
       semantics: [
-      
+        {
+          match: ({context}) => context.marker == 'timeRepeats',
+          apply: ({context, objects, toFinalValue}) => {
+            objects.runCommand = true
+            objects.current.timeRepeats = toFinalValue(context.repeats)
+          }
+        },
+        {
+          match: ({context, toArray}) => {
+            if (context.marker !== 'list') {
+              return false
+            }
+
+            const array = toArray(context)
+            if (array[0].marker == 'back' && array[1].marker == 'forth') {
+              return true
+            }
+          },
+          apply: ({context, objects, api, mentions}) => {
+            objects.runCommand = true
+            objects.current.backAndForth = true
+            const ordinal = api.currentOrdinal()
+            const currentPoint = mentions({ context: { marker: 'point' }, condition: (context) => context.ordinal == ordinal })
+            const lastPoint = mentions({ context: { marker: 'point' }, condition: (context) => context.ordinal == ordinal-1 })
+            objects.current.path.push(lastPoint)
+            objects.current.path.push(currentPoint)
+          }
+        }
       ],
     },
   ],