working through errors and logging, plus new bootstrap

zss/device/api.ts

@@ -5,15 +5,22 @@ without having to include device code
 
 */
 
+import { INPUT } from 'zss/gadget/data/types'
 import { hub } from 'zss/hub'
 import { BOOK } from 'zss/memory/book'
 
+export function api_error(sender: string, message: string, player: string) {
+  hub.emit('error', sender, message, player)
+  return tape_error(sender, [message, player])
+}
+
 export function tape_log(sender: string, ...message: any[]) {
   hub.emit('tape:log', sender, message)
   return true
 }
 
-export function tape_error(sender: string, ...message: any[]) {
+// internal only, use api_error
+function tape_error(sender: string, ...message: any[]) {
   hub.emit('tape:error', sender, message)
   return false
 }
@@ -26,6 +33,23 @@ export function register_write(sender: string, name: string, value: any) {
   hub.emit('register:write', sender, [name, value])
 }
 
-export function vm_mem(sender: string, book: BOOK) {
-  hub.emit('vm:mem', sender, book)
+export function vm_mem(sender: string, book: BOOK, player: string) {
+  hub.emit('vm:mem', sender, book, player)
+}
+
+export function vm_login(sender: string, player: string) {
+  hub.emit('vm:login', sender, undefined, player)
+}
+
+export function vm_doot(sender: string, player: string) {
+  hub.emit('vm:doot', sender, undefined, player)
+}
+
+export function vm_input(
+  sender: string,
+  input: INPUT,
+  mods: Record<INPUT, number>,
+  player: string,
+) {
+  hub.emit('vm:input', sender, [input, mods], player)
 }

zss/device/bip.ts

@@ -0,0 +1,45 @@
+import { createdevice } from 'zss/device'
+
+import { vm_doot, vm_login } from './api'
+import { gadgetstategetplayer, gadgetstatesetplayer } from './gadgetclient'
+
+// simple bootstrap manager
+
+const bip = createdevice(
+  'bip',
+  ['second', 'ready', 'error', 'memset'],
+  (message) => {
+    // ??
+    console.info(message)
+
+    switch (message.target) {
+      case 'second': {
+        const player = gadgetstategetplayer()
+        if (player) {
+          vm_doot(bip.name(), player)
+        }
+        break
+      }
+      case 'ready':
+        if (message.player) {
+          if (gadgetstatesetplayer(message.player)) {
+            vm_login(bip.name(), message.player)
+          }
+        }
+        break
+      case 'error':
+        if (message.player) {
+          switch (message.data) {
+            case 'with login':
+              // issue reboot
+              break
+          }
+        }
+        break
+      case 'memset':
+        if (message.player) {
+          //
+        }
+    }
+  },
+)

zss/device/gadgetclient.ts

@@ -27,17 +27,6 @@ const gadgetclientdevice = createdevice(
   ['ready', 'second'],
   (message) => {
     switch (message.target) {
-      case 'ready':
-        if (message.player && syncstate.state.player === '') {
-          syncstate.state.player = message.player
-          gadgetclientdevice.emit('vm:login', undefined, syncstate.state.player)
-        }
-        break
-      case 'second':
-        if (syncstate.state.player) {
-          gadgetclientdevice.emit('vm:doot', undefined, syncstate.state.player)
-        }
-        break
       case 'reset':
         if (message.player === syncstate.state.player) {
           desync = false
@@ -69,3 +58,15 @@ const gadgetclientdevice = createdevice(
 export function getgadgetstate(): GADGET_STATE {
   return syncstate.state
 }
+
+export function gadgetstatesetplayer(player: string) {
+  if (player && syncstate.state.player === '') {
+    syncstate.state.player = player
+    return true
+  }
+  return false
+}
+
+export function gadgetstategetplayer() {
+  return syncstate.state.player
+}

zss/device/register.ts

@@ -2,7 +2,7 @@ import { createdevice } from 'zss/device'
 import { encodeduritovalue, valuetoencodeduri } from 'zss/mapping/buffer'
 import { ispresent } from 'zss/mapping/types'
 
-import { vm_mem } from './api'
+import { api_error, tape_log, vm_mem } from './api'
 
 function readstate(): [any, any] {
   try {
@@ -25,13 +25,16 @@ function writestate(state: any) {
 const register = createdevice('register', [], (message) => {
   switch (message.target) {
     // memory
-    case 'reboot': {
-      const [mem] = readstate()
-      if (ispresent(mem)) {
-        vm_mem(register.id(), mem)
+    case 'reboot':
+      if (message.player) {
+        const [mem] = readstate()
+        if (ispresent(mem)) {
+          vm_mem(register.name(), mem, message.player)
+        } else {
+          api_error(register.name(), 'reboot failed', message.player)
+        }
       }
       break
-    }
     case 'flush': {
       const [, flags] = readstate()
       if (ispresent(message.data)) {
@@ -47,9 +50,9 @@ const register = createdevice('register', [], (message) => {
         const value = flags[name]
         if (ispresent(flags)) {
           register.reply(message, 'register', [name, value])
-          console.info('read', value, 'for', name)
+          tape_log(register.name(), 'read', value, 'for', name)
         } else {
-          console.info(name, 'is empty')
+          tape_log(register.name(), 'read', name, 'is empty')
         }
       }
       break
@@ -60,7 +63,7 @@ const register = createdevice('register', [], (message) => {
       if (ispresent(flags)) {
         flags[name] = value
         writestate([mem, flags])
-        console.info('wrote', value, 'to', name)
+        tape_log(register.name(), 'wrote', value, 'to', name)
       }
       break
     }

zss/device/vm.ts

@@ -12,15 +12,15 @@ import {
 } from 'zss/memory'
 import { createos } from 'zss/os'
 
-import { tape_error, tape_log } from './api'
+import { api_error, tape_log } from './api'
 
 // limited chars so peerjs doesn't get mad
 const justNumberChars = customAlphabet(numbers, 4)
 const mixedChars = customAlphabet(`${numbers}${lowercase}`, 16)
 
 // this should be unique every time the worker is created
-const player = `pid_${justNumberChars()}_${mixedChars()}`
-memorysetdefaultplayer(player)
+const playerid = `pid_${justNumberChars()}_${mixedChars()}`
+memorysetdefaultplayer(playerid)
 
 // manages chips
 const os = createos()
@@ -29,46 +29,32 @@ const os = createos()
 const LOOP_TIMEOUT = 32 * 15
 const tracking: Record<string, number> = {}
 
-const vm = createdevice('vm', ['login', 'tick', 'tock'], (message) => {
+const vm = createdevice('vm', ['tick', 'tock'], (message) => {
   switch (message.target) {
     case 'mem':
-      if (message.player === player) {
+      if (message.player === playerid) {
         memoryresetbooks(message.data)
-        tape_log(vm.id(), 'memset')
-        vm.emit('memset', undefined, message.player)
+        tape_log(vm.name(), 'ackmem', message.player)
+        vm.emit('ackmem', undefined, message.player)
       }
       break
     case 'login':
       if (message.player) {
         if (memoryplayerlogin(message.player)) {
           tracking[message.player] = 0
+          tape_log(vm.name(), 'acklogin', message.player)
+          vm.emit('acklogin', undefined, message.player)
         } else {
-          tape_error(vm.id(), 'with login')
-          vm.emit('error', 'with login', message.player)
+          api_error(vm.name(), 'with login', message.player)
         }
       }
       break
-    case 'tick':
-      memorytick(os, message.data)
-      break
-    case 'tock':
-      // iterate over logged in players
-      Object.keys(tracking).forEach((player) => {
-        ++tracking[player]
-        if (tracking[player] > LOOP_TIMEOUT) {
-          // drop inactive players (logout)
-          delete tracking[player]
-          memoryplayerlogout(player)
-          tape_log(vm.id(), 'logout', player)
-          vm.emit('player', 'did logout', player)
-        }
-      })
-      break
     case 'doot':
       // player keepalive
       if (message.player) {
         tracking[message.player] = 0
-        tape_log(vm.id(), '.', message.player)
+        tape_log(vm.name(), '.', message.player)
+        vm.emit('doot', undefined, message.player)
       }
       break
     case 'input':
@@ -80,6 +66,23 @@ const vm = createdevice('vm', ['login', 'tick', 'tock'], (message) => {
         memory.inputmods[input as INPUT] = mods
       }
       break
+    // from clock
+    case 'tick':
+      memorytick(os, message.data)
+      break
+    case 'tock':
+      // iterate over logged in players
+      Object.keys(tracking).forEach((player) => {
+        ++tracking[player]
+        if (tracking[player] > LOOP_TIMEOUT) {
+          // drop inactive players (logout)
+          delete tracking[player]
+          memoryplayerlogout(player)
+          tape_log(vm.name(), 'logout', player)
+          vm.emit('logout', undefined, player)
+        }
+      })
+      break
     default:
       os.message(message)
       break
@@ -89,5 +92,5 @@ const vm = createdevice('vm', ['login', 'tick', 'tock'], (message) => {
 export function ready() {
   // TODO: load default software ...
   // signal ready state
-  vm.emit('ready', undefined, player)
+  vm.emit('ready', undefined, playerid)
 }

zss/platform.ts

@@ -2,6 +2,7 @@ import { createforward } from './device/forward'
 import ZSSWorker from './instance??worker'
 
 // devices that operate within web main
+import './device/bip'
 import './device/gadgetclient'
 import './device/pcspeaker'
 import './device/register'