Test & fix all peripherals except turtle

Author: neumond

computercraft/back.lua

@@ -15,6 +15,18 @@ ws.send(textutils.serializeJSON{
     args={...},
 })
 
+function nullify_array(a, size)
+    local r = {}
+    for k=1,size do
+        if a[k] == nil then
+            r[k] = textutils.json_null
+        else
+            r[k] = a[k]
+        end
+    end
+    return r
+end
+
 while true do
     local event, p1, p2, p3, p4, p5 = os.pullEvent()
 
@@ -56,7 +68,7 @@ while true do
         ws.send(textutils.serializeJSON{
             action='event',
             event=event,
-            params={p1, p2, p3, p4, p5},
+            params=nullify_array({p1, p2, p3, p4, p5}, 5),
         })
     end
 

computercraft/rproc.py

@@ -57,7 +57,7 @@ def any_list(result):
 def fact_tuple(*components, tail_nils=0):
     def proc(result):
         result = any_list(result)
-        assert len(components) + tail_nils >= len(result) >= len(components)
+        assert len(components) >= len(result) >= len(components) - tail_nils
         while len(result) < len(components):
             result.append(None)
         assert len(components) == len(result)
@@ -120,3 +120,12 @@ def proc(result):
 array_string = fact_array(string)
 option_integer = fact_option(integer)
 option_string = fact_option(string)
+
+
+option_string_bool = fact_option(fact_union(
+    (
+        lambda v: v is True or v is False,
+        boolean,
+    ),
+    pelse=string,
+))

computercraft/subapis/disk.py

@@ -1,16 +1,7 @@
 from typing import Optional, Union
 
 from .base import BaseSubAPI
-from ..rproc import boolean, string, nil, option_integer, option_string, fact_option, fact_union
-
-
-option_string_bool = fact_option(fact_union(
-    (
-        lambda v: v is True or v is False,
-        boolean,
-    ),
-    pelse=string,
-))
+from ..rproc import boolean, nil, option_integer, option_string, option_string_bool
 
 
 class DiskAPI(BaseSubAPI):

computercraft/subapis/mixins.py

@@ -54,6 +54,3 @@ async def getPaletteColor(self, colorID: int) -> Tuple[float, float, float]:
 
     async def setPaletteColor(self, colorID: int, r: float, g: float, b: float):
         return nil(await self._send('setPaletteColor', colorID, r, g, b))
-
-    async def nativePaletteColor(self, colorID: int) -> Tuple[float, float, float]:
-        return tuple3_number(await self._send('nativePaletteColor', colorID))

computercraft/subapis/os.py

@@ -8,12 +8,18 @@
 class CCEventQueue:
     def __init__(self, q):
         self._q = q
-
-    def __aiter__(self):
-        return self
-
-    async def __anext__(self):
-        return await self._q.get()
+        self.filter = self.default_filter
+
+    @staticmethod
+    def default_filter(msg):
+        return True, msg
+
+    async def __aiter__(self):
+        while True:
+            msg = await self._q.get()
+            emit, msg = self.filter(msg)
+            if emit:
+                yield msg
 
 
 class OSAPI(BaseSubAPI):

computercraft/subapis/peripheral.py

@@ -1,13 +1,20 @@
-from typing import Optional, List, Tuple, Any
+from contextlib import asynccontextmanager
+from dataclasses import dataclass
+from typing import Optional, List, Tuple, Any, Union
 
-from .base import BaseSubAPI
+from .base import BaseSubAPI, LuaNum
 from .mixins import TermMixin
-from ..rproc import boolean, nil, integer, string, option_integer, option_string, tuple2_integer, array_string
+from ..errors import LuaException
+from ..rproc import (
+    boolean, nil, integer, string, option_integer, option_string,
+    tuple2_integer, array_string, option_string_bool, fact_tuple,
+)
 
 
 class CCPeripheral(BaseSubAPI):
-    def __init__(self, cc, call_fn):
+    def __init__(self, cc, side, call_fn):
         super().__init__(cc)
+        self._side = side
         self._send = call_fn
 
 
@@ -30,8 +37,8 @@ async def getMountPath(self) -> Optional[str]:
     async def hasAudio(self) -> bool:
         return boolean(await self._send('hasAudio'))
 
-    async def getAudioTitle(self) -> Optional[str]:
-        return option_string(await self._send('getAudioTitle'))
+    async def getAudioTitle(self) -> Optional[Union[bool, str]]:
+        return option_string_bool(await self._send('getAudioTitle'))
 
     async def playAudio(self):
         return nil(await self._send('playAudio'))
@@ -47,6 +54,9 @@ async def getDiskID(self) -> Optional[int]:
 
 
 class CCMonitor(CCPeripheral, TermMixin):
+    async def getTextScale(self) -> int:
+        return integer(await self._send('getTextScale'))
+
     async def setTextScale(self, scale: int):
         return nil(await self._send('setTextScale', scale))
 
@@ -64,11 +74,21 @@ async def reboot(self):
     async def getID(self) -> int:
         return integer(await self._send('getID'))
 
+    async def getLabel(self) -> Optional[str]:
+        return option_string(await self._send('getLabel'))
+
     async def isOn(self) -> bool:
         return boolean(await self._send('isOn'))
 
 
-class CCModem(CCPeripheral):
+@dataclass
+class ModemMessage:
+    reply_channel: int
+    content: Any
+    distance: LuaNum
+
+
+class ModemMixin:
     async def isOpen(self, channel: int) -> bool:
         return boolean(await self._send('isOpen', channel))
 
@@ -87,13 +107,41 @@ async def transmit(self, channel: int, replyChannel: int, message: Any):
     async def isWireless(self) -> bool:
         return boolean(await self._send('isWireless'))
 
