Created sm.modpackAPI for other mods to use

.gitignore

@@ -1,3 +1,4 @@
 /cache/
 /description.json
-preview.png
+preview.png
+.vscode/

Scripts/interactable/NumberLogic/CounterBlock.lua

@@ -57,23 +57,52 @@ CounterBlock.digs = {
 	["577d07ff"] = -0.00000001
 }
 
+local counters = {}
+
+sm.modpackAPI = sm.modpackAPI or {}
+sm.modpackAPI.counter = {}
+
+function sm.modpackAPI.counter.setValue(interactableid, value)
+    local counter = counters[interactableid]
+    if counter then
+        counter.power = value
+        counter.interactable:setPower(value)
+        counter.needssave = true
+        return true
+    end
+	return false
+end
+
+function sm.modpackAPI.counter.getValue(interactableid)
+    local counter = counters[interactableid]
+    if counter then
+        return counter.power
+    end
+    return nil
+end
 
 function CounterBlock.server_onRefresh( self )
-	sm.isDev = true
-	self:server_onCreate()
+    sm.isDev = true
+    self:server_onCreate()
 end
 
 function CounterBlock.server_onCreate( self )
-	local stored = self.storage:load()
-	if stored then
-		if type(stored) == "table" then -- compatible with old versions (they used a jank workaround for a bug back then)
-			self.power = tonumber(stored[1])
-		else
-			self.power = tonumber(stored)
-		end
-		self.interactable:setPower(self.power)
-	end
-	sm.interactable.setValue(self.interactable, self.power)
+    local stored = self.storage:load()
+    if stored then
+        if type(stored) == "table" then -- compatible with old versions (they used a jank workaround for a bug back then)
+            self.power = tonumber(stored[1])
+        else
+            self.power = tonumber(stored)
+        end
+        self.interactable:setPower(self.power)
+    end
+    sm.interactable.setValue(self.interactable, self.power)
+
+    counters[self.interactable.id] = self
+end
+
+function CounterBlock.server_onDestroy(self)
+	counters[self.interactable.id] = nil
 end
 
 function CounterBlock.server_onFixedUpdate( self, dt )

Scripts/interactable/NumberLogic/MathBlock.lua

@@ -59,7 +59,7 @@ MathBlock.modetable = {--"value" aka "savevalue", gets saved, gets loaded.
 }
 MathBlock.savemodes = {}
 for k,v in pairs(MathBlock.modetable) do
