tpr

--Configuration values:
--Use these to customize this mod
timeout_delay = 30
teleport_delay = 5

--DO NOT CHANGE:

sender = nil
receiver = nil

print ("[Teleport Request] Teleport Request v0.1a Loaded.")

--Teleport Request System

local function tpr_send(name, param)

    --Register variables

        sender = name
        receiver = param
    --Check for empty parameter

        if receiver == "" then
            minetest.chat_send_player(sender, "Usage: /tpr <Player name>")
            return
        end

    --If paremeter is valid, Send teleport message and set the table.

        if minetest.env:get_player_by_name(receiver) then
            minetest.chat_send_player(receiver, sender ..' is requesting to teleport to you. /tpy to accept.')
        minetest.chat_send_player(sender, 'Teleport request sent! It will time out in '.. timeout_delay ..' seconds.')

    --Write name values to list and clear old values.
            tpr_list[receiver] = nil
            tpr_list[receiver] = sender
        --Teleport timeout delay
        minetest.after(timeout_delay, reset_request)
    end
end

--Reset after configured delay.

function reset_request(name)

    --A check to prevent crashing

    if tpr_list[receiver] ~= nil then
            tpr_list[receiver] = nil

    end

end

-- Teleport Deny System

function tpr_deny(name)

    sender = tpr_list[receiver]

    if tpr_list[receiver] ~= nil then
            tpr_list[receiver] = nil
        minetest.chat_send_player(sender, 'Teleport request denied :C')
        minetest.chat_send_player(receiver, 'Teleport request denied.')


    end

end

--Teleport Accept System

local function tpr_accept(name, param)

    --Register name variables.

    receiver = name
    sender = tpr_list[name]

    --Check to prevent constant teleporting.

    if tpr_list[name] == nil then
            minetest.chat_send_player(name, "Usage: /tpy allows you to accept teleport requests sent to you by other players")

        return
    end

    --Check to ensure name is valid, then send appropriate chat messages

    if tpr_list[name] then
        minetest.chat_send_player(tpr_list[receiver], "Request Accepted!")
        minetest.chat_send_player(receiver, sender..' is teleporting to you.')

    --Code here copied from Celeron-55's /teleport command. Thanks Celeron!

        local function find_free_position_near(pos)
            local tries = {
                {x=1,y=0,z=0},
                {x=-1,y=0,z=0},
                {x=0,y=0,z=1},
                {x=0,y=0,z=-1},
            }
            for _, d in ipairs(tries) do
                local p = {x = pos.x+d.x, y = pos.y+d.y, z = pos.z+d.z}
                local n = minetest.env:get_node(p)
                if not minetest.registered_nodes[n.name].walkable then
                    return p, true
                end
            end
            return pos, false
        end

        --Get names from variables and set position.

        local requester = minetest.env:get_player_by_name(sender)
        local accepter = minetest.env:get_player_by_name(name)
        local position = nil

        position = accepter:getpos()
        position = find_free_position_near(position)

        -- Check for a delay, if so, teleport player after specified delay, else, just teleport the player

        if teleport_delay ~= 0 then
            minetest.after(teleport_delay, teleport_player, position)
            return
        end

        if teleport_delay == 0 then

            requester:setpos(p)
            tpr_list[name] = nil

        end

        -- Set name values to nil to prevent re-teleporting on the same request.

    end
end

--This is where the problem happens

function teleport_player(param)
    requester = tpr_list[receiver]
        print(requester)
        print(param)
        requester:setpos(param)
end

--Initalize Table.

tpr_list = {}

--Initalize Permissions.

minetest.register_privilege("tpr", {
    description = "Permission to request teleport to other players.",
    give_to_singleplayer = true
})

minetest.register_privilege("tpr_admin", {
    description = "Permission to override teleport to other players. UNFINISHED",
    give_to_singleplayer = true
})

--Initalize Commands.

minetest.register_chatcommand("tpr", {
    description = "Request teleport to another player",
    params = "<playername> | leave playername empty to see help message",
    privs = {tpr=true},
    func = tpr_send

})

minetest.register_chatcommand("tpy", {
    description = "Accept teleport requests from another player",
    func = tpr_accept
})

minetest.register_chatcommand("tpn", {
    description = "Deny teleport requests from another player",
    func = tpr_deny
})