tpmkms 9.6.1 → 9.6.2

package/common/drone.js

@@ -1,24 +1,43 @@
 const { knowledgeModule, where } = require('./runtime').theprogrammablemind
 const { conjugateVerb } = require('./english_helpers')
-const { OverrideCheck, defaultContextCheck, getValue, setValue } = require('./helpers')
+const { OverrideCheck, defaultContextCheckProperties, defaultContextCheck, getValue, setValue } = require('./helpers')
 const drone_tests = require('./drone.test.json')
 const instance = require('./drone.instance.json')
 const hierarchy = require('./hierarchy')
 const ordinals = require('./ordinals')
 const nameable = require('./nameable')
 const compass = require('./compass')
+const actions = require('./actions')
 const angle = require('./angle')
 const rates = require('./rates')
 const help = require('./help')
-const { rotateDelta, degreesToRadians, radiansToDegrees, cartesianToPolar } = require('./helpers/drone')
+const { rotateDelta, degreesToRadians, radiansToDegrees, cartesianToPolar, smallestRotate } = require('./helpers/drone')
 
 /*
-turn left go forward 1 foot <- the turn is lost
+DONE go back
+go back another point
+go back again
+go back to the start
+go back 2 points along route 1
+go to the start of route 2
+
+turn left\nturn back
+
+do route 1 pausing 10 seconds at each point
+
+forward 1 foot\nwest 1 foot\ngo back to the start         <<<<<<<<  turn the longer way not he shorter way
+forward 1 foot\nwest 1 foot\ncall the path route 1\ngo to the start of route 1\npatrol route 1\npatrol route 1   <<<<< does the patrol more than once
 
+?? elipses of the verb go or some kind of conjunction?!?!?
+go forward 1 meter turn right forward 2 meters stop
+
+the patrol called patrol 1 is forward 1 meter pause 10 second west 1 meter pause again then back to the start
+
+do a 5 second pause at each point / add a 10 second pause to each point / pause of 5 seconds
 
 start again / start here / starting here / restart
 again
-go back to the start
+go back to the start => follows path | go to the start => does not follow the path | go to the start following the path
 go back 2 points/turns
 go back and forth to the start!?!?
 
@@ -28,6 +47,7 @@ go 20 percent faster
 lower and raise crane
 round to 2 digits
 
+DONE turn left go forward 1 foot <- the turn is lost
 DONE call this patrol 1
 DONE call this path patrol 1
 DONE call that patrol 1
@@ -80,7 +100,6 @@ https://www.amazon.ca/Freenove-Raspberry-Tracking-Avoidance-Ultrasonic/dp/B0BNDQ
   convert from length to a some kind of standard number
   shut up/dont talk/be quiet -> stop saying responses
 
-  use it to measure distances -> go forward. stop. how far was that
 
   call this point a
   move 5 feet
@@ -102,6 +121,7 @@ https://www.amazon.ca/Freenove-Raspberry-Tracking-Avoidance-Ultrasonic/dp/B0BNDQ
   this is jeff
   say hi
 
+  use it to measure distances -> go forward. stop. how far was that
 
   say your names
   car 1 do patrol one
@@ -153,7 +173,7 @@ https://www.amazon.ca/Freenove-Raspberry-Tracking-Avoidance-Ultrasonic/dp/B0BNDQ
   amke the default speed 2 times faster
   double the default speed  
 
-  what is the speed
+#  what is the speed
   use inches per second and repeat that
 */
 
@@ -290,7 +310,7 @@ class API {
     return this._objects.current.ordinal += 1
   }
 
