1098 lines
34 KiB
Lua
1098 lines
34 KiB
Lua
-- bl library
|
|
-- Main lua-side functionality of bllua,
|
|
-- provided through the global table 'bl.'
|
|
|
|
local _bllua_ts = ts
|
|
|
|
bl = bl or {}
|
|
|
|
-- Misc
|
|
-- Apply a function to each element in a list, building a new list from the returns
|
|
local function map(t,f)
|
|
local u = {}
|
|
for i,v in ipairs(t) do
|
|
u[i] = f(v)
|
|
end
|
|
return u
|
|
end
|
|
local function isValidFuncName(name)
|
|
return type(name)=='string' and name:find('^[a-zA-Z_][a-zA-Z0-9_]*$')
|
|
end
|
|
local function isValidFuncNameNs(name)
|
|
return type(name)=='string' and (
|
|
name:find('^[a-zA-Z0-9_]+$') or
|
|
name:find('^[a-zA-Z0-9_]+::[a-zA-Z0-9_]+$') )
|
|
end
|
|
local function isValidFuncNameNsArgn(name)
|
|
return type(name)=='string' and (
|
|
name:find('^[a-zA-Z0-9_]+$') or
|
|
name:find('^[a-zA-Z0-9_]+%.[a-zA-Z0-9_]+$') or
|
|
name:find('^[a-zA-Z0-9_]+::[a-zA-Z0-9_]+$') or
|
|
name:find('^[a-zA-Z0-9_]+:[0-9]+$') or
|
|
name:find('^[a-zA-Z0-9_]+::[a-zA-Z0-9_]+:[0-9]+$') )
|
|
end
|
|
-- Whether a var can be converted into a TS vector
|
|
local function isTsVector(val)
|
|
if type(val)~='table' then return false end
|
|
if #val~=3 and #val~=2 then return false end
|
|
if val.__is_vector then return true end
|
|
for _,v in ipairs(val) do
|
|
if type(v)~='number' then return false end
|
|
end
|
|
return true
|
|
end
|
|
-- Use strings for object types instead of integer bitmasks like in TS
|
|
local tsTypesByName = {
|
|
['all'] = -1,
|
|
['static'] = 1,
|
|
['environment'] = 2,
|
|
['terrain'] = 4,
|
|
['water'] = 16,
|
|
['trigger'] = 32,
|
|
['marker'] = 64,
|
|
['gamebase'] = 1024,
|
|
['shapebase'] = 2048,
|
|
['camera'] = 4096,
|
|
['staticshape'] = 8192,
|
|
['player'] = 16384,
|
|
['item'] = 32768,
|
|
['vehicle'] = 65536,
|
|
['vehicleblocker'] = 131072,
|
|
['projectile'] = 262144,
|
|
['explosion'] = 524288,
|
|
['corpse'] = 1048576,
|
|
['debris'] = 4194304,
|
|
['physicalzone'] = 8388608,
|
|
['staticts'] = 16777216,
|
|
['brick'] = 33554432,
|
|
['brickalways'] = 67108864,
|
|
['staticrendered'] = 134217728,
|
|
['damagableitem'] = 268435456,
|
|
}
|
|
local tsTypesByNum = {}
|
|
for k,v in pairs(tsTypesByName) do
|
|
tsTypesByNum[v] = k
|
|
end
|
|
|
|
-- Type conversion from Lua to TS
|
|
local toTsObject
|
|
-- Convert a string from TS into a boolean
|
|
-- Note: Nonempty nonnumeric strings evaluate to 1, unlike in TS
|
|
local function tsBool(v) return v~='' and v~='0' end
|
|
-- Convert a Lua var into a TS string, or error if not possible
|
|
local function valToTs(val)
|
|
if val==nil then -- nil -> ''
|
|
return ''
|
|
elseif type(val)=='boolean' then -- bool -> 0 or 1
|
|
return val and '1' or '0'
|
|
elseif type(val)=='number' then -- number
|
|
return tostring(val)
|
|
elseif type(val)=='string' then -- string
|
|
return val
|
|
elseif type(val)=='table' then
|
|
if val._tsObjectId then -- object -> object id
|
|
return tostring(val._tsObjectId)
|
|
elseif isTsVector(val) then -- vector - > 3 numbers
|
|
return table.concat(val, ' ')
|
|
elseif #val==2 and isTsVector(val[1]) and isTsVector(val[2]) then
|
|
-- box - > 6 numbers
|
|
return table.concat(val[1], ' ')..' '..table.concat(val[2], ' ')
|
|
else
|
|
error('valToTs: cannot pass Lua tables to TorqueScript.', 3)
|
|
end
|
|
else
|
|
error('valToTs: could not convert value to TorqueScript: '..tostring(val), 3)
|
|
end
|
|
end
|
|
|
|
-- Type conversion from TS to Lua
|
|
local fromTsForceTypes = {
|
|
['boolean'] = function(val) return tsBool(val) end,
|
|
['object'] = function(val) return toTsObject(val) end, -- wrap because toTsObject not defined yet
|
|
['string'] = function(val) return val end,
|
|
}
|
|
local function forceValFromTs(val, typ)
|
|
local func = fromTsForceTypes[typ]
|
|
if not func then error('valFromTs: invalid force type \''..typ..'\'', 4) end
|
|
return func(val)
|
|
end
|
|
local function vectorFromTs(val)
|
|
local xS,yS,zS = val:match('^(%-?[0-9%.e]+) (%-?[0-9%.e]+) (%-?[0-9%.e]+)$')
|
|
if xS then return vector{tonumber(xS),tonumber(yS),tonumber(zS)}
|
|
else return nil end
|
|
end
|
|
local function boxFromTs(val)
|
|
local x1S,y1S,z1S,x2S,y2S,z2S = val:match(
|
|
'^(%-?[0-9%.e]+) (%-?[0-9%.e]+) (%-?[0-9%.e]+) '..
|
|
'(%-?[0-9%.e]+) (%-?[0-9%.e]+) (%-?[0-9%.e]+)$')
|
|
if x1S then return {
|
|
vector{tonumber(x1S),tonumber(y1S),tonumber(z1S)},
|
|
vector{tonumber(x2S),tonumber(y2S),tonumber(z2S)} }
|
|
else return nil end
|
|
end
|
|
local function multinumericFromTs(val)
|
|
local tsNumPat = '%-?[0-9]+%.?[0-9]*e?[0-9]*'
|
|
if val:find('^'..tsNumPat) then
|
|
local nums = {}
|
|
for _,part in ipairs(val:split(' ')) do
|
|
if part:find('^'..tsNumPat..'$') then
|
|
table.insert(nums, tonumber(part))
|
|
else
|
|
return nil
|
|
end
|
|
end
|
|
if #nums==2 or #nums==3 then
|
|
return vector(nums)
|
|
elseif #nums==6 then -- box
|
|
return {
|
|
vector{nums[1], nums[2], nums[3]},
|
|
vector{nums[4], nums[5], nums[6]} }
|
|
elseif #nums==7 then -- axis
|
|
return nil --return matrix(nums)
|
|
else
|
|
return nil
|
|
end
|
|
end
|
|
end
|
|
bl._forceType = bl._forceType or {}
|
|
-- todo: ensure name and name2 are already lowercase
|
|
local function valFromTs(val, name, name2)
|
|
if type(val)~='string' then
|
|
error('valFromTs: expected string, got '..type(val), 3) end
|
|
if name then
|
|
name = name:lower()
|
|
if bl._forceType[name] then
|
|
return forceValFromTs(val, bl._forceType[name])
|
|
end
|
|
end
|
|
if name2 then
|
|
name2 = name2:lower()
|
|
if bl._forceType[name2] then
|
|
return forceValFromTs(val, bl._forceType[name2])
|
|
end
|
|
end
|
|
-- '' -> nil
|
|
if val=='' then return nil end
|
|
-- number
|
|
local num = tonumber(val)
|
|
if num then return num end
|
|
-- vector, box, or axis->matrix
|
|
local vec = multinumericFromTs(val)
|
|
if vec then return vec end
|
|
-- string
|
|
return val
|
|
end
|
|
local function arglistFromTs(name, argsS)
|
|
local args = {}
|
|
for i,arg in ipairs(argsS) do
|
|
args[i] = valFromTs(arg, name..':'..i)
|
|
end
|
|
return args
|
|
end
|
|
local function arglistToTs(args)
|
|
return map(args, valToTs)
|
|
end
|
|
local function classFromForceTypeStr(name)
|
|
local class, rest = name:match('^([a-zA-Z0-9_]+)(::.+)$')
|
|
if not class then
|
|
class, rest = name:match('^([a-zA-Z0-9_]+)(%..+)$') end
|
|
return class,rest
|
|
end
|
|
local setForceType
|
|
setForceType = function(ftname, typ)
|
|
if typ~=nil and not fromTsForceTypes[typ] then
|
|
error('bl.type: invalid type \''..typ..'\'', 2) end
|
|
if not isValidFuncNameNsArgn(ftname) then
|
|
error('bl.type: invalid function or variable name \''..ftname..'\'', 2) end
|
|
|
|
ftname = ftname:lower()
|
|
|
|
bl._forceType[ftname] = typ
|
|
|
|
-- apply to child classes if present
|
|
local cname, rest = classFromForceTypeStr(ftname)
|
|
if cname then
|
|
local meta = bl._objectUserMetas[cname]
|
|
if meta then
|
|
for chcname,_ in pairs(meta._children) do
|
|
setForceType(chcname..rest, typ)
|
|
end
|
|
end
|
|
end
|
|
end
|
|
bl.type = setForceType
|
|
|
|
-- Type conversion TS->Lua backwards, convert back to string
|
|
local function numFromTsTostring(val)
|
|
-- todo: as-good-as-possible scientific notation for numbers
|
|
return tostring(val)
|
|
end
|
|
local function valFromTsTostring(val)
|
|
if type(val)=='string' then
|
|
return val
|
|
elseif type(val)=='number' then
|
|
return numFromTsTostring(val)
|
|
elseif type(val)=='table' then
|
|
if val.__is_vector then
|
|
local strs = {}
|
|
for i=1,#val do strs[i] = numFromTsTostring(val[i]) end
|
|
return table.concat(strs, ' ')
|
|
elseif val.__is_matrix then
|
|
-- todo: matrix back to axis-angle string
|
|
error('bl.string: matrix not yet supported', 3)
|
|
end
|
|
end
|
|
error('bl.string: cannot convert \''..type(val)..'\'', 3)
|
|
end
|
|
|
|
-- Getting info from TS about functions and objects
|
|
local function isTsObject(t)
|
|
return type(t)=='table' and t._tsObjectId~=nil
|
|
end
|
|
local function tsIsObject(name) return tsBool(_bllua_ts.call('isObject', name)) end
|
|
local function tsIsFunction(name) return tsBool(_bllua_ts.call('isFunction', name)) end
|
|
local function tsIsFunctionNs(ns, name) return tsBool(_bllua_ts.call('isFunction', ns, name)) end
|
|
local function tsIsFunctionNsname(nsname)
|
|
local ns, name = nsname:match('^([^:]+)::([^:]+)$')
|
|
if ns then return tsIsFunctionNs(ns, name)
|
|
else return tsIsFunction(nsname) end
|
|
end
|
|
-- sanity check to make sure objects that don't isObject are always marked as ._deleted
|
|
-- can be removed later
|
|
local function assertTsObjectExists(obj)
|
|
local is = tsIsObject(obj._tsObjectId)
|
|
if not is then
|
|
print('Warning: TS object :exists or isobject from lua but no longer exists') end
|
|
return is
|
|
end
|
|
function bl.isObject(obj)
|
|
if type(obj)=='number' then -- object id
|
|
return tsIsObject(tostring(obj))
|
|
elseif type(obj)=='string' then -- object name
|
|
return tsIsObject(obj)
|
|
elseif isTsObject(obj) then -- lua object
|
|
if obj._deleted then
|
|
return false
|
|
else
|
|
return assertTsObjectExists(obj)
|
|
end
|
|
else
|
|
error('bl.isObject: argument #1: expected torque object, number, or string', 2)
|
|
end
|
|
end
|
|
function bl.isFunction(name)
|
|
return tsIsFunctionNsname(name)
|
|
end
|
|
|
|
-- Torque object pseudo-class
|
|
local tsClassMeta = {
|
|
__tostring = function(t)
|
|
return 'torqueClass:'..t._name..
|
|
(t._inherit and (':'..t._inherit._name) or '')
|
|
end,
|
|
}
|
|
bl._objectUserMetas = bl._objectUserMetas or {}
|
|
function bl.class(cname, inhname)
|
|
if not ( type(cname)=='string' and isValidFuncName(cname) ) then
|
|
error('bl.class: argument #1: invalid class name', 2) end
|
|
if not ( inhname==nil or (type(inhname)=='string' and isValidFuncName(inhname)) ) then
|
|
error('bl.class: argument #2: inherit name must be a string or nil', 2) end
|
|
cname = cname:lower()
|
|
|
|
local met = bl._objectUserMetas[cname] or {
|
|
_name = cname,
|
|
_inherit = nil,
|
|
_children = {},
|
|
}
|
|
bl._objectUserMetas[cname] = met
|
|
setmetatable(met, tsClassMeta)
|
|
|
|
if inhname then
|
|
inhname = inhname:lower()
|
|
|
|
local inh = bl._objectUserMetas[inhname]
|
|
if not inh then error('bl.class: argument #2: \''..inhname..'\' is not the '..
|
|
'name of an existing class', 2) end
|
|
|
|
inh._children[cname] = true
|
|
|
|
local inhI = met._inherit
|
|
if inhI and inhI~=inh then
|
|
error('bl.class: argument #2: class already exists and '..
|
|
'inherits a different parent.', 2) end
|
|
met._inherit = inh
|
|
|
|
-- apply inherited method and field types
|
|
for ftname, typ in pairs(bl._forceType) do
|
|
local cname2, rest = classFromForceTypeStr(ftname)
|
|
if cname2==inhname then
|
|
setForceType(cname..rest, typ)
|
|
end
|
|
end
|
|
end
|
|
end
|
|
local function objectInheritedMetas(name)
|
|
local inh = bl._objectUserMetas[name:lower()]
|
|
return function()
|
|
local inhP = inh
|
|
if inhP==nil then return nil end
|
|
inh = inh._inherit
|
|
return inhP
|
|
end
|
|
end
|
|
local tsObjectMeta = {
|
|
-- __index: Called when accessing fields that don't exist in the object itself
|
|
-- Return torque member function or value
|
|
__index = function(t, name)
|
|
if rawget(t,'_deleted') then
|
|
error('ts object index: object no longer exists', 2) end
|
|
if type(name)~='string' and type(name)~='number' then
|
|
error('ts object index: index must be a string or number', 2) end
|
|
if getmetatable(t)[name] then
|
|
return getmetatable(t)[name]
|
|
elseif type(name)=='number' then
|
|
if not tsIsFunctionNs(rawget(t,'_tsNamespace'), 'getObject') then
|
|
error('ts object __index: index is number, but object does not have '..
|
|
'getObject method', 2) end
|
|
return toTsObject(_bllua_ts.callobj(t._tsObjectId, 'getObject',
|
|
tostring(name)))
|
|
else
|
|
for inh in objectInheritedMetas(rawget(t,'_tsClassName')) do
|
|
if inh[name] then return inh[name] end
|
|
end
|
|
if
|
|
tsIsFunctionNs(rawget(t,'_tsNamespace'), name) or
|
|
tsIsFunctionNs(rawget(t,'_tsName'), name)
|
|
then
|
|
return function(t2, ...)
|
|
if t2==nil or type(t2)~='table' or not t2._tsObjectId then
|
|
error('ts object method: be sure to use :func() not .func()', 2) end
|
|
local argsS = arglistToTs({...})
|
|
local res =
|
|
_bllua_ts.callobj(t2._tsObjectId, name, unpack(argsS))
|
|
return valFromTs(res,
|
|
t2._tsName and t2._tsName..'::'..name,
|
|
t2._tsNamespace..'::'..name)
|
|
end
|
|
else
|
|
local res = _bllua_ts.getfield(rawget(t,'_tsObjectId'), name)
|
|
return valFromTs(res,
|
|
rawget(t,'_tsName') and rawget(t,'_tsName')..'.'..name,
|
|
rawget(t,'_tsNamespace')..'.'..name)
|
|
end
|
|
end
|
|
end,
|
|
-- __newindex: Called when setting fields on the object
|
|
-- Set lua data
|
|
-- Use :set() to set Torque data
|
|
__newindex = function(t, name, val)
|
|
if rawget(t,'_deleted') then
|
|
error('ts object newindex: object no longer exists', 2) end
|
|
if type(name)~='string' then
|
|
error('ts object newindex: index must be a string', 2) end
|
|
rawset(t, name, val)
|
|
-- create strong reference since it's now storing lua data
|
|
bl._objectsStrong[rawget(t,'_tsObjectId')] = t
|
|
end,
|
|
-- object:set(fieldName, value)
|
|
-- Use to set torque data
|
|
set = function(t, name, val)
|
|
if t==nil or type(t)~='table' or not t._tsObjectId then
|
|
error('ts object method: be sure to use :func() not .func()', 2) end
|
|
if t._deleted then
|
|
error('ts object method: object no longer exists', 2) end
|
|
if type(name)~='string' then
|
|
error('ts object :set(): index must be a string', 2) end
|
|
_bllua_ts.setfield(t._tsObjectId, name, valToTs(val))
|
|
end,
|
|
-- __tostring: Called when printing
|
|
-- Display a nice info string
|
|
__tostring = function(t)
|
|
return 'torque:'..t._tsNamespace..':'..t._tsObjectId..
|
|
(t._tsName~='' and ('('..t._tsName..')') or '')..
|
|
(t._deleted and '(deleted)' or '')
|
|
end,
|
|
-- #object
|
|
-- If the object has a getCount method, return its count
|
|
__len = function(t)
|
|
if t._deleted then
|
|
error('ts object __len: object no longer exists', 2) end
|
|
if not tsIsFunctionNs(t._tsNamespace, 'getCount') then
|
|
error('ts object __len: object has no getCount method', 2) end
|
|
return tonumber(_bllua_ts.callobj(t._tsObjectId, 'getCount'))
|
|
end,
|
|
-- object:members()
|
|
-- Return an iterator for Torque objects with the getCount and getObject methods
|
|
-- for index, object in group:members() do ... end
|
|
members = function(t)
|
|
if t==nil then
|
|
error('ts object method: be sure to use :func() not .func()', 2) end
|
|
if t._deleted then
|
|
error('ts object method: object no longer exists', 2) end
|
|
if not (
|
|
tsIsFunctionNs(t._tsNamespace, 'getCount' ) and
|
|
tsIsFunctionNs(t._tsNamespace, 'getObject')) then
|
|
error('ts object :members() - '..
|
|
'Object does not have getCount and getObject methods', 2) end
|
|
local count = tonumber(_bllua_ts.callobj(t._tsObjectId, 'getCount'))
|
|
local idx = 0
|
|
return function()
|
|
if idx < count then
|
|
local obj = toTsObject(_bllua_ts.callobj(t._tsObjectId,
|
|
'getObject', tostring(idx)))
|
|
idx = idx+1
|
|
--return idx-1, obj
|
|
return obj
|
|
else
|
|
return nil
|
|
end
|
|
end
|
|
end,
|
|
-- Wrap some Torque functions for performance and error checking
|
|
getName = function(t)
|
|
if t==nil then
|
|
error('ts object method: be sure to use :func() not .func()', 2) end
|
|
if t._deleted then
|
|
error('ts object method: object no longer exists', 2) end
|
|
return t._tsName
|
|
end,
|
|
getId = function(t)
|
|
if t==nil then
|
|
error('ts object method: be sure to use :func() not .func()', 2) end
|
|
if t._deleted then
|
|
error('ts object method: object no longer exists', 2) end
|
|
return tonumber(t._tsObjectId)
|
|
end,
|
|
getType = function(t)
|
|
if t==nil then
|
|
error('ts object method: be sure to use :func() not .func()', 2) end
|
|
if t._deleted then
|
|
error('ts object method: object no longer exists', 2) end
|
|
return tsTypesByNum[_bllua_ts.callobj(t._tsObjectId, 'getType')]
|
|
end,
|
|
---- Schedule method for objects
|
|
--schedule = function(t, time, cb, ...)
|
|
-- if type(t)~='table' or not t._tsObjectId then
|
|
-- error('ts object method: be sure to use :func() not .func()', 2) end
|
|
-- if t._deleted then
|
|
-- error('ts object method: object no longer exists', 2) end
|
|
-- if type(time)~='number' then
|
|
-- error('ts object schedule: argument #2: time must be a number', 2) end
|
|
-- if type(cb)~='function' then
|
|
-- error('ts object schedule: argument #3: callback must be a function', 2) end
|
|
-- local args = {...}
|
|
-- bl.schedule(time, function()
|
|
-- if tsBool(__bllua_ts.call('isObject', t._tsObjectId)) then
|
|
-- pcall(cb, unpack(args))
|
|
-- end
|
|
-- end)
|
|
--end,
|
|
exists = function(t)
|
|
if t==nil then
|
|
error('ts object method: be sure to use :func() not .func()', 2) end
|
|
if t._deleted then
|
|
return false
|
|
else
|
|
return assertTsObjectExists(t)
|
|
end
|
|
end,
|
|
}
|
|
-- Weak-values table for caching Torque object references
|
|
-- Objects in this table can be garbage collected if there are no other refs to them
|
|
if not bl._objectsWeak then
|
|
bl._objectsWeak = {}
|
|
setmetatable(bl._objectsWeak, { __mode='v' })
|
|
end
|
|
-- Strong table for preserving Torque object references containing lua data
|
|
-- If an object in this table, it will remain here and in the Weak table until deleted
|
|
if not bl._objectsStrong then
|
|
bl._objectsStrong = {}
|
|
end
|
|
-- Hook object deletion to clean up its lua data
|
|
-- idS is expected to be the object ID number, NOT the object name
|
|
function _bllua_objectDeleted(idS)
|
|
local obj = bl._objectsWeak[idS]
|
|
if obj then
|
|
obj._deleted = true
|
|
bl._objectsStrong[idS] = nil
|
|
bl._objectsWeak[idS] = nil
|
|
bl._objectsWeak[obj._tsName:lower()] = nil
|
|
end
|
|
end
|
|
|
|
-- Return a Torque object for the object ID string, or create one if none exists
|
|
toTsObject = function(idiS)
|
|
if type(idiS)~='string' then
|
|
error('toTsObject: input must be a string', 2) end
|
|
idiS = idiS:lower()
|
|
if bl._objectsWeak[idiS] then return bl._objectsWeak[idiS] end
|
|
|
|
if not tsIsObject(idiS) then
|
|
--error('toTsObject: object \''..idiS..'\' does not exist', 2) end
|
|
return nil end
|
|
|
|
local className = _bllua_ts.callobj(idiS, 'getClassName')
|
|
local obj = {
|
|
_tsObjectId = _bllua_ts.callobj(idiS, 'getId' ),
|
|
_tsName = _bllua_ts.callobj(idiS, 'getName' ),
|
|
_tsNamespace = className,
|
|
_tsClassName = className:lower(),
|
|
}
|
|
setmetatable(obj, tsObjectMeta)
|
|
|
|
bl._objectsWeak[obj._tsObjectId ] = obj
|
|
bl._objectsWeak[obj._tsName:lower()] = obj
|
|
return obj
|
|
end
|
|
|
|
-- Allow bl['namespaced::function']()
|
|
local function safeNamespaceName(name)
|
|
return tostring(name:gsub(':', '_'))
|
|
end
|
|
local nscallArgStr = '%a,%b,%c,%d,%e,%f,%g,%h'
|
|
bl._cachedNamespaceCalls = {}
|
|
local function tsNamespacedCallTfname(name)
|
|
local tfname = bl._cachedNamespaceCalls[name]
|
|
if not tfname then
|
|
tfname = '_bllua_nscall_'..safeNamespaceName(name)
|
|
local tfcode = 'function '..tfname..'('..nscallArgStr..'){'..
|
|
name..'('..nscallArgStr..');}'
|
|
_bllua_ts.eval(tfcode)
|
|
bl._cachedNamespaceCalls[name] = tfname
|
|
end
|
|
return tfname
|
|
end
|
|
local function tsCallGen(name)
|
|
return function(...)
|
|
local argsS = arglistToTs({...})
|
|
local res = _bllua_ts.call(name, unpack(argsS))
|
|
return valFromTs(res, name)
|
|
end
|
|
end
|
|
|
|
-- Metatable for the global bl library
|
|
-- Allows accessing Torque objects, variables, and functions by indexing it
|
|
local tsMeta = {
|
|
-- __index: Called when accessing fields that don't exist in the table itself
|
|
-- Allow indexing by object id: bl[1234]
|
|
-- by object name: bl.mainMenuGui
|
|
-- by function name: bl.quit()
|
|
-- by variable name: bl.iAmAdmin
|
|
__index = function(t, name)
|
|
if getmetatable(t)[name] then
|
|
return getmetatable(t)[name]
|
|
elseif type(name)=='string' and bl._objectUserMetas[name:lower()] then
|
|
return bl._objectUserMetas[name:lower()]
|
|
else
|
|
if type(name)=='number' then
|
|
return toTsObject(tostring(name))
|
|
elseif name:find('::') then
|
|
local ns, rest = name:match('^([^:]+)::(.+)$')
|
|
if not ns then error('ts index: invalid name \''..name..'\'', 2) end
|
|
if not rest:find('::') and tsIsFunctionNs(ns, rest) then
|
|
return tsCallGen(tsNamespacedCallTfname(name))
|
|
else
|
|
local res = _bllua_ts.getvar(name)
|
|
return valFromTs(res, name)
|
|
end
|
|
elseif tsIsFunction(name) then
|
|
return tsCallGen(name)
|
|
elseif tsIsObject(name) then
|
|
return toTsObject(name)
|
|
else
|
|
local res = _bllua_ts.getvar(name)
|
|
return valFromTs(res, name)
|
|
end
|
|
end
|
|
end,
|
|
}
|
|
|
|
-- bl.set(name, value)
|
|
-- Used to set global variables
|
|
function bl.set(name, val)
|
|
_bllua_ts.setvar(name, valToTs(val))
|
|
end
|
|
|
|
-- Utility functions
|
|
function bl.call(func, ...)
|
|
local args = {...}
|
|
local argsS = arglistToTs(args)
|
|
return _bllua_ts.call(func, unpack(argsS))
|
|
end
|
|
function bl.eval(code)
|
|
local res = _bllua_ts.eval(code)
|
|
return valFromTs(res)
|
|
end
|
|
function bl.exec(file)
|
|
local res = _bllua_ts.call('exec', file)
|
|
return valFromTs(res)
|
|
end
|
|
function bl.array(name, ...)
|
|
local rest = {...}
|
|
return name..table.concat(rest, '_')
|
|
end
|
|
function bl.boolean(val)
|
|
return val~=nil and
|
|
val~=false and
|
|
--val~='' and
|
|
--val~='0' and
|
|
val~=0
|
|
end
|
|
function bl.object(id)
|
|
if type(id)=='table' and id._tsObjectId then
|
|
return id
|
|
elseif type(id)=='string' or type(id)=='number' then
|
|
return toTsObject(tostring(id))
|
|
else
|
|
error('bl.object: id must be a ts object, number, or string', 2)
|
|
end
|
|
end
|
|
function bl.string(val)
|
|
return valFromTsTostring(val)
|
|
end
|
|
|
|
-- Lua calling from TS
|
|
local luaLookup
|
|
luaLookup = function(tbl, name, set, val)
|
|
if name:find('%.') then
|
|
local first, rest = name:match('^([^%.:]+)%.(.+)$')
|
|
if not isValidFuncName(first) then
|
|
error('luaLookup: invalid name \''..tostring(first)..'\'', 3) end
|
|
if not tbl[first] then
|
|
if set then tbl[first] = {}
|
|
else return nil end
|
|
end
|
|
return luaLookup(tbl[first], rest, set, val)
|
|
elseif name:find(':') then
|
|
local first, rest = name:match('^([^%.:]+):(.*)$')
|
|
if rest:find('[%.:]') then
|
|
error('luacall: cannot have : or . after :', 3) end
|
|
if not isValidFuncName(first) then
|
|
error('luacall: invalid name \''..tostring(first)..'\'', 3) end
|
|
if not isValidFuncName(rest) then
|
|
error('luacall: invalid method name \''..tostring(first)..'\'', 3) end
|
|
if not tbl[first] then
|
|
error('luacall: no object named \''..rest..'\'', 3) end
|
|
if not tbl[first][rest] then
|
|
error('luacall: no method named \''..rest..'\'', 3) end
|
|
return function(...)
|
|
tbl[first][rest](tbl[first], ...)
|
|
end
|
|
else
|
|
if set then
|
|
tbl[name] = val
|
|
else
|
|
return tbl[name]
|
|
end
|
|
end
|
|
end
|
|
-- Todo: similar deep access for luaget and luaset
|
|
function _bllua_call(fname, ...)
|
|
local args = arglistFromTs(fname:lower(), {...}) -- todo: separate lua from ts func names?
|
|
local func = luaLookup(_G, fname)
|
|
if not func then
|
|
error('luacall: no global in lua named \''..fname..'\'', 2) end
|
|
local res = func(unpack(args))
|
|
return valToTs(res)
|
|
end
|
|
function _bllua_getvar(vname)
|
|
return valToTs(luaLookup(_G, vname))
|
|
end
|
|
function _bllua_setvar(vname, valS)
|
|
return valToTs(luaLookup(_G, vname, true, valFromTs(valS, vname))) -- todo: separate lua from ts var names?
|
|
end
|
|
function _bllua_eval(code) return loadstring(code)() end
|
|
function _bllua_exec(fn) return dofile(fn, 2) end
|
|
|
|
|
|
-- bl.schedule: Use TS's schedule function to schedule lua calls
|
|
-- bl.schedule(time, function, args...)
|
|
bl._scheduleTable = bl._scheduleTable or {}
|
|
bl._scheduleNextId = bl._scheduleNextId or 1
|
|
local function cancelTsSched(sched)
|
|
if not (sched and sched.handle) then
|
|
error('schedule:cancel() - invalid object', 2)
|
|
end
|
|
_bllua_ts.call('cancel', sched.handle)
|
|
bl._scheduleTable[id] = nil
|
|
end
|
|
function bl.schedule(time, cb, ...)
|
|
local id = bl._scheduleNextId
|
|
bl._scheduleNextId = bl._scheduleNextId+1
|
|
local args = {...}
|
|
local handle = tonumber(_bllua_ts.call('schedule',
|
|
time, 0, '_bllua_luacall', '_bllua_schedule_callback', id))
|
|
local sch = {
|
|
callback = cb,
|
|
args = args,
|
|
handle = handle,
|
|
cancel = cancelTsSched,
|
|
}
|
|
bl._scheduleTable[id] = sch
|
|
return sch
|
|
end
|
|
function _bllua_schedule_callback(idS)
|
|
local id = tonumber(idS) or
|
|
error('_bllua_schedule_callback: invalid id: '..tostring(idS))
|
|
local sch = bl._scheduleTable[id]
|
|
if not sch then error('_bllua_schedule_callback: no schedule with id '..id) end
|
|
bl._scheduleTable[id] = nil
|
|
sch.callback(unpack(sch.args))
|
|
end
|
|
|
|
-- serverCmd and clientCmd
|
|
bl._cmds = bl._cmds or {}
|
|
function _bllua_process_cmd(cmdS, ...)
|
|
local cmd = cmdS:lower()
|
|
local args = arglistFromTs(cmd, {...})
|
|
local func = bl._cmds[cmd]
|
|
if not func then error('_bllua_process_cmd: no cmd named \''..cmd..'\'') end
|
|
func(unpack(args)) --pcall(func, unpack(args))
|
|
end
|
|
local function addCmd(cmd, func)
|
|
if not isValidFuncName(cmd) then
|
|
error('addCmd: invalid function name \''..tostring(cmd)..'\'') end
|
|
bl._cmds[cmd] = func
|
|
local arglist = '%a,%b,%c,%d,%e,%f,%g,%h,%i,%j,%k,%l,%m,%n,%o,%p'
|
|
_bllua_ts.eval('function '..cmd..'('..arglist..'){'..
|
|
'_bllua_luacall(_bllua_process_cmd,"'..cmd..'",'..arglist..');}')
|
|
end
|
|
function bl.addServerCmd(name, func)
|
|
name = name:lower()
|
|
addCmd('servercmd'..name, func)
|
|
bl._forceType['servercmd'..name..':1'] = 'object'
|
|
end
|
|
function bl.addClientCmd(name, func)
|
|
name = name:lower()
|
|
addCmd('clientcmd'..name, func)
|
|
end
|
|
|
|
-- commandToServer and commandToClient
|
|
function bl.commandToServer(cmd, ...)
|
|
_bllua_ts.call('commandToServer',
|
|
_bllua_ts.call('addTaggedString', cmd),
|
|
unpack(arglistToTs({...})))
|
|
end
|
|
function bl.commandToClient(cmd, ...)
|
|
_bllua_ts.call('commandToClient',
|
|
_bllua_ts.call('addTaggedString', cmd),
|
|
unpack(arglistToTs({...})))
|
|
end
|
|
function bl.commandToAll(cmd, ...)
|
|
_bllua_ts.call('commandToAll',
|
|
_bllua_ts.call('addTaggedString', cmd),
|
|
unpack(arglistToTs({...})))
|
|
end
|
|
|
|
-- Hooks (using TS packages)
|
|
local function isPackageActive(pkg)
|
|
local numpkgs = tonumber(_bllua_ts.call('getNumActivePackages'))
|
|
for i = 0, numpkgs-1 do
|
|
local apkg = _bllua_ts.call('getActivePackage', tostring(i))
|
|
if apkg==pkg then return true end
|
|
end
|
|
return false
|
|
end
|
|
local function activatePackage(pkg)
|
|
if not isPackageActive(pkg) then
|
|
_bllua_ts.call('activatePackage', pkg)
|
|
end
|
|
end
|
|
local function deactivatePackage(pkg)
|
|
if isPackageActive(pkg) then
|
|
_bllua_ts.call('deactivatePackage', pkg)
|
|
end
|
|
end
|
|
local hookNargs = 8
|
|
local hookArglistLocal = '%a,%b,%c,%d,%e,%f,%g,%h'
|
|
local hookArglistGlobal = '$_bllua_hook_arg1,$_bllua_hook_arg2,$_bllua_hook_arg3,$_bllua_hook_arg4,$_bllua_hook_arg5,$_bllua_hook_arg6,$_bllua_hook_arg7,$_bllua_hook_arg8'
|
|
bl._hooks = bl._hooks or {}
|
|
function _bllua_process_hook_before(pkgS, nameS, ...)
|
|
local args = arglistFromTs(nameS, {...})
|
|
local func = bl._hooks[pkgS] and bl._hooks[pkgS][nameS] and
|
|
bl._hooks[pkgS][nameS].before
|
|
if not func then
|
|
error('_bllua_process_hook_before: no hook for '..pkgs..':'..nameS) end
|
|
_bllua_ts.setvar('_bllua_hook_abort', '0')
|
|
func(args) --pcall(func, args)
|
|
if args._return then
|
|
_bllua_ts.setvar('_bllua_hook_abort', '1')
|
|
_bllua_ts.setvar('_bllua_hook_return', valToTs(args._return))
|
|
end
|
|
for i=1,hookNargs do
|
|
_bllua_ts.setvar('_bllua_hook_arg'..i, valToTs(args[i]))
|
|
end
|
|
end
|
|
function _bllua_process_hook_after(pkgS, nameS, resultS, ...)
|
|
nameS = nameS:lower()
|
|
local args = arglistFromTs(nameS, {...})
|
|
args._return = valFromTs(resultS, nameS)
|
|
local func = bl._hooks[pkgS] and bl._hooks[pkgS][nameS] and
|
|
bl._hooks[pkgS][nameS].after
|
|
if not func then
|
|
error('_bllua_process_hook_after: no hook for '..pkgs..':'..nameS) end
|
|
func(args) --pcall(func, args)
|
|
return valToTs(args._return)
|
|
end
|
|
local function updateHook(pkg, name, hk)
|
|
local beforeCode = hk.before and
|
|
('_bllua_luacall("_bllua_process_hook_before", "'..pkg..'","'..name..
|
|
'",'..hookArglistLocal..');') or ''
|
|
local arglist = (hk.before and hookArglistGlobal or hookArglistLocal)
|
|
local parentCode =
|
|
tsIsFunctionNsname(name) and -- only call parent if it exists
|
|
(hk.before and
|
|
'if($_bllua_hook_abort)return $_bllua_hook_return; else ' or '')..
|
|
((hk.after and '%result=' or 'return ')..
|
|
'parent::'..name:match('[^:]+$')..
|
|
'('..arglist..');') or ''
|
|
local afterCode = hk.after and
|
|
('return _bllua_luacall("_bllua_process_hook_after","'..pkg..'","'..name..'",%result,'..
|
|
arglist..');') or ''
|
|
local code =
|
|
'package '..pkg..'{'..
|
|
'function '..name..'('..hookArglistLocal..'){'..
|
|
beforeCode..parentCode..afterCode..
|
|
'}'..
|
|
'};'
|
|
_bllua_ts.eval(code)
|
|
end
|
|
function bl.hook(pkg, name, time, func)
|
|
if not isValidFuncName(pkg) then
|
|
error('bl.hook: argument #1: invalid package name \''..tostring(pkg)..'\'', 2) end
|
|
if not isValidFuncNameNs(name) then
|
|
error('bl.hook: argument #2: invalid function name \''..tostring(name)..'\'', 2) end
|
|
if time~='before' and time~='after' then
|
|
error('bl.hook: argument #3: time must be \'before\' or \'after\'', 2) end
|
|
if type(func)~='function' then
|
|
error('bl.hook: argument #4: expected a function', 2) end
|
|
|
|
bl._hooks[pkg] = bl._hooks[pkg] or {}
|
|
bl._hooks[pkg][name] = bl._hooks[pkg][name] or {}
|
|
bl._hooks[pkg][name][time] = func
|
|
|
|
updateHook(pkg, name, bl._hooks[pkg][name])
|
|
activatePackage(pkg)
|
|
end
|
|
local function tableEmpty(t)
|
|
return next(t)~=nil
|
|
end
|
|
function bl.unhook(pkg, name, time)
|
|
if not isValidFuncName(pkg) then
|
|
error('bl.unhook: argument #1: invalid package name \''..tostring(pkg)..'\'', 2) end
|
|
if not isValidFuncNameNs(name) then
|
|
error('bl.unhook: argument #2: invalid function name \''..tostring(name)..'\'', 2) end
|
|
if time~='before' and time~='after' then
|
|
error('bl.unhook: argument #3: time must be \'before\' or \'after\'', 2) end
|
|
|
|
if not name then
|
|
if bl._hooks[pkg] then
|
|
for name,hk in pairs(bl._hooks[pkg]) do
|
|
updateHook(pkg, name, {})
|
|
end
|
|
bl._hooks[pkg] = nil
|
|
else
|
|
--error('bl.unhook: no hooks registered under package name \''..
|
|
-- pkg..'\'', 2)
|
|
end
|
|
deactivatePackage(pkg)
|
|
else
|
|
if bl._hooks[pkg][name] then
|
|
if not time then
|
|
bl._hooks[pkg][name] = nil
|
|
if table.empty(bl._hooks[pkg]) then
|
|
bl._hooks[pkg] = nil
|
|
deactivatePackage(pkg)
|
|
end
|
|
updateHook(pkg, name, {})
|
|
else
|
|
if time~='before' and time~='after' then
|
|
error('bl.unhook: argument #3: time must be nil, \'before\', or \'after\'', 2) end
|
|
bl._hooks[pkg][name][time] = nil
|
|
if tableEmpty(bl._hooks[pkg][name]) and tableEmpty(bl._hooks[pkg]) then
|
|
bl._hooks[pkg] = nil
|
|
deactivatePackage(pkg)
|
|
updateHook(pkg, name, {})
|
|
else
|
|
updateHook(pkg, name, bl._hooks[pkg][name])
|
|
end
|
|
end
|
|
else
|
|
--error('bl.unhook: no hooks registered for function \''..name..
|
|
-- '\' under package name \''..pkg..'\'', 2)
|
|
end
|
|
end
|
|
end
|
|
|
|
-- Container search/raycast
|
|
local function vecToTs(v)
|
|
if not isTsVector(v) then
|
|
error('vecToTs: argument is not a vector', 3) end
|
|
return table.concat(v, ' ')
|
|
end
|
|
local function maskToTs(mask)
|
|
if type(mask)=='string' then
|
|
local val = tsTypesByName[mask:lower()]
|
|
if not val then
|
|
error('maskToTs: invalid mask \''..mask..'\'', 3) end
|
|
return tostring(val)
|
|
elseif type(mask)=='table' then
|
|
local tval = 0
|
|
local seen = {}
|
|
for i,v in ipairs(mask) do
|
|
if not seen[v] then
|
|
local val = tsTypesByName[v:lower()]
|
|
if not val then
|
|
error('maskToTs: invalid mask \''..v..
|
|
'\' at index '..i..' in mask list', 3) end
|
|
tval = tval + val
|
|
seen[v] = true
|
|
end
|
|
end
|
|
return tostring(tval)
|
|
else
|
|
error('maskToTs: mask must be a string or table', 3)
|
|
end
|
|
end
|
|
local function objToTs(obj)
|
|
if type(obj)=='number' or type(obj)=='string' then
|
|
return tostring(obj)
|
|
elseif type(obj)=='table' and obj._tsObjectId then
|
|
return tostring(obj._tsObjectId)
|
|
else
|
|
error('objToTs: invalid object \''..tostring(obj)..'\'', 3)
|
|
end
|
|
end
|
|
function bl.raycast(start, stop, mask, ignores)
|
|
local startS = vecToTs(start)
|
|
local stopS = vecToTs(start)
|
|
local maskS = maskToTs(mask)
|
|
local ignoresS = {}
|
|
for _,v in ipairs(ignores) do
|
|
table.insert(ignoresS, objToTs(v))
|
|
end
|
|
|
|
local retS = _bllua_ts.call('containerRaycast', startS, stopS, maskS, unpack(ignoresS))
|
|
|
|
if retS=='0' then
|
|
return nil
|
|
else
|
|
local hitS, pxS,pyS,pzS, nxS,nyS,nzS = retS:match('^([0-9]+) '..
|
|
'(%-?[0-9%.e]+) (%-?[0-9%.e]+) (%-?[0-9%.e]+) '..
|
|
'(%-?[0-9%.e]+) (%-?[0-9%.e]+) (%-?[0-9%.e]+)$')
|
|
local hit = toTsObject(hitS)
|
|
local pos = vector{tonumber(pxS),tonumber(pyS),tonumber(pzS)}
|
|
local norm = vector{tonumber(nxS),tonumber(nyS),tonumber(nzS)}
|
|
return hit, pos, norm
|
|
end
|
|
end
|
|
local function tsContainerSearchIterator()
|
|
local retS = _bllua_ts.call('containerSearchNext')
|
|
if retS=='0' then
|
|
return nil
|
|
else
|
|
return toTsObject(retS)
|
|
end
|
|
end
|
|
function bl.boxSearch(pos, size, mask)
|
|
local posS = vecToTs(pos)
|
|
local sizeS = vecToTs(size)
|
|
local maskS = maskToTs(mask)
|
|
|
|
_bllua_ts.call('initContainerBoxSearch', posS, sizeS, maskS)
|
|
return tsContainerSearchIterator
|
|
end
|
|
function bl.radiusSearch(pos, radius, mask)
|
|
local posS = vecToTs(pos)
|
|
if type(radius)~='number' then
|
|
error('bl.radiusSearch: argument #2: radius must be a number', 2) end
|
|
local radiusS = tostring(radius)
|
|
local maskS = maskToTs(mask)
|
|
|
|
_bllua_ts.call('initContainerRadiusSearch', posS, radiusS, maskS)
|
|
return tsContainerSearchIterator
|
|
end
|
|
|
|
-- Print/Talk/Echo
|
|
local maxTsArgLen = 8192
|
|
local function valsToString(vals)
|
|
local strs = {}
|
|
for i,v in ipairs(vals) do
|
|
local tstr = table.tostring(v)
|
|
if #tstr>maxTsArgLen then
|
|
tstr = tostring(v)
|
|
end
|
|
strs[i] = tstr
|
|
end
|
|
return table.concat(strs, ' ')
|
|
end
|
|
bl.echo = function(...)
|
|
local str = valsToString({...})
|
|
_bllua_ts.call('echo', str)
|
|
end
|
|
print = bl.echo
|
|
bl.talk = function(...)
|
|
local str = valsToString({...})
|
|
_bllua_ts.call('echo', str)
|
|
_bllua_ts.call('talk', str)
|
|
end
|
|
|
|
-- bl.new and bl.datablock
|
|
local function createTsObj(keyword, class, name, inherit, props)
|
|
local propsT = {}
|
|
if props then
|
|
for k,v in pairs(props) do
|
|
if not isValidFuncName(k) then
|
|
error('bl.new/bl.datablock: invalid property name \''..k..'\'') end
|
|
table.insert(propsT, k..'="'..valToTs(v)..'";')
|
|
end
|
|
end
|
|
|
|
local objS = _bllua_ts.eval(
|
|
'return '..keyword..' '..class..'('..
|
|
(name or '')..(inherit and (':'..inherit) or '')..'){'..
|
|
table.concat(propsT)..'};')
|
|
local obj = toTsObject(objS)
|
|
if not obj then
|
|
error('bl.new/bl.datablock: failed to create object', 3) end
|
|
|
|
return obj
|
|
end
|
|
local function parseTsDecl(decl)
|
|
local class, name, inherit
|
|
if decl:find(' ') then -- class ...
|
|
local cl, rest = decl:match('^([^ ]+) ([^ ]+)$')
|
|
class = cl
|
|
if rest:find(':') then -- class name:inherit
|
|
name, inherit = rest:match('^([^:]*):([^:]+)$')
|
|
if not name then class = nil end -- error
|
|
if name=='' then name = nil end -- class :inherit
|
|
else
|
|
name = rest
|
|
end
|
|
else -- class
|
|
class = decl
|
|
end
|
|
if not (
|
|
isValidFuncName(class) and
|
|
(name==nil or isValidFuncName(name)) and
|
|
(inherit==nil or isValidFuncName(inherit)) ) then
|
|
error('bl.new/bl.datablock: invalid decl \''..decl..'\'\n'..
|
|
'must be of the format: \'className\', \'className name\', '..
|
|
'\'className :inherit\', or \'className name:inherit\'', 3) end
|
|
return class, name, inherit
|
|
end
|
|
function bl.new(decl, props)
|
|
local class, name, inherit = parseTsDecl(decl)
|
|
return createTsObj('new', class, name, inherit, props)
|
|
end
|
|
function bl.datablock(decl, props)
|
|
local class, name, inherit = parseTsDecl(decl)
|
|
if not name then error('bl.datablock: must specify a name', 2) end
|
|
return createTsObj('datablock', class, name, inherit, props)
|
|
end
|
|
|
|
setmetatable(bl, tsMeta)
|
|
|
|
print(' Executed libbl.lua')
|