-    # wired only functions below
+    def _mk_recv_filter(self, channel):
+        def filter(msg):
+            if msg[0] != self._side:
+                return False, None
+            if msg[1] != channel:
+                return False, None
+            return True, ModemMessage(*msg[2:])
+        return filter
+
+    @asynccontextmanager
+    async def receive(self, channel: int):
+        if await self.isOpen(channel):
+            raise Exception('Channel is busy')
+        await self.open(channel)
+        try:
+            async with self._cc.os.captureEvent('modem_message') as q:
+                q.filter = self._mk_recv_filter(channel)
+                yield q
+        finally:
+            await self.close(channel)
+
+
+class CCWirelessModem(CCPeripheral, ModemMixin):
+    pass
+
+
+class CCWiredModem(CCPeripheral, ModemMixin):
+    async def getNameLocal(self) -> Optional[str]:
+        return option_string(await self._send('getNameLocal'))
 
     async def getNamesRemote(self) -> List[str]:
         return array_string(await self._send('getNamesRemote'))
 
-    async def getTypeRemote(self, peripheralName: str) -> str:
-        return string(await self._send('getTypeRemote', peripheralName))
+    async def getTypeRemote(self, peripheralName: str) -> Optional[str]:
+        return option_string(await self._send('getTypeRemote', peripheralName))
 
     async def isPresentRemote(self, peripheralName: str) -> bool:
         return boolean(await self._send('isPresentRemote', peripheralName))
@@ -103,7 +151,11 @@ async def wrapRemote(self, peripheralName: str) -> CCPeripheral:
         async def call_fn(method, *args):
             return await self._send('callRemote', peripheralName, method, *args)
 
-        return TYPE_MAP[await self.getTypeRemote(peripheralName)](self._cc, call_fn)
+        ptype = await self.getTypeRemote(peripheralName)
+        if ptype is None:
+            return None
+
+        return TYPE_MAP[ptype](self._cc, None, call_fn)
 
 
 class CCPrinter(CCPeripheral):
@@ -135,6 +187,39 @@ async def getInkLevel(self) -> int:
         return integer(await self._send('getInkLevel'))
 
 
+class CCSpeaker(CCPeripheral):
+    async def playNote(self, instrument: str, volume: int = 1, pitch: int = 1) -> bool:
+        # instrument:
+        # https://minecraft.gamepedia.com/Note_Block#Instruments
+        # bass
+        # basedrum
+        # bell
+        # chime
+        # flute
+        # guitar
+        # hat
+        # snare
+        # xylophone
+        # iron_xylophone
+        # pling
+        # banjo
+        # bit
+        # didgeridoo
+        # cow_bell
+
+        # volume 0..3
+        # pitch 0..24
+        return boolean(await self._send('playNote', instrument, volume, pitch))
+
+    async def playSound(self, sound: str, volume: int = 1, pitch: int = 1):
+        # volume 0..3
+        # pitch 0..2
+        return boolean(await self._send('playSound', sound, volume, pitch))
+
+
+run_result = fact_tuple(boolean, option_string, tail_nils=1)
+
+
 class CCCommandBlock(CCPeripheral):
     async def getCommand(self) -> str:
         return string(await self._send('getCommand'))
@@ -143,15 +228,19 @@ async def setCommand(self, command: str):
         return nil(await self._send('setCommand', command))
 
     async def runCommand(self):
-        return nil(await self._send('runCommand'))
+        success, error_msg = run_result(await self._send('runCommand'))
+        if not success:
+            raise LuaException(error_msg)
+        else:
+            assert error_msg is None
 
 
 TYPE_MAP = {
     'drive': CCDrive,
     'monitor': CCMonitor,
     'computer': CCComputer,
-    'modem': CCModem,
     'printer': CCPrinter,
+    'speaker': CCSpeaker,
     'command': CCCommandBlock,
 }
 
@@ -168,9 +257,19 @@ async def getType(self, side: str) -> Optional[str]:
     async def getNames(self) -> List[str]:
         return array_string(await self._send('getNames'))
 
-    async def wrap(self, side: str) -> CCPeripheral:
-        # use instead getMethods and call
+    # use instead getMethods and call
+    async def wrap(self, side: str) -> Optional[CCPeripheral]:
         async def call_fn(method, *args):
             return await self._send('call', side, method, *args)
 
-        return TYPE_MAP[await self.getType(side)](self._cc, call_fn)
+        ptype = await self.getType(side)
+        if ptype is None:
+            return None
+
+        if ptype == 'modem':
+            if boolean(await self._send('call', side, 'isWireless')):
+                return CCWirelessModem(self._cc, side, call_fn)
+            else:
+                return CCWiredModem(self._cc, side, call_fn)
+        else:
+            return TYPE_MAP[ptype](self._cc, side, call_fn)

computercraft/subapis/term.py

@@ -2,7 +2,7 @@
 
 from .base import BaseSubAPI
 from .mixins import TermMixin
-from ..rproc import nil, tuple2_integer
+from ..rproc import nil, tuple2_integer, tuple3_number
 
 
 class CCWindow(BaseSubAPI, TermMixin):
@@ -29,6 +29,9 @@ async def reposition(self, x: int, y: int, width: int = None, height: int = None
 class TermAPI(BaseSubAPI, TermMixin):
     _API = 'term'
 
+    async def nativePaletteColor(self, colorID: int) -> Tuple[float, float, float]:
+        return tuple3_number(await self._send('nativePaletteColor', colorID))
+
     # TODO
     # term.redirect(target) 	table previous terminal object
     # term.current() 	table terminal object