510 lines
16 KiB
Lua
510 lines
16 KiB
Lua
--------------------------------------------------------
|
|
-- Minetest :: ActiveFormspecs Mod v2.6 (formspecs)
|
|
--
|
|
-- See README.txt for licensing and release notes.
|
|
-- Copyright (c) 2016-2019, Leslie Ellen Krause
|
|
--
|
|
-- ./games/just_test_tribute/mods/formspecs/init.lua
|
|
--------------------------------------------------------
|
|
|
|
print( "Loading ActiveFormspecs Mod" )
|
|
|
|
minetest.FORMSPEC_SIGEXIT = "true" -- player clicked exit button or pressed esc key (boolean for backward compatibility)
|
|
minetest.FORMSPEC_SIGQUIT = 1 -- player logged off
|
|
minetest.FORMSPEC_SIGKILL = 2 -- player was killed
|
|
minetest.FORMSPEC_SIGTERM = 3 -- server is shutting down
|
|
minetest.FORMSPEC_SIGPROC = 4 -- procedural closure
|
|
minetest.FORMSPEC_SIGTIME = 5 -- timeout reached
|
|
minetest.FORMSPEC_SIGSTOP = 6 -- procedural closure (cannot be trapped)
|
|
minetest.FORMSPEC_SIGHOLD = 7 -- child form opened, parent is suspended
|
|
minetest.FORMSPEC_SIGCONT = 8 -- child form closed, parent can continue
|
|
|
|
local afs = { } -- obtain localized, protected namespace
|
|
|
|
afs.forms = { }
|
|
afs.timers = { }
|
|
afs.session_id = 0
|
|
afs.session_seed = math.random( 0, 65535 )
|
|
|
|
afs.stats = { active = 0, opened = 0, closed = 0 }
|
|
|
|
afs.stats.on_open = function ( self )
|
|
self.active = self.active + 1
|
|
self.opened = self.opened + 1
|
|
end
|
|
|
|
afs.stats.on_close = function ( self )
|
|
self.active = self.active - 1
|
|
self.closed = self.closed + 1
|
|
end
|
|
|
|
-----------------------------------------------------------------
|
|
-- trigger callbacks at set intervals within timer queue
|
|
-----------------------------------------------------------------
|
|
|
|
do
|
|
-- localize needed object references for efficiency
|
|
local get_us_time = minetest.get_us_time
|
|
local timers = afs.timers
|
|
local t_cur = get_us_time( )
|
|
local t_off = -t_cur
|
|
|
|
-- step monotonic clock with graceful 32-bit overflow
|
|
local step_clock = function( )
|
|
local t_new = get_us_time( )
|
|
|
|
if t_new < t_cur then
|
|
t_off = t_off + 4294967290
|
|
end
|
|
|
|
t_cur = t_new
|
|
return t_off + t_new
|
|
end
|
|
afs.get_uptime = function( )
|
|
return ( t_off + t_cur ) / 1000000
|
|
end
|
|
|
|
minetest.register_globalstep( function( dtime )
|
|
--local x = get_us_time( )
|
|
local curtime = step_clock( ) / 1000000
|
|
local idx = #timers
|
|
|
|
-- iterate through table in reverse order to allow removal
|
|
while idx > 0 do
|
|
local self = timers[ idx ]
|
|
|
|
if curtime >= self.exptime then
|
|
self.counter = self.counter + 1
|
|
self.overrun = curtime - self.exptime
|
|
self.exptime = curtime + self.form.timeout
|
|
|
|
self.form.newtime = math.floor( curtime )
|
|
self.form.on_close( self.form.meta, self.form.player, { quit = minetest.FORMSPEC_SIGTIME } )
|
|
|
|
self.overrun = 0.0
|
|
end
|
|
idx = idx - 1
|
|
end
|
|
end )
|
|
end
|
|
|
|
-----------------------------------------------------------------
|
|
-- override node registrations for attached formspecs
|
|
-----------------------------------------------------------------
|
|
|
|
local on_rightclick = function( pos, node, player )
|
|
local nodedef = minetest.registered_nodes[ node.name ]
|
|
local meta = nodedef.before_open and nodedef.before_open( pos, node, player ) or pos
|
|
local formspec = nodedef.on_open( meta, player )
|
|
|
|
if formspec then
|
|
local player_name = player:get_player_name( )
|
|
minetest.create_form( meta, player_name, formspec, nodedef.on_close )
|
|
afs.forms[ player_name ].origin = node.name
|
|
end
|
|
end
|
|
|
|
local old_register_node = minetest.register_node
|
|
local old_override_item = minetest.override_item
|
|
|
|
minetest.register_node = function ( name, def )
|
|
if def.on_open and not def.on_rightclick then
|
|
def.on_rightclick = on_rightclick
|
|
end
|
|
old_register_node( name, def )
|
|
end
|
|
|
|
minetest.override_item = function ( name, def )
|
|
if minetest.registered_nodes[ name ] and def.on_open then
|
|
def.on_rightclick = on_rightclick
|
|
end
|
|
old_override_item( name, def )
|
|
end
|
|
|
|
-----------------------------------------------------------------
|
|
-- trigger callbacks during formspec events
|
|
-----------------------------------------------------------------
|
|
|
|
minetest.register_on_player_receive_fields( function( player, formname, fields )
|
|
local player_name = player:get_player_name( )
|
|
local form = afs.forms[ player_name ]
|
|
|
|
-- perform a basic sanity check, since these shouldn't technically occur
|
|
if not form or player ~= form.player or formname ~= form.name then return end
|
|
|
|
-- handle reverse-lookups of dropdown indexes
|
|
for name, keys in pairs( form.dropdowns ) do
|
|
if fields[ name ] then
|
|
fields[ name ] = keys[ fields[ name ] ]
|
|
end
|
|
end
|
|
|
|
form.newtime = os.time( )
|
|
form.on_close( form.meta, form.player, fields )
|
|
|
|
-- end current session when closing formspec
|
|
if fields.quit then
|
|
minetest.get_form_timer( player_name ).stop( )
|
|
|
|
afs.stats:on_close( )
|
|
if form.parent_form then
|
|
-- restore previous session
|
|
form = form.parent_form
|
|
afs.forms[ player_name ] = form
|
|
|
|
-- delay a single tick to ensure formspec updates are handled by client
|
|
minetest.after( 0.0, function ( )
|
|
form.on_close( form.meta, form.player, { quit = minetest.FORMSPEC_SIGCONT } )
|
|
end )
|
|
else
|
|
afs.forms[ player_name ] = nil
|
|
end
|
|
end
|
|
end )
|
|
|
|
-----------------------------------------------------------------
|
|
-- expose timer functionality within a helper object
|
|
-----------------------------------------------------------------
|
|
|
|
minetest.get_form_timer = function ( player_name, form_name )
|
|
local self = { }
|
|
local form = afs.forms[ player_name ]
|
|
|
|
if not form or form_name and form_name ~= form.name then return end
|
|
|
|
self.start = function ( timeout )
|
|
if not form.timeout and timeout >= 0.5 then
|
|
local curtime = afs.get_uptime( )
|
|
|
|
form.timeout = timeout
|
|
table.insert( afs.timers, { form = form, counter = 0, oldtime = curtime, exptime = curtime + timeout, overrun = 0.0 } )
|
|
end
|
|
end
|
|
self.stop = function ( )
|
|
if not form.timeout then return end
|
|
|
|
form.timeout = nil
|
|
|
|
for i, v in ipairs( afs.timers ) do
|
|
if v.form == form then
|
|
table.remove( afs.timers, i )
|
|
return
|
|
end
|
|
end
|
|
end
|
|
self.get_state = function ( )
|
|
if not form.timeout then return end
|
|
|
|
for i, v in ipairs( afs.timers ) do
|
|
local curtime = afs.get_uptime( )
|
|
|
|
if v.form == form then
|
|
return { elapsed = curtime - v.oldtime, remain = v.exptime - curtime, overrun = v.overrun, counter = v.counter }
|
|
end
|
|
end
|
|
end
|
|
|
|
return self
|
|
end
|
|
|
|
-----------------------------------------------------------------
|
|
-- parse specialized formspec elements and escapes codes
|
|
-----------------------------------------------------------------
|
|
|
|
local _
|
|
local function is_match( str, pat )
|
|
-- use array for captures
|
|
_ = { string.match( str, pat ) }
|
|
return #_ > 0 and _ or nil
|
|
end
|
|
|
|
local function escape( str )
|
|
return string.gsub( str, "\\.",
|
|
{ ["\\]"] = "\\x5D", ["\\["] = "\\x5B", ["\\,"] = "\\x2C", ["\\;"] = "\\x3B" } )
|
|
end
|
|
|
|
local function unescape( str, is_raw )
|
|
return string.gsub( str, "\\x..",
|
|
{ ["\\x5D"] = "\\]", ["\\x5B"] = "\\[", ["\\x2C"] = "\\,", ["\\x3B"] = "\\;" } )
|
|
end
|
|
|
|
local function unescape_raw( str, is_raw )
|
|
return string.gsub( str, "\\x..",
|
|
{ ["\\x5D"] = "]", ["\\x5B"] = "[", ["\\x2C"] = ",", ["\\x3B"] = ";" } )
|
|
end
|
|
|
|
local function parse_elements( form, formspec )
|
|
formspec = escape( formspec )
|
|
form.dropdowns = { } -- reset the dropdown lookup
|
|
|
|
-- dropdown elements can optionally return the selected
|
|
-- index rather than the value of the option itself
|
|
formspec = string.gsub( formspec, "dropdown%[(.-)%]", function( params )
|
|
if is_match( params, "^([^;]*;[^;]*;([^;]*);([^;]*);[^;]*);([^;]*)$" ) then
|
|
local prefix = _[ 1 ]
|
|
local name = _[ 2 ]
|
|
local options = _[ 3 ]
|
|
local use_index = _[ 4 ]
|
|
|
|
if use_index == "true" then
|
|
form.dropdowns[ name ] = { }
|
|
for idx, val in ipairs( string.split( options, ",", true ) ) do
|
|
form.dropdowns[ name ][ unescape_raw( val ) ] = idx -- add to reverse lookup table
|
|
end
|
|
return string.format( "dropdown[%s]", prefix )
|
|
elseif use_index == "false" or use_index == "" then
|
|
return string.format( "dropdown[%s]", prefix )
|
|
else
|
|
return "" -- strip invalid dropdown elements
|
|
end
|
|
end
|
|
return string.format( "dropdown[%s]", params )
|
|
end )
|
|
|
|
-- hidden elements only provide default, initial values
|
|
-- for state table and are always stripped afterward
|
|
formspec = string.gsub( formspec, "hidden%[(.-)%]", function( params )
|
|
if is_match( params, "^([^;]*);([^;]*)$" ) or is_match( params, "^([^;]*);([^;]*);([^;]*)$" ) then
|
|
local key = _[ 1 ]
|
|
local value = _[ 2 ]
|
|
local type = _[ 3 ]
|
|
|
|
if key ~= "" and form.meta[ key ] == nil then
|
|
-- parse according to specified data type
|
|
if type == "string" or type == "" or type == nil then
|
|
form.meta[ key ] = unescape_raw( value )
|
|
elseif type == "number" then
|
|
form.meta[ key ] = tonumber( value )
|
|
elseif type == "boolean" then
|
|
form.meta[ key ] = ( { ["1"] = true, ["0"] = false, ["true"] = true, ["false"] = false } )[ value ]
|
|
end
|
|
end
|
|
end
|
|
return "" -- strip hidden elements prior to showing formspec
|
|
end )
|
|
|
|
return unescape( formspec )
|
|
end
|
|
|
|
-----------------------------------------------------------------
|
|
-- open detached formspec with session-based state table
|
|
-----------------------------------------------------------------
|
|
|
|
minetest.create_form = function ( meta, player_name, formspec, on_close, signal )
|
|
-- short circuit whenever required params are missing
|
|
if not player_name or not formspec then return end
|
|
|
|
if type( player_name ) ~= "string" then
|
|
player_name = player_name:get_player_name( )
|
|
end
|
|
|
|
local form = afs.forms[ player_name ]
|
|
|
|
-- trigger previous callback before formspec closure
|
|
if form then
|
|
minetest.get_form_timer( player_name, form.name ).stop( )
|
|
if signal ~= minetest.FORMSPEC_SIGSTOP then
|
|
form.on_close( form.meta, form.player, { quit = signal or minetest.FORMSPEC_SIGPROC } )
|
|
end
|
|
if signal ~= minetest.FORMSPEC_SIGHOLD then
|
|
form = nil
|
|
afs.stats:on_close( )
|
|
end
|
|
end
|
|
|
|
-- start new session when opening formspec
|
|
afs.session_id = afs.session_id + 1
|
|
|
|
form = { parent_form = form }
|
|
form.id = afs.session_id
|
|
form.name = minetest.get_password_hash( player_name, afs.session_seed + afs.session_id )
|
|
form.player = minetest.get_player_by_name( player_name )
|
|
form.origin = string.match( debug.getinfo( 2 ).source, "^@.*[/\\]mods[/\\](.-)[/\\]" ) or "?"
|
|
form.on_close = on_close or function ( ) end
|
|
form.meta = meta or { }
|
|
form.oldtime = math.floor( afs.get_uptime( ) )
|
|
form.newtime = form.oldtime
|
|
|
|
afs.forms[ player_name ] = form
|
|
afs.stats:on_open( )
|
|
minetest.show_formspec( player_name, form.name, parse_elements( form, formspec ) )
|
|
|
|
return form.name
|
|
end
|
|
|
|
minetest.update_form = function ( player, formspec )
|
|
local pname = type( player ) == "string" and player or player:get_player_name( )
|
|
local form = afs.forms[ pname ]
|
|
|
|
if form then
|
|
form.oldtime = math.floor( afs.get_uptime( ) )
|
|
minetest.show_formspec( pname, form.name, parse_elements( form, formspec ) )
|
|
end
|
|
end
|
|
|
|
minetest.destroy_form = function ( player, signal )
|
|
local pname = type( player ) == "string" and player or player:get_player_name( )
|
|
local form = afs.forms[ pname ]
|
|
|
|
if form then
|
|
minetest.close_formspec( pname, form.name )
|
|
minetest.get_form_timer( pname ):stop( )
|
|
|
|
if signal ~= minetest.FORMSPEC_SIGSTOP then
|
|
form.on_close( form.meta, form.player, { quit = signal or minetest.FORMSPEC_SIGPROC } )
|
|
end
|
|
|
|
afs.stats:on_close( )
|
|
afs.forms[ pname ] = nil
|
|
end
|
|
end
|
|
|
|
-----------------------------------------------------------------
|
|
-- trigger callbacks after unexpected formspec closure
|
|
-----------------------------------------------------------------
|
|
|
|
minetest.register_on_leaveplayer( function( player, is_timeout )
|
|
local pname = player:get_player_name( )
|
|
local form = afs.forms[ pname ]
|
|
|
|
if form then
|
|
minetest.get_form_timer( pname, form.name ).stop( )
|
|
|
|
form.newtime = os.time( )
|
|
form.on_close( form.meta, form.player, { quit = minetest.FORMSPEC_SIGQUIT } )
|
|
|
|
afs.stats:on_close( )
|
|
afs.forms[ pname ] = nil
|
|
end
|
|
end )
|
|
|
|
minetest.register_on_dieplayer( function( player )
|
|
local pname = player:get_player_name( )
|
|
local form = afs.forms[ pname ]
|
|
|
|
if form then
|
|
minetest.get_form_timer( pname, form.name ).stop( )
|
|
|
|
form.newtime = os.time( )
|
|
form.on_close( form.meta, form.player, { quit = minetest.FORMSPEC_SIGKILL } )
|
|
|
|
afs.stats:on_close( )
|
|
afs.forms[ pname ] = nil
|
|
end
|
|
end )
|
|
|
|
minetest.register_on_shutdown( function( )
|
|
for _, form in pairs( afs.forms ) do
|
|
minetest.get_form_timer( form.player:get_player_name( ), form.name ).stop( )
|
|
|
|
form.newtime = os.time( )
|
|
form.on_close( form.meta, form.player, { quit = minetest.FORMSPEC_SIGTERM } )
|
|
|
|
afs.stats:on_close( )
|
|
end
|
|
afs.forms = { }
|
|
end )
|
|
|
|
-----------------------------------------------------------------
|
|
-- display realtime information about form sessions
|
|
-----------------------------------------------------------------
|
|
|
|
minetest.register_chatcommand( "fs", {
|
|
description = "Display realtime information about form sessions",
|
|
privs = { server = true },
|
|
func = function( pname, param )
|
|
local page_idx = 1
|
|
local page_size = 10
|
|
local sorted_forms
|
|
|
|
local get_sorted_forms = function( )
|
|
local f = { }
|
|
for k, v in pairs( afs.forms ) do
|
|
table.insert( f, v )
|
|
end
|
|
table.sort( f, function( a, b ) return a.id < b.id end )
|
|
return f
|
|
end
|
|
local get_formspec = function( )
|
|
local uptime = math.floor( afs.get_uptime( ) )
|
|
|
|
local formspec = "size[9.5,7.5]"
|
|
.. default.gui_bg
|
|
.. default.gui_bg_img
|
|
|
|
.. "label[0.1,6.7;ActiveFormspecs v2.6"
|
|
.. string.format( "label[0.1,0.0;%s]label[0.1,0.5;%d min %02d sec]",
|
|
minetest.colorize( "#888888", "uptime:" ), math.floor( uptime / 60 ), uptime % 60 )
|
|
.. string.format( "label[5.6,0.0;%s]label[5.6,0.5;%d]",
|
|
minetest.colorize( "#888888", "active" ), afs.stats.active )
|
|
.. string.format( "label[6.9,0.0;%s]label[6.9,0.5;%d]",
|
|
minetest.colorize( "#888888", "opened" ), afs.stats.opened )
|
|
.. string.format( "label[8.2,0.0;%s]label[8.2,0.5;%d]",
|
|
minetest.colorize( "#888888", "closed" ), afs.stats.closed )
|
|
|
|
.. string.format( "label[0.5,1.5;%s]label[3.5,1.5;%s]label[6.9,1.5;%s]label[8.2,1.5;%s]",
|
|
minetest.colorize( "#888888", "player" ),
|
|
minetest.colorize( "#888888", "origin" ),
|
|
minetest.colorize( "#888888", "idletime" ),
|
|
minetest.colorize( "#888888", "lifetime" )
|
|
)
|
|
|
|
.. "box[0,1.2;9.2,0.1;#111111]"
|
|
.. "box[0,6.2;9.2,0.1;#111111]"
|
|
|
|
local num = 0
|
|
for idx = ( page_idx - 1 ) * page_size + 1, math.min( page_idx * page_size, #sorted_forms ) do
|
|
local form = sorted_forms[ idx ]
|
|
|
|
local player_name = form.player:get_player_name( )
|
|
local lifetime = uptime - form.oldtime
|
|
local idletime = uptime - form.newtime
|
|
|
|
local vert = 2.0 + num * 0.5
|
|
|
|
formspec = formspec
|
|
.. string.format( "button[0.1,%0.1f;0.5,0.3;del:%s;x]", vert + 0.1, player_name )
|
|
.. string.format( "label[0.5,%0.1f;%s]", vert, player_name )
|
|
.. string.format( "label[3.5,%0.1f;%s]", vert, form.origin )
|
|
.. string.format( "label[6.9,%0.1f;%dm %02ds]", vert, math.floor( idletime / 60 ), idletime % 60 )
|
|
.. string.format( "label[8.2,%0.1f;%dm %02ds]", vert, math.floor( lifetime / 60 ), lifetime % 60 )
|
|
num = num + 1
|
|
end
|
|
|
|
formspec = formspec
|
|
.. "button[6.4,6.5;1,1;prev;<<]"
|
|
.. string.format( "label[7.4,6.7;%d of %d]", page_idx, math.max( 1, math.ceil( #sorted_forms / page_size ) ) )
|
|
.. "button[8.4,6.5;1,1;next;>>]"
|
|
|
|
return formspec
|
|
end
|
|
local on_close = function( meta, player, fields )
|
|
if fields.quit == minetest.FORMSPEC_SIGTIME then
|
|
sorted_forms = get_sorted_forms( )
|
|
minetest.update_form( pname, get_formspec( ) )
|
|
|
|
elseif fields.prev and page_idx > 1 then
|
|
page_idx = page_idx - 1
|
|
minetest.update_form( pname, get_formspec( ) )
|
|
|
|
elseif fields.next and page_idx < #sorted_forms / page_size then
|
|
page_idx = page_idx + 1
|
|
minetest.update_form( pname, get_formspec( ) )
|
|
|
|
else
|
|
local player_name = string.match( next( fields, nil ), "del:(.+)" )
|
|
if player_name and afs.forms[ player_name ] then
|
|
minetest.destroy_form( player_name )
|
|
end
|
|
end
|
|
end
|
|
|
|
sorted_forms = get_sorted_forms( )
|
|
|
|
minetest.create_form( nil, pname, get_formspec( ), on_close )
|
|
minetest.get_form_timer( pname ).start( 1 )
|
|
|
|
return true
|
|
end,
|
|
} )
|