initial

src/util/libbl.lua

@@ -0,0 +1,840 @@
+-- bl library
+-- Main lua-side functionality of bllua,
+-- provided through the global table 'bl.'
+
+-- todo: set
+
+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-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
+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: could not convert table', 3)
+		end
+	else
+		error('valToTs: could not convert '..type(val), 3)
+	end
+end
+bl._forceType = bl._forceType or {}
+local function valFromTs(val, name)
+	if type(val)~='string' then
+		error('valFromTs: expected string, got '..type(val), 3) end
+	if name then
+		local nameL = name:lower()
+		if bl._forceType[nameL] then
+			local typ = bl._forceType[nameL]
+			if typ=='boolean' then
+				return tsBool(val)
+			elseif typ=='object' then
+				return toTsObject(val)
+			else
+				error('valFromTs: invalid force type '..typ, 3)
+			end
+		end
+	end
+	-- '' -> nil
+	if val=='' then return nil end
+	-- number
+	local num = tonumber(val)
+	if num then return num end
+	-- vector
+	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)} end
+	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]+)$')
+	-- box (2 vectors)
+	if x1S then return {
+		vector{tonumber(x1S),tonumber(y1S),tonumber(z1S)},
+		vector{tonumber(x2S),tonumber(y2S),tonumber(z2S)} } 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
+function bl.type(name,typ)
+	if typ~='bool' and typ~='boolean' and typ~='object' and typ~=nil then
+		error('bl.type: can only set type to \'bool\' or \'object\' or nil', 2) end
+	if not isValidFuncNameNsArgn(name) then
+		error('bl.type: invalid function or variable name \''..name..'\'', 2) end
+	if typ=='bool' then typ='boolean' end
+	bl._forceType[name:lower()] = typ
+end
+
+
+-- Value detection
+
+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
+
+function bl.isObject(obj)
+	if isTsObject(obj) then
+		obj = obj._tsObjectId
+	elseif type(obj)=='number' then
+		obj = tostring(obj)
+	elseif type(obj)~='string' then
+		error('bl.isObject: argument #1: expected torque object, number, or string', 2)
+	end
+	return tsIsObject(obj)
+end
+function bl.isFunction(a1, a2)
+	if type(a1)~='string' then
+		error('bl.isFunction: argument #1: expected string', 2) end
+	if a2 then
+		if type(a2)~='string' then
+			error('bl.isFunction: argument #2: expected string', 2) end
+		return tsIsFunctionNs(a1, a2)
+	else
+		return tsIsFunction(a1)
+	end
+end
+
+-- Torque object pseudo-class
+bl._objectUserMetas = bl._objectUserMetas or {}
+function bl.class(name, inherit)
+	if not ( type(name)=='string' and isValidFuncName(name) ) then
+		error('bl.class: argument #1: invalid class name', 2) end
+	if not ( inherit==nil or (type(inherit)=='string' and isValidFuncName(inherit)) ) then
+		error('bl.class: argument #2: inherit name must be a string or nil', 2) end
+	name = name:lower()
+	
+	local met = bl._objectUserMetas[name] or {}
+	bl._objectUserMetas[name] = met
+	met._name = name
+	
+	if inherit then
+		inherit = inherit:lower()
+		
+		local inh = bl._objectUserMetas[inherit]
+		if not inh then error('bl.class: argument #2: \''..inherit..'\' is not the '..
+			'name of an existing class', 2) end
+		
+		local inhI = bl._objectUserMetas[name]._inherit
+		if inhI and inhI~=inh then
+			error('bl.class: argument #2: class already exists and '..
+				'inherits a different parent.', 2) end
+		
+		bl._objectUserMetas[name]._inherit = inh
+	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) then
+				return function(t, ...)
+					local args = {...}
+					local argsS = arglistToTs(args)
+					return valFromTs(_bllua_ts.callobj(rawget(t,'_tsObjectId'), name, unpack(argsS)),
+						rawget(t,'_tsNamespace')..'::'..name)
+				end
+			else
+				return valFromTs(_bllua_ts.getfield(rawget(t,'_tsObjectId'), 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 '')
+	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:iterate()
+	-- Return an iterator for Torque objects with the getCount and getObject methods
+	-- for index, object in group:iterate() do ... end
+	iterate = 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 :iterate() - '..
+				'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
+			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 end
+		return tsIsObject(t._tsObjectId)
+	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 tsBool(_bllua_ts.call('isObject', 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
+
+-- 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 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 tsIsFunction(ns, rest) then
+					error('ts index: can\'t call a namespaced function from lua', 2)
+				else
+					return valFromTs(_bllua_ts.getvar(name), name)
+				end
+			elseif tsIsFunction(name) then
+				return function(...)
+					local args = {...}
+					local argsS = arglistToTs(args)
+					return valFromTs(_bllua_ts.call(name, unpack(argsS)), name)
+				end
+			elseif tsIsObject(name) then
+				return toTsObject(name)
+			else
+				return valFromTs(_bllua_ts.getvar(name), name)
+			end
+		end
+	end,
+}
+
+-- bl.set(name, value)
+-- Used to set global variables
+function bl.set(t, name, val)
+	_bllua_ts.call('_bllua_set_var', 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)
+	return valFromTs(_bllua_ts.call('eval', code))
+end
+function bl.exec(file)
+	return valFromTs(_bllua_ts.call('exec', file))
+end
+function bl.tobool(val)
+	return val~=nil and
+		val~=false and
+		--val~='' and
+		--val~='0' and
+		val~=0
+end
+function bl.toobject(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.toobject: id must be a ts object, number, or string', 2)
+	end
+end
+function bl.array(name, ...)
+	local rest = {...}
+	return name..table.concat(rest, '_')
+end
+function _bllua_call(name, ...)
+	-- todo: call ts->lua using this instead of directly
+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, '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(id)
+	id = tonumber(id)
+	local sch = bl._scheduleTable[id]
+	if not sch then error('_ts_schedule_callback: no schedule with id '..id) end
+	bl._scheduleTable[sched_id] = nil
+	sch.callback(unpack(sch.args))
+end
+
+-- serverCmd and clientCmd
+-- bl.serverCmd('suicide', function(client) client.player:kill() end)
+bl._cmds = bl._cmds or {}
+function _bllua_process_cmd(cmdS, clientS, ...)
+	local client = toTsObject(clientS)
+	local argsS = {...}
+	local args = arglistFromTs(cmdS, argsS)
+	local func = bl._cmds[cmdS]
+	if not func then error('_bllua_process_cmd: no cmd named \''..cmd..'\'') end
+	pcall(func, client, unpack(args))
+end
+local function addCmd(cmd, func)
+	if not isValidFuncName(cmd) then
+		error('addCmd: invalid function name \''..tostring(cmd)..'\'') end
+	bl._servercmds[cmd] = func
+	local arglist = '%a,%b,%c,%d,%e,%f,%g,%h'
+	_bllua_ts.eval('function '..cmd..'(%cl,'..arglist..'){'..
+		'luacall(_bllua_process_cmd,"'..cmd..'",%cl,'..arglist..');}')
+end
+function bl.serverCmd(name, func) addCmd('serverCmd'..name, func) end
+function bl.clientCmd(name, func) addCmd('clientCmd'..name, func) 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
+bl._hooks = bl._hooks or {}
+function _bllua_process_hook(pkgS, nameS, timeS, ...)
+	local argsS = {...}
+	local args = arglistFromTs(nameS, argsS)
+	
+	local func = bl._hooks[pkgS] and bl._hooks[pkgS][nameS] and
+		bl._hooks[pkgS][nameS][timeS]
+	if not func then
+		error('_bllua_process_hook: no hook for '..pkgS..':'..nameS..':'..timeS) end
+	
+	pcall(func, args)
+end
+local function updateHook(pkg, name, hk)
+	local arglist = '%a,%b,%c,%d,%e,%f,%g,%h'
+	local beforeCode = hk.before and
+		('luacall("_bllua_process_hook", "'..pkg..'", "'..name..
+			'", "before", '..arglist..');') or ''
+	local parentCode = hk.override and
+		('luacall("_bllua_process_hook", "'..pkg..'", "'..name..
+			'", "override", '..arglist..');') or
+		(tsIsFunctionNsname(name) and
+			('parent::'..name:match('[^:]+$')..'('..arglist..');') or '')
+	local afterCode = hk.after and
+		('luacall("_bllua_process_hook", "'..pkg..'", "'..name..
+			'", "after", '..arglist..');') or ''
+	bl.eval('package '..pkg..'{function '..name..'('..arglist..'){'..
+		beforeCode..parentCode..afterCode..'}};')
+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' and time~='override' then
+		error('bl.hook: argument #3: time must be one of '..
+			'\'before\' \'after\' \'override\'', 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
+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' and time~='override' then
+		error('bl.unhook: argument #3: time must be one of '..
+			'\'before\' \'after\' \'override\'', 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.isempty(bl._hooks[pkg]) then
+					bl._hooks[pkg] = nil
+					deactivatePackage(pkg)
+				end
+				updateHook(pkg, name, {})
+			else
+				if time~='before' and time~='after' and time~='override' then
+					error('bl.unhook: argument #3: time must be nil or one of '..
+						'\'before\' \'after\' \'override\'', 2) end
+				bl._hooks[pkg][name][time] = nil
+				if table.isempty(bl._hooks[pkg][name]) and table.empty(bl._hooks[pkg]) then
+					bl._hooks[pkg] = nil
+					deactivatePackage(pkg)
+				end
+				updateHook(pkg, name, bl._hooks[pkg][name])
+			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 function valsToString(vals)
+	local strs = {}
+	for i,v in ipairs(vals) do
+		strs[i] = table.tostring(v)
+	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
+
+local function createTsObj(keyword, class, name, inherit, props)
+	local propsT = {}
+	for k,v in pairs(props) do
+		if not isValidFuncName(k) then
+			error('bl.new/datablock: invalid property name \''..k..'\'') end
+		table.insert(propsT, k..'="'..valToTs(v)..'";')
+	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/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/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)
+	return createTsObj('datablock', class, name, inherit, props)
+end
+
+setmetatable(bl, tsMeta)
+
+print('  Executed libbl.lua')