red_glazed_terracotta/mods/rgt_base/init.lua

-- "I'll stop calling it Minetest when it stops being one."
minetest = core

-- Override properties of a table from those of another table
function extend(dst, src)
    for k, v in pairs(src) do
        dst[k] = v
    end
    return dst
end

-- PHP-style helper verb
function include(file)
    return dofile(minetest.get_modpath(minetest.get_current_modname()).."/"..file)
end

function include_all(dir)
    for _, x in pairs(minetest.get_dir_list(minetest.get_modpath(minetest.get_current_modname()).."/"..dir)) do
        include(dir.."/"..x)
    end
end

function warn(str)
    minetest.log("warning", str)
end

function err(str)
    minetest.log("error", str.."\n"..debug.traceback())
end

function tell(p, msg)
    minetest.chat_send_player(p, "# Server: "..msg)
end

function say(msg)
    minetest.chat_send_all("# Server: "..msg)
end

EventTarget = {
    init = function()
        local e = {
            listeners = {}
        }
        return setmetatable(e, {__index = EventTarget})
    end,
    listen = function(e, channel, fn)
        if not e.listeners[channel] then e.listeners[channel] = {} end
        local l = e.listeners[channel]
        l[#l +1] = fn
    end,
    unlisten = function(e, channel, fn)
        if not e.listeners[channel] then return end
        local l = e.listeners[channel]
        local idx = table.indexof(l, fn)
        if idx < 0 then return end
        table.remove(l, idx)
    end,
    dispatch = function(e, channel, ...)
        local l = e.listeners[channel]
        if not l then return end
        for i = 1, #l do
            l[i](...)
        end
    end
}
setmetatable(EventTarget, {
    __call = function(_, ...) return EventTarget.init(...) end
})

rgt = {
    adjacent_neighbor_offests = {
        vector.new(0,0,1),
        vector.new(0,0,-1),
        vector.new(1,0,0),
        vector.new(-1,0,0),
        vector.new(1,0,1),
        vector.new(1,0,-1),
        vector.new(-1,0,1),
        vector.new(-1,0,-1),
    },
    adjacent_horizontal_neighbor_offests = {
        vector.new(0,0,1),
        vector.new(0,0,-1),
        vector.new(1,0,0),
        vector.new(-1,0,0),
    },
    nodes_to_content_ids = {},
    content_ids_to_nodes = {}
}
local ns = rgt

function ns.register_node(name, def)
    def._name = name
    local alias
    if not name:find(":") then
        alias = name
        name = "red_glazed_terracotta:"..name
    end
    if def.groups then
        if def.groups.interactable then
            def.on_rightclick = function(pos, _, p)
                rgt.players[p:get_player_name()].interacting_with = pos
            end
        end
    end
    if def._variants then
        if type(def._variants) == "string" then
            rgt_world["register_"..def._variants](def)
        else
            for _, x in ipairs(def._variants) do
                rgt_world["register_"..x](def)
            end
        end
    end
    minetest.register_node(":"..name, def)
    local cid = minetest.get_content_id(name)
    ns.nodes_to_content_ids[name] = cid
    ns.content_ids_to_nodes[cid] = name
    if alias then
        minetest.register_alias(alias, name)
    end
end

function ns.register_item(name, def)
    def._name = name
    local alias
    if not name:find(":") then
        alias = name
        name = "red_glazed_terracotta:"..name
    end
    minetest.register_craftitem(":"..name, def)
    if alias then
        minetest.register_alias(alias, name)
    end
end

function ns.register_tool(name, def)
    def._name = name
    local alias
    if not name:find(":") then
        alias = name
        name = "red_glazed_terracotta:"..name
    end
    minetest.register_tool(":"..name, def)
    if alias then
        minetest.register_alias(alias, name)
    end
end

function ns.register_entity(name, def)
    minetest.register_entity(name, def)
end

-- Out-of-line node metadata, allowing meta for a node to be accessed even when its containing mapblock is not loaded.
local db = minetest.get_mod_storage()
local NodeMetaRef = {
    set = function(e, key, value)
        return db:set_string(e._pos.."_"..key, value)
    end,
    get = function(e, key)
        return db:get(e._pos.."_"..key)
    end,
}
NodeMetaRef.__index = NodeMetaRef

function ns.get_node_meta(pos)
    return setmetatable({_pos = tostring(minetest.hash_node_position(pos))}, NodeMetaRef)
end

-- Allow nodes to provide a callback to run on activation without
-- needing to register a bunch of mostly identical LBMs.
minetest.register_lbm {
    name = ":red_glazed_terracotta:on_activate",
    nodenames = {"group:run_on_activate"},
    action = function(pos, node)
        minetest.registered_nodes[node.name].on_activate(pos)
    end
}


minetest.register_on_joinplayer(function(p)
    if p:get_player_name() == "singleplayer" then
        minetest.change_player_privs(p:get_player_name(), {
            fast = true,
            fly = true,
            noclip = true,
            server = true,
            give = true,
        })
    end
end)