-   MathBlock.savemodes[v.value]=k
+    MathBlock.savemodes[v.value]=k
 end
 
 MathBlock.modeFunctions = {
@@ -826,34 +826,62 @@ MathBlock.modeFunctions = {
 		end
 }
 
+local mathblocks = {}
+sm.modpackAPI = sm.modpackAPI or {}
+sm.modpackAPI.mathblock = {}
 
+function sm.modpackAPI.mathblock.getMode(interactableid)
+	local mathblock = mathblocks[interactableid]
+	if mathblock then
+		return mathblock.mode
+	end
+	return nil
+end
+
+function sm.modpackAPI.mathblock.setMode(interactableid, mode)
+	local mathblock = mathblocks[interactableid]
+	if mathblock then
+		mathblock.mode = mode
+        mathblock.storage:save(mathblock.modetable[mode].value)
+		mathblock.needUpdateUV = true
+	end
+end
 
 function MathBlock.server_onRefresh( self )
 	sm.isDev = true
 	self:server_onCreate()
 end
 
 function MathBlock.server_onCreate( self )
-	local stored = self.storage:load()
-	if stored then
-		if type(stored) == "number" then
-			self.mode = self.savemodes[stored]
-		elseif type(stored) == "table" then
-			self.mode = self.savemodes[stored.mode] -- backwards compatibility
-		end
-	else
-		self.storage:save(self.modetable[self.mode].value)
-	end
-	sm.interactable.setValue(self.interactable, 0)
-end
+    local stored = self.storage:load()
+	self.needUpdateUV = false
+    if stored then
+        if type(stored) == "number" then
+            self.mode = self.savemodes[stored]
+        elseif type(stored) == "table" then
+            self.mode = self.savemodes[stored.mode] -- backwards compatibility
+        end
+    else
+        self.storage:save(self.modetable[self.mode].value)
+    end
+    sm.interactable.setValue(self.interactable, 0)
 
+    mathblocks[self.interactable.id] = self
+end
 
+function MathBlock.server_onDestroy(self)
+	mathblocks[self.interactable.id] = nil
+end
 
 function MathBlock.server_onFixedUpdate( self, dt )
 	local parents = self.interactable:getParents()
 
 	local mode = self.modetable[self.mode].value
-	self.modeFunctions[mode](self, parents)
+    self.modeFunctions[mode](self, parents)
+	if self.needUpdateUV then
+		self.network:sendToClients("cl_setMode", {self.mode, false})
+		self.needUpdateUV = false
+	end
 
 	self.lastmode = self.mode
 end

Scripts/interactable/NumberLogic/MemoryPanel.lua

@@ -9,15 +9,48 @@ print("loading MemoryPanel.lua")
 
 local memorypanels = {}
 
+sm.modpackAPI = sm.modpackAPI or {}
+sm.modpackAPI.memorypanel = {}
+
+function sm.modpackAPI.memorypanel.write(interactableid, saveValue)
+    local panel = memorypanels[interactableid]
+    if panel then
+        panel:server_setData(saveValue)
+        return true
+    end
+	return false
+end
+
 sm.modpack = {
-	memorypanelWrite = function(interactableid, saveValue)
-		local panel = memorypanels[interactableid]
-		if panel then
-			panel:server_setData(saveValue)
-		end
-	end
+	memorypanelWrite = sm.modpackAPI.memorypanel.write -- backwards compatibility with mods that use this function
 }
 
+function sm.modpackAPI.memorypanel.read(interactableid)
+    local panel = memorypanels[interactableid]
+    if panel then
+        return panel.data
+    end
+    return nil
+end
+
+function sm.modpackAPI.memorypanel.writeValue(interactableid, address, value)
+    local panel = memorypanels[interactableid]
+    if panel then
+        panel.data[address] = tonumber(value) or 0
+        panel.storage:save(panel.data)
+        return true
+    end
+    return false
+end
+
+function sm.modpackAPI.memorypanel.readValue(interactableid, address)
+	local panel = memorypanels[interactableid]
+	if panel then
+		return panel.data[address]
+	end
+	return nil
+end
+
 -- MemoryPanel.lua --
 MemoryPanel = class( nil )
 MemoryPanel.maxParentCount = -1
@@ -58,6 +91,10 @@ function MemoryPanel.server_onCreate( self )
 	memorypanels[self.interactable.id] = self
 end
 
+function MemoryPanel.server_onDestroy( self )
+	memorypanels[self.interactable.id] = nil
+end
+
 function MemoryPanel.server_setData(self, saveData)
 	self.data = saveData
 	self.storage:save(saveData)

Scripts/interactable/NumberLogic/WirelessBlock.lua

@@ -17,27 +17,78 @@ WirelessBlock.colorHighlight = sm.color.new( 0xaaaaaaff )
 WirelessBlock.poseWeightCount = 3
 
 if not wirelessdata then wirelessdata = {} end
+local wirelessrouters = {}
 
+sm.modpackAPI = sm.modpackAPI or {}
+sm.modpackAPI.wirelessblock = {}
+function sm.modpackAPI.wirelessblock.setIsSender(interactableid, isSender)
+    local block = wirelessrouters[interactableid]
+    if block then
+        block.IsSender = isSender
+        block.storage:save(isSender)
+		block.needUpdateMode = true
+        return true
+    end
+    return false
+end
+
+function sm.modpackAPI.wirelessblock.getIsSender(interactableid)
+    local block = wirelessrouters[interactableid]
+    if block then
+        return block.IsSender
+    end
+    return nil
+end
+
+function sm.modpackAPI.wirelessblock.getWirelessData()
+    return wirelessdata
+end
+
+function sm.modpackAPI.wirelessblock.getWirelessDataValues(frequency, color)
+    local data = wirelessdata[frequency]
+    if data then
+		-- data[color] is a table of interactables
+        local valuesTable = {}
+		for _, interactable in pairs(data[color]) do
+			local value = sm.interactable.getValue_shadow(interactable)[1]
+			if value then
+				table.insert(valuesTable, {interactable.id, value})
+			end
+		end
+		return valuesTable
+    end
+    return nil
+end
 
 function WirelessBlock.server_onRefresh( self )
 	sm.isDev = true
 	self:server_onCreate()
 end
 function WirelessBlock.server_onCreate( self )
-	self.IsSender = true
-	local stored = self.storage:load()
-	if stored ~= nil then
-		if type(stored) == "number" then
-			self.IsSender = (stored == 1) -- backwards compatibility with workaround artifacts
-		else -- boolean
-			self.IsSender = stored 
-		end
-	end
-	self.storage:save(self.IsSender)
+    self.IsSender = true
+	self.needUpdateMode = false
+    local stored = self.storage:load()
+    if stored ~= nil then
+        if type(stored) == "number" then
+            self.IsSender = (stored == 1) -- backwards compatibility with workaround artifacts
+        else -- boolean
+            self.IsSender = stored
+        end
+    end
+    self.storage:save(self.IsSender)
+
+    wirelessrouters[self.interactable.id] = self
 end
 
-function WirelessBlock.server_onFixedUpdate( self, dt )
+function WirelessBlock.server_onDestroy(self)
+	wirelessrouters[self.interactable.id] = nil
+end
 
+function WirelessBlock.server_onFixedUpdate( self, dt )
+	if self.needUpdateMode then
+		self.needUpdateMode = false
+		self:server_sendModeToClient(false)
+	end
 	if self.IsSender then 
 		-- client side handles getting values and making them global so that the server receiver can read them.
 		mp_updateOutputData(self, 0, false) -- make sure nothing attached to a sender can get a value
@@ -66,8 +117,8 @@ function WirelessBlock.server_onFixedUpdate( self, dt )
 		local power_values = {}
 
 
-		if wirelessdata[frequency] and wirelessdata[frequency][color] then
-			for k, v in pairs(wirelessdata[frequency][color]) do
+        if wirelessdata[frequency] and wirelessdata[frequency][color] then
+            for k, v in pairs(wirelessdata[frequency][color]) do
 				if sm.exists(v) and sm.interactable.getValue_shadow(v) then
 					table.insert(power_values, sm.interactable.getValue_shadow(v)[1])
 					table.insert(pose_values, sm.interactable.getValue_shadow(v)[2]) -- shadow val should always exist.

Scripts/interactable/NumberOut/SmartSensor.lua

@@ -42,19 +42,46 @@ for k,v in pairs(SmartSensor.modes) do
    SmartSensor.savemodes[v.value] = k
 end
 
+local smartsensors = {}
+
+sm.modpackAPI = sm.modpackAPI or {}
+sm.modpackAPI.smartsensor = {}
+
+function sm.modpackAPI.smartsensor.setMode(interactableid, mode)
+    local sensor = smartsensors[interactableid]
+    if sensor then
+        sensor:sv_setMode({ mode = mode })
+        return true
+    end
+    return false
+end
+
+function sm.modpackAPI.smartsensor.getMode(interactableid)
+    local sensor = smartsensors[interactableid]
+    if sensor then
+        return sensor.mode
+    end
+    return nil
+end
 
 function SmartSensor.server_onRefresh( self )
 	sm.isDev = true
 	self:server_onCreate()
 end
 
 function SmartSensor.server_onCreate( self )
-	local stored = self.storage:load()
-	if stored then
-		self.mode = self.savemodes[stored]
-	else
-		self.storage:save(self.modes[self.mode].value)
-	end
+    local stored = self.storage:load()
+    if stored then
+        self.mode = self.savemodes[stored]
+    else
+        self.storage:save(self.modes[self.mode].value)
+    end
+
+    smartsensors[self.interactable.id] = self
+end
+
+function SmartSensor.server_onDestroy(self)
+	smartsensors[self.interactable.id] = nil
 end
 
 function SmartSensor.server_onFixedUpdate( self, dt )