Subscribe to download
MicroLua

-- SPDX-FileCopyrightText: 2023 Matheus Izvekov <mizvekov@gmail.com>
-- SPDX-License-Identifier: ISC

-- Autoclosing door controller wiring instructions:
-- in1: connect to door state out.
-- in2: connect to motion sensor, detecting doorway obstruction.
-- in3..6: connect to emergency sensors
-- (ex. water and fire detectors on both sides of the door).
-- out1: door set_state input.

local lastClosedTime

inp = {}
function upd()
local isClosed = inp[1] ~= 1
local isDoorwayObstructed = inp[2] ~= 0
local hasEmergency = false
for i = 3, 6 do hasEmergency = hasEmergency or inp[i] == 1 end
table.clear(inp)

if hasEmergency then
if isClosed then
lastClosedTime = time()
return
end
if isDoorwayObstructed then return end
if lastClosedTime == nil or time() - lastClosedTime >= 4 then
lastClosedTime = nil
out[1] = 0
end
elseif lastClosedTime ~= nil then
lastClosedTime = nil
out[1] = 1
end
end

-- The body of the script is executed once per component load / source code change.
-- Use it to setup the component, define functions and do any other expensive one time computations.

-- Example: Define one state that will persist across frames.
-- These can effectively replace a memory component, but note they are not saved across rounds.
local somestate = 999

-- Create a new function.
local function foo(a, b)
return a + 10 ^ b
end

-- Define how signal inputs will be handled.
-- In the below example, inputs will be simply stored in a table.
inp = {}
-- You can alternatively define 'inp' as a function that
-- takes a pin and a value as inputs.
-- Eg. function inp(pin, val)

-- Create a function that will be called every frame.
function upd(deltaTime)
-- deltaTime is the time in seconds since the last frame.
-- If you need the absolute time, you can use the `time()` function instead.

-- Compute a value based on inputs.
local x = inp[1] * foo(inp[2], inp[3])

-- Produce an output.
out[1] = inp[3] / x
-- Note that `out` is not a table, you cannot read the outputs back.

-- Also note that `out` can be set from the `inp` callback, if defined.
-- This for example allows you to mimic the behavior of certain vanilla
-- components which produce outputs outside of frame updates, such as
-- the memory and signalcheck components.

-- After you are done using the inputs, you can optionally
-- clear them back to nil:
table.clear(inp)
-- That allows you to detect that a pin has not received any signal
-- since the last frame.
-- For example, that can be used to detect a wire has been disconnected.

-- Otherwise, not clearing them means it will contain the last values received,
-- which is good enough for most cases.
end

-- ADVANCED FUNCTIONALITY
-- You can check the current game mode.
-- Possible values: 'server', 'client', 'single'.
if mode == 'client' then
-- In a multiplayer game, the server and clients will be each
-- running the scripts independently.
-- Rarely, you will need to keep the clients synchronized to the server.
-- MicroLua leaves how exactly to perform this synchronization up to you.
-- It just provides the means for the server to send a string to the clients.

-- Define a function that will allow the clients to
-- receive a message from the server:
function recv(msg)
print('message received from server: ', msg)
end
-- A message then can be sent from the server to this callback, by using
-- the `send(msg)` function.

-- Note: As said previously, synchronization will rarely be needed at all.
-- For example, most devices that initiate a signal, such as buttons
-- and other components that react to character action, are already
-- synchronized themselves.
-- Use synchronization for long lived state in your program, which
-- is likely to not converge in the short term.
end

if mode == 'server' then
-- Send a message from the server to the clients.
send'hello world'

-- `send` is only available on 'server' mode.
-- Normally you would perform this sending in the `upd` callback somehow.
end