-  currentPoint() {
+  async currentPoint() {
     const current = this._objects.current
     if (current.durationInSeconds) {
       // okay
@@ -298,7 +318,7 @@ class API {
       return null // in motion
     }
     const ordinal = this.currentOrdinal()
-    const lastPoint = this.args.mentions({ context: { marker: 'point' }, condition: (context) => context.ordinal == ordinal })
+    const lastPoint = await this.args.mentions({ context: { marker: 'point' }, condition: (context) => context.ordinal == ordinal })
     if (!current.startTime && !current.endTime && !current.durationInSeconds) {
       return lastPoint // did not move
     }
@@ -318,8 +338,8 @@ class API {
     return { x: xPrime, y: yPrime }
   }
 
-  markCurrentPoint() {
-    const point = this.currentPoint()
+  async markCurrentPoint() {
+    const point = await this.currentPoint()
     if (!point) {
       return
     }
@@ -385,30 +405,35 @@ class API {
       objects.current.durationInSeconds = distanceMeters / speed_meters_per_second
       await this.pause(objects.current.durationInSeconds, { batched: true })
       await this.stop({ batched: true })
-      this.markCurrentPoint()
+      await this.markCurrentPoint()
     }
 
     if (objects.current.path.length > 0) {
       if (objects.current.timeRepeats) {
         this.startRepeats(objects.current.timeRepeats)
       }
-      let currentPoint = this.args.mentions({ context: { marker: 'point' } }).point
+      let currentPoint = (await this.args.mentions({ context: { marker: 'point' } })).point
       this._objects.history.push({ marker: 'history', debug: 'doing path' })
-      for (const destination of objects.current.path) {
-        const destinationPoint = destination.point
-        if (currentPoint.x == destinationPoint.x && currentPoint.y == destinationPoint.y) {
-          // already there
+      for (const pathComponent of objects.current.path) {
+        if (pathComponent.marker == 'pause') {
+          this.pause(pathComponent.pauseSeconds, { batched: true })
         } else {
-          const polar = cartesianToPolar(currentPoint, destinationPoint)
-          const destinationAngleInRadians = polar.angle
-          const angleDelta = (destinationAngleInRadians - objects.current.angleInRadians)
-          await this.rotate(angleDelta, { batched: true })
-          if (!destination.aimOnly) {
-            await this.forward(objects.current.speed, { batched: true })
-            await stopAtDistance("forward", polar.radius)
+          const destinationPoint = pathComponent.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)
+            const angleDelta = rotateDelta(objects.current.angleInRadians, destinationAngleInRadians)
+            await this.rotate(angleDelta, { batched: true })
+            if (!pathComponent .aimOnly) {
+              await this.forward(objects.current.speed, { batched: true })
+              await stopAtDistance("forward", polar.radius)
+            }
           }
+          currentPoint = destinationPoint
         }
-        currentPoint = destinationPoint
       }
       if (objects.current.timeRepeats) {
         await this.endRepeats()
@@ -511,6 +536,35 @@ class API {
     return time
   }
 
+  async back(points) {
+    const objects = this._objects
+    let ordinal
+    if (points?.quantity?.value) {
+      ordinal = this.currentOrdinal() - points.quantity?.value
+    } else {
+      ordinal = this.currentOrdinal() - 1
+    }
+    const lastPoint = await this.args.mentions({ context: { marker: 'point' }, condition: (context) => context.ordinal == ordinal })
+    if (!lastPoint) {
+      this.args.say(`There is no previous point to go back to`)
+      return
+    }
+    objects.current.path.push(lastPoint)
+    objects.runCommand = true
+  }
+
+  async backAndForth() {
+    const objects = this._objects
+    const current = objects.current
+    current.backAndForth = true
+    const ordinal = this.currentOrdinal()
+    const currentPoint = await this.args.mentions({ context: { marker: 'point' }, condition: (context) => context.ordinal == ordinal })
+    const lastPoint = await this.args.mentions({ context: { marker: 'point' }, condition: (context) => context.ordinal == ordinal-1 })
+    current.path.push(lastPoint)
+    current.path.push(currentPoint)
+    objects.runCommand = true
+  }
+
   async sonic() {
     return await this.sonicDrone()
   }
@@ -524,7 +578,7 @@ class API {
       shortestRotate = shortestRotate + Math.PI*2
     }
     await this.rotateDrone(angleInRadians, options)
-    this._objects.current.angleInRadians = (this._objects.current.angleInRadians + angleInRadians) % (2*Math.PI)
+    this._objects.current.angleInRadians = smallestRotate(this._objects.current.angleInRadians + angleInRadians)
   }
 
   async tiltAngle(angle) {
@@ -571,7 +625,7 @@ class API {
   }
 
   async pauseDrone(durationInSeconds, options) {
-    this._objects.history.push({ marker: 'history', pause: durationInSeconds, ...options })
+    this._objects.history.push({ marker: 'history', pause: durationInSeconds, time: this.now(true, durationInSeconds*1000), ...options })
     this.testDate = new Date(this.testDate.getTime() + (durationInSeconds-1)*1000)
   }
 
@@ -585,15 +639,15 @@ class API {
     return 1.2
   }
 
-  now(lookahead = false) {
+  now(lookahead = false, pause = 1000) {
     if (this.args.isProcess || this.args.isTest) {
       if (!this.testDate) {
         this.testDate = new Date(2025, 5, 29, 14, 52, 0)
       }
       if (lookahead) {
-        return new Date(this.testDate.getTime() + 1000)
+        return new Date(this.testDate.getTime() + pause)
       } else {
-        this.testDate = new Date(this.testDate.getTime() + 1000)
+        this.testDate = new Date(this.testDate.getTime() + pause)
         return this.testDate
       }
     } else {
@@ -691,6 +745,7 @@ function expectDistanceForMove(args) {
 const template = {
   fragments: [ 
     "quantity in meters",
+    "quantity in seconds",
     "quantity in meters per second",
     "number meters per second",
     "quantity in units",
@@ -701,13 +756,14 @@ const template = {
   configs: [
     "arm, claw and drone are concepts",
     //TODO "forward left, right, backward are directions",
-    "around, forward, left, right, and backward are directions",
+    "around, forward, left, right, back, forth and backward are directions",
     "paths are nameable and memorable",
     "start and end are properties of path",
     "start and end are points",
     {
       hierarchy: [
         ['thisitthat', 'path'],
+        ['path', 'action'],
       ],
     },
     "speed and power are properties",
@@ -715,7 +771,7 @@ const template = {
     "speed is a quantity",
     "point is a concept",
     // TODO fix/add this "position means point",
-    "points are nameable orderable and memorable",
+    "points are nameable orderable countable and memorable",
     "drone modifies direction",
     (args) => {
       expectDirection(args)
@@ -753,20 +809,33 @@ const template = {
     },
     {
       operators: [
-        "([do] (path))",
+        // "([do] (path))",
         "([patrol] (path))",
         "([lift|lift,raise] (@<= arm || @<= claw))",
         "([lower] (@<= arm || @<=claw))",
         "([open] (claw))",
         "([close] (claw))",
-        "([back])",
-        "([forth])",
+        "([pathComponent])",
+        "(<another> (point))",
         // "([turn] (direction))",
-        "([pause] ([number]))",
+        // "([pause] ([number]))",
         "([stop] ([drone|])?)",
         "([toPoint|to] (point))",
       ],
       bridges: [
+        { 
+          id: 'another',
+          bridge: `{
+            ...next(after[0]),
+            another: operator,
+            after: after[0],
+            interpolate: [ { property: 'another' }, { property: 'after' } ]
+          }`,
+        },
+        { 
+          id: 'pathComponent',
+          children: ['point', 'pause'],
+        },
         {
           id: 'patrol',
           isA: ['verb'],
@@ -789,6 +858,7 @@ const template = {
             objects.runCommand = true
           }
         },
+        /*
         {
           id: 'do',
           isA: ['verb'],
@@ -804,6 +874,7 @@ const template = {
             objects.runCommand = true
           }
         },
+        */
         {
           id: 'lift',
           isA: ['verb'],
@@ -845,13 +916,10 @@ const template = {
           }
         },
         {
-          id: "back",
+          id: 'back',
           isA: ['noun'],
-          semantic: async ({objects, mentions, api, e, context}) => {
-            objects.runCommand = true
-            const ordinal = api.currentOrdinal() - 1
-            const lastPoint = mentions({ context: { marker: 'point' }, condition: (context) => context.ordinal == ordinal })
-            objects.current.path.push(lastPoint)
+          semantic: async ({objects, mentions, api, e, context, say}) => {
+            await api.back()
           }
         },
         {
@@ -872,32 +940,43 @@ const template = {
         { 
           id: "go",
           level: 0,
-          isA: ['verb'],
+          // convolution: true,
+          isA: ['verb', 'action'],
           words: [
             ...conjugateVerb('go'),
           ],
+          check: defaultContextCheckProperties(['direction', 'distance', 'to']),
           bridge: `{ 
             ...next(operator), 
             distance: distance?, 
             direction: direction?,
+            points: points?,
             to: to?,
             operator: operator,
-            interpolate: [{ property: 'operator' }, { property: 'direction' }, { property: 'to' }, { property: 'distance' }] 
+            interpolate: [{ property: 'operator' }, { property: 'direction' }, { property: 'points' }, { property: 'to' }, { property: 'distance' }] 
           }`,
           selector: {
             arguments: {
               distance: "(@<= 'quantity' && context.unit.dimension == 'length')",
               direction: "(@<= 'direction')",
               to: "(@<= 'toPoint')",
+              points: "(@<= 'point')",
             },
           },
           semantic: async (args) => {
-            const {context, objects, e, toEValue} = args
+            const {context, objects, e, toArray, toEValue} = args
             if (context.distance) {
               await handleDistance(args, context.distance)
             }
             if (context.direction) {
-              objects.current.direction = context.direction.marker
+              const array = toArray(context.direction)
+              if (array.length == 2 && array[0].marker == 'back' && array[1].marker == 'forth') {
+                await args.api.backAndForth()
+              } else if (context.direction.marker == 'back') {
+                await args.api.back(context.points)
+              } else {
+                objects.current.direction = context.direction.marker
+              }
             }
             if (context.to) {
               const evaluation = await e(context.to.point)
@@ -931,7 +1010,7 @@ const template = {
             if (context.repeats) {
               current.timeRepeats = toFinalValue(context.repeats.repeats)
             }
-            const toRadians = async (angle) => {
+            async function toRadians(angle) {
               const fi = await fragments("40 degrees in radians")
               return await fi.instantiate([
                 { 
@@ -962,11 +1041,26 @@ const template = {
         {
           id: 'pause',
           isA: ['verb'],
-          bridge: "{ ...operator, time: after[0], interpolate: [{ context: operator }, { property: 'time' }] }",
-          semantic: async ({context}) => {
-            // why doesn't nodejs add a sleep function. I always have to look up how to do this because its not fucking memorable.
-            // function sleep(ms) { return new Promise(r => setTimeout(r, ms)); }
-            // await sleep(context.time.value*1000) 
+          words: ['pause'],
+          bridge: "{ ...operator, time: or(time?, forTime), interpolate: [{ context: operator }, { property: 'time' }] }",
+          check: defaultContextCheckProperties(['time']),
+          selector: {
+            arguments: {
+              forTime: "(@<= 'forQuantity' && context.quantity.unit.dimension == 'time')",
+              time: "(@<= 'quantity' && context.unit.dimension == 'time')",
+            },
+          },
+          semantic: async ({context, mentioned, api, e, fragments, toFinalValue}) => {
+            let time = context.time 
+            if (time.marker == 'forQuantity') {
+              time = time.quantity
+            }
+            const instantiation = await fragments("quantity in seconds", { quantity: time})
+            const result = await e(instantiation)
+            const seconds = toFinalValue(toFinalValue(result).amount)
+            context.pauseSeconds = seconds
+            mentioned(context)
+            api.pause(seconds)
           }
         },
         {
@@ -978,7 +1072,7 @@ const template = {
           bridge: "{ ...next(operator), object: after[0], interpolate: [{ context: operator }, { property: 'object' }] }",
           semantic: async ({mentioned, context, objects, api, say}) => {
             await api.stop()
-            api.markCurrentPoint()
+            await api.markCurrentPoint()
           }
         },
       ],
@@ -993,9 +1087,20 @@ const template = {
         },
       ],
       semantics: [
+        {
+          match: ({context}) => context.marker == 'doAction',
+          apply: async ({context, e, toEValue, objects}) => {
+            const evaluated = await(e(context.action))
+            const path = toEValue(evaluated)
+            for (const point of path.points) {
+              objects.current.path.push(point)
+            }
+            objects.runCommand = true
+          }
+        },
         {
           match: ({context, contextHierarchy}) => {
-            if (!context.pullFromContext || !context.evaluate || contextHierarchy.under('do')) {
+            if (!context.pullFromContext || !context.evaluate || contextHierarchy.under(['doAction', 'evaluate'])) {
               return false
             }
             
@@ -1003,12 +1108,37 @@ const template = {
               return true
             }
           },
-          apply: async ({context, fragments, stm, objects, mentioned, mentions, resolveEvaluate, _continue, contextHierarchy}) => {
-            const points = mentions({ context: { marker: 'point' }, all: true })
+          apply: async ({context, frameOfReference, toArray, fragments, stm, objects, mentioned, mentions, resolveEvaluate, _continue, contextHierarchy}) => {
+            const pathComponents = toArray(await mentions({ context: { marker: 'pathComponent' }, all: true }))
             const path = (await fragments('path')).contexts()[0]
-            path.points = points.reverse()
+            delete path.value
+            path.points = pathComponents.reverse()
+            frameOfReference(path, { mentioned: 'points', reversed: true })
             await mentioned(path)
-            _continue()
+
+            _continue() // let the call pick the object out from the stm
+          },
+        },
+        {
+          match: ({context, contextHierarchy}) => {
+            if (!context.pullFromContext || !context.evaluate || !contextHierarchy.under('call') || context.notUnderCall) {
+              return false
+            }
+            
+            if (context.marker == 'point' || context.marker == 'ordinal') {
+              return true
+            }
+          },
+          apply: async ({context, e, fragments, stm, toEValue, toArray, objects, mentioned, mentions, resolveEvaluate, _continue, contextHierarchy}) => {
+            const evaluated = await e({...context, notUnderCall: true})
+            const pointsContext = toEValue(evaluated)
+            const pathComponents = toArray(pointsContext)
+
+            const path = (await fragments('path')).contexts()[0]
+            delete path.value
+            path.points = pathComponents.reverse()
+            await mentioned(path)
+            resolveEvaluate(context, path)
           },
         },
         {
@@ -1022,7 +1152,7 @@ const template = {
         {
           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, mentions}) => {
-            const path = mentions({ context: context.objects[1] })
+            const path = await mentions({ context: context.objects[1] })
             if (!path?.points) {
               return
             }
@@ -1084,15 +1214,8 @@ const template = {
               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)
-            // objects.current.path.push({ ...lastPoint, aimOnly: true })
+          apply: async ({api}) => {
+            await api.backAndForth()
           }
         }
       ],
@@ -1102,7 +1225,7 @@ const template = {
 
 knowledgeModule( { 
   config: { name: 'drone' },
-  includes: [angle, compass, nameable, ordinals, hierarchy, rates, help],
+  includes: [actions, angle, compass, nameable, ordinals, hierarchy, rates, help],
   api: () => new API(),
 
   module,
@@ -1112,9 +1235,32 @@ knowledgeModule( {
     contents: drone_tests,
     checks: {
       context: [
-        defaultContextCheck({ marker: 'path', exported: true, extra: ['points', { property: 'stm', check: ['id', 'names'] }] }),
-        defaultContextCheck({ marker: 'go', exported: true, extra: ['direction', 'distance'] }),
-        defaultContextCheck({ marker: 'point', exported: true, extra: ['ordinal', { property: 'point', check: ['x', 'y'] }, 'description', { property: 'stm', check: ['id', 'names'] }] }),
+        defaultContextCheck({ marker: 'path', exported: true, 
+          extra: [
+            'points', 
+            { 
+              property: 'namespaced', 
+              check: [
+                { property: 'stm', check: ['id'] },
+                { property: 'nameable', check: ['names'] },
+              ] 
+            }
+          ] 
+        }),
+        defaultContextCheck({ marker: 'point', exported: true, 
+          extra: [
+            'ordinal', 
+            { property: 'point', check: ['x', 'y'] }, 
+            'description', 
+            { 
+              property: 'namespaced', 
+              check: [
+                { property: 'stm', check: ['id'] },
+                { property: 'nameable', check: ['names'] },
+              ] 
+            },
+          ] 
+        }),
         defaultContextCheck({ marker: 'turn', exported: true, extra: ['direction', 'repeats'] }),
         defaultContextCheck({ marker: 'history', exported: true, extra: ['debug', 'pause', 'direction', 'speed', 'turn', 'time', 'sonic', 'batched', 'repeats', 'armAction', 'clawAction'] }),
         defaultContextCheck(),