📃 SLua Alpha

Common usage of methods like ll.AgentInExperience etc in lsl is to just stick them in an if directly as 1 evaluates true As this is not the case in lua, it would be good for the relevant functions to return booleans. I have scoured the function list and updated the wiki to include all the ones I could see on a first pass through. https://wiki.secondlife.com/wiki/Category:LSL_Functions/Returns_a_integer/boolean ll.AgentInExperience ll.DerezObject ll.EdgeOfWorld ll.GetScriptState ll.GetStatus ll.IsFriend ll.ManageEstateAccess ll.SameGroup ll.ScaleByFactor ll.ScriptDanger ll.SetMemoryLimit Were missing and I added them, listed separately in case they are "wrong" ll.DetectedGroup ll.IsLinkGLTFMaterial ll.OverMyLand ll.SetRegionPos ll.VerifyRSA

There has already been some discussion of this in other canny's Like here But a centralized issue for feedback is probably a better idea. As the post by Harold Linden says in the above link, LL are considering something like LLEvents.touch_start = function ... Personally I would rather suggest something more akin to local handle = llevent.onTouchStart(function(touches:number) end) local handle = llevent.dispose(handle) or local handle = llevent.on(llevent.TOUCH_START, function(touches:number) end) llevent.dispose(handle) or (nya's suggestion) local function touchHandler(touches: number) end llevent.on(llevent.TOUCH_START, touchHandler) llevent.off(llevent.TOUCH_START, touchHandler) Mostly to allow for if not now, at least in the future multiple event handlers being setup and expanding to support things similar too function listenHandler(channel, name, key, msg) end local listener = ll.Listen(0,"","","test") llevent.on(llevent.LISTEN, listenHandler, listener) or function listenHandler(channel, name, key, msg) end llevent.on(llevent.LISTEN, listenHandler, {channel=0,message="test"}) Possibly something similar to roblox's "standard" , or something designed in a way that is compatible with it, so it can be properly extended later. This needs to happen BEFORE a possible beta phase There should also be NO COMPATABILITY with the current way of working, all current scripts SHOULD break and need rewriting, having both is not really a good option, and NOW is the time for breaking that.

function touch_start(total_number) ll.Say(0, "Touched.") end ll.OwnerSay("Hello, Avatar!") It's confusing for LSL scripters who are starting to learn SLua to be told that state_entry() doesn't exist, when the sample script includes it. There are many "Hello, Avatar!" messages in scripting classes or sandboxes.

This was briefly discussed in the original table to json feature . It would be useful to have to allow for encoding of more complex data structures, also to allow tables that have functions to be encoded by specifying them to not be included Probably best for __tojson to return what we want to be encoded rather than actual json? local Nested = {} Nested.__index = Nested function Nested:__tojson() return { name= self.name, child= if self.child then self.child else nil } end function Nested.new(name,parent) return setmetatable({ name=name, parent=parent, child=nil },Nested) end local root = Nested.new("root") root.child = Nested.new("child1",root) root.child.child = Nested.new("child2",root.child) ll.OwnerSay(lljson.encode(root)) Possibly this is deemed too much of an addition as it can be achieved atm with this local Nested = {} Nested.__index = Nested function Nested:__tojson() return { name= self.name, child= if self.child then self.child:__tojson() else nil } end function Nested.new(name,parent) return setmetatable({ name=name, parent=parent, child=nil },Nested) end local root = Nested.new("root") root.child = Nested.new("child1",root) root.child.child = Nested.new("child2",root.child) ll.OwnerSay(lljson.encode(root:__tojson()))

some ideas on how it could work: Required scripts are saved as a different type of script: modules, with a new compiler option: compile to "SLua scriopt" or to "Slua module". Modules are executed when required and return a value, with a return statement, for instance a table with functions and constants. Scripts call modules as myModule = require("Module name") , the returned value is assigned to the variable myModule , using the script's memory space. The module must be in the object contents with the script that requires it. If the module is not in the object, its running state is disabled, or it doesn't return a value, require() will return nil. Once it returns, the module is removed from memory and its variables are garbage-collected. Modules are executed synchronously, the main script is paused until the module returns. Modules don't receive events, any events that arrive while the module is executing are queued in the main script. Modules can't require other modules, only scripts can use require() .

The SLua code below demonstrates the problem. Two vectors, multiplied, results in a vector answer rather than a number. v1 = vector(9, 2, 7) v2 = vector(4,8,10) v3 = v1 * v2 ll.OwnerSay(typeof(v3) .. ": " .. tostring(v3)) Program output: vector: <36.00000, 16.00000, 70.00000> Reason for identifying as a bug: The SL Wiki indicates that the dot product should return the sum of the products of the vector elements. In this case, the expected result should be 122.0. What is returned instead is simply the vector of the products of each element.

A crashed script won't start on reset. The script state however does seem to be "running", seems to be the same in LSL on luau LSL and lso are unaffected Reproduction Steps 1 Object with 2 scripts Script 1: function touch_start(total_number) error("crash") end ll.Say(0,"boot") Script 2: local other = ""; for i=0,ll.GetInventoryNumber(INVENTORY_SCRIPT)-1 do other = ll.GetInventoryName(INVENTORY_SCRIPT,i) if other ~= ll.GetScriptName() then break end end timer = function() local crashed = ll.GetScriptState(other) ll.Say(0,`{other}: {crashed}`) end ll.SetTimerEvent(2.0) Save scripts and watch script as script 1 says boot and script 2 starts to say "<script_1_name>: 1" in chat Click the prim Should get an error saying crash the chat messaged should change to "<script_1_name>: 0" in chat reset the crashed script no message in local saying boot touch doesn't crash it again script 2 is saying "<script_1_name>: 1" in chat again Using ll.ResetOtherScript produces the same result

Traditional LSL requires bitwise operators quite often: event parameters ( changed ), function call flags ( llRezObjectWithParams ), ... Lua 5.3 introduced native bitwise operators: https://www.lua.org/manual/5.3/manual.html#3.4.2 Having these usable in SLua would be a significant quality-of-life improvement in the face of Luau's bit32 library, though the library does still include other very useful features like btest , replace , etc. The library should stay regardless. To be fair, Luau's reasoning for not including bitwise operators is decent, but LSL context adds quite a heavy weight on this decision. I don't know the work that would go into implementing these operators, but hopefully they can be implemented in such a way that makes use of the same VM built-ins as the bit32 library to avoid any performance penalties.

If a script is open in the external editor, print errors the client receives to a matching .log file. This would allow external tooling to pick them up and display them in editor. In the future with more advanced errors this could include source map support etc. Suggestion Client receives script error (be it on debug channel, or a compile error) Checks if script the error belongs to is open Checks if that script is open in external editor Appends error to matching file sl_script_<script_name>_<uuid>.luau.log

This should remove any undue runtime overhead from bit32.* calls and friends that have FASTCALL implementations.