targeted_input.txt

--@name Targeted Input
--@author legokidlogan
--@shared
--@include lkl/fancy_input.txt

targetedInput = targetedInput or {}

if targetedInput._alreadyLoaded then return end
targetedInput._alreadyLoaded = true

require( "lkl/fancy_input.txt" )


--[[
    - A library which builds off of fancy_input and networks button presses from client to server.
    - You must specify which players and buttons to target, for the sake of network efficiency.
    - This does NOT network back to other clients, only to the server.
    - See fancy_input for relevant hooks and utility functions.


    - Example setup:
        --@shared
        --@include lkl/targeted_input.txt

        require( "lkl/targeted_input.txt" )

        if SERVER then
            local buttonFuncs = {
                [KEY.F] = function( ply, key, state )
                    local stateStr = state and "pressed" or "released"

                    print( "F was " .. stateStr .. " by " .. ply:getName() )
                end,
                [KEY.G] = function( ply, key, state )
                    local stateStr = state and "pressed" or "released"

                    print( "G was " .. stateStr .. " by " .. ply:getName() )
                end,
            }


            targetedInput.setTargets( owner() ) -- Target the chip owner
            targetedInput.setTargetButtons( table.getKeys( buttonFuncs ) ) -- Target only the desired buttons, reducing network traffic

            local function keyClk( ply, key, state )
                ( buttonFuncs[key] or function() end )( ply, key, state )
            end

            hook.add( "LKL_FancyInput_InputClk", "MYPROJECT_KeyClk", keyClk )
        else
            -- Client listener
            hook.add( "LKL_FancyInput_InputClk", "MYPROJECT_KeyClk", function( _, key, state )
                local stateStr = state and "pressed" or "released"

                print( "You " .. stateStr .. " button " .. key )
            end )
        end
--]]


local targets = {}
local targetButtons = {}
local targetAllButtons = false

local curtime = timer.curtime


if SERVER then
    local tableIsEmpty = table.isEmpty
    local tableRemove = table.remove
    local timeoutDelay = 4 -- How long to wait before considering a message timed out and needs to be re-sent. Typically only happens during chip startup.
    local incompleteResponses = {}

    local getHumans
    local awaitResponseRetry
    local awaitResponse


    --[[
        - Sets the players to get input updates from.
        - Cannot target bots.

        plys:
            - { plyOne, plyTwo, plyThree, ... } -> Sets these players as the new targets to get button presses from.
                - Either numerically indexed, or a lookup table (i.e. { [1] = plyOne, [2] = plyTwo, ... }  or  { [plyOne] = tue, [plyTwo] = true, ... })
            - {} / false -> Do not target any players.
            - ply -> Target one specific player. Same as { ply }
            - nil -> Target ALL players.
    --]]
    function targetedInput.setTargets( plys )
        if plys == nil then
            plys = getHumans()
        end

        if not plys then
            plys = {}
        end

        local plysType = type( plys )

        if plysType == "Player" and isValid( plys ) then
            plys = {
                plys,
            }
        elseif plysType ~= "table" then
            return -- Invalid input (was a number, string, invalid ent, etc)
        end

        local oldTargets = targets
        targets = {}
        plys = getHumans( plys )

        if tableIsEmpty( plys ) then
            for _, ply in ipairs( find.allPlayers() ) do
                fancyInput.setButtonStates( ply, {} )
            end

            awaitResponse( "SetTargets" )
            net.start( "LKL_TargetedInput_SetTargets" )
            net.writeTable( targets )
            net.send()

            return
        end

        local plyCount = #plys

        if plyCount == 0 then
            -- This better be a lookup table!

            for ply in pairs( plys ) do -- deep-clone the table to ensure ply validity and unlink memory addresses
                if isValid( ply ) and ply:isPlayer() then
                    targets[ply] = true
                end
            end
        else
            for i = 1, plyCount do
                local ply = plys[i]

                if isValid( ply ) and ply:isPlayer() then
                    targets[ply] = true
                end
            end
        end

        -- Discard button states of now-removed player targets
        for ply in pairs( oldTargets ) do
            if not targets[ply] then
                fancyInput.setButtonStates( ply, {} )
            end
        end

        awaitResponse( "SetTargets" )
        net.start( "LKL_TargetedInput_SetTargets" )
        net.writeTable( targets )
        net.send()
    end

    --[[
        - Adds to the current target players, instead of replacing them.
        - Useful for a chip with multiple depencies that each use TargetedInput.
        - Cannot target bots.

        plys:
            - { plyOne, plyTwo, plyThree, ... } -> Adds these players to the target list.
                - Either numerically indexed, or a lookup table (i.e. { [1] = plyOne, [2] = plyTwo, ... }  or  { [plyOne] = tue, [plyTwo] = true, ... })
            - {} / false -> Do not add any players.
            - ply -> Add one specific player. Same as { ply }
            - nil -> Add ALL players.
    --]]
    function targetedInput.addTargets( plys )
        if plys == nil then
            targetedInput.setTargets( nil )

            return
        end

        if not plys then return end

        if type( plys ) ~= "table" then
            plys = {
                plys,
            }
        elseif tableIsEmpty( plys ) then return end

        local combinedTargets = {}

        for ply in pairs( targets ) do
            combinedTargets[ply] = true
        end

        for _, ply in pairs( plys ) do
            combinedTargets[ply] = true
        end

        targetedInput.setTargets( table.getKeys( combinedTargets ) )
    end

    --[[
        - Sets the buttons to get input updates for.
        - Valid button values are from the KEY/MOUSE enums

        buttons:
            - { btnOne, btnTwo, btnThree, ... } -> Sets these buttons as the new target inputs.
                - This can only be a numerical table, not a lookup, since buttons are themselves numbers and #tbl will get confused
            - {} / false -> Do not target any buttons.
            - btn -> Target one specific button value. Same as { btn }
            - nil -> Target ALL possible button inputs.
    --]]
    function targetedInput.setTargetButtons( buttons )
        if buttons == nil then
            targetAllButtons = true
            targetButtons = {}

            awaitResponse( "SetTargetButtons" )
            net.start( "LKL_TargetedInput_SetTargetButtons" )
            net.writeBool( targetAllButtons )
            net.writeTable( targetButtons )
            net.send()

            return
        end

        if not buttons then
            buttons = {}
        end

        if type( buttons ) ~= "table" then
            buttons = {
                buttons,
            }
        elseif tableIsEmpty( buttons ) then
            targetAllButtons = false
            targetButtons = {}

            for ply in ipairs( find.allPlayers() ) do
                fancyInput.setButtonStates( ply, {} )
            end

            awaitResponse( "SetTargetButtons" )
            net.start( "LKL_TargetedInput_SetTargetButtons" )
            net.writeBool( targetAllButtons )
            net.writeTable( targetButtons )
            net.send()

            return
        end

        for i = #buttons, 1, -1 do
            local button = buttons[i]

            if type( button ) ~= "number" then
                tableRemove( buttons, i )
            end
        end

        local plys = find.allPlayers()

        -- Remove buttons states for now-removed button targets
        for _, ply in ipairs( plys ) do
            local states = fancyInput.getButtonStates( ply )

            for button in pairs( targetButtons ) do
                if not buttons[button] then
                    states[button] = nil
                end
            end

            fancyInput.setButtonStates( ply, states )
        end

        targetAllButtons = false
        targetButtons = {}

        for _, button in pairs( buttons ) do
            targetButtons[button] = true
        end

        awaitResponse( "SetTargetButtons" )
        net.start( "LKL_TargetedInput_SetTargetButtons" )
        net.writeBool( targetAllButtons )
        net.writeTable( targetButtons )
        net.send()
    end

    --[[
        - Adds to the current target buttons, instead of replacing them.
        - Useful for a chip with multiple depencies that each use TargetedInput.
        - Valid button values are from the KEY/MOUSE enums.

        buttons:
            - { btnOne, btnTwo, btnThree, ... } -> Adds these buttons to the target inputs.
                - This can only be a numerical table, not a lookup, since buttons are themselves numbers and #tbl will get confused
            - {} / false -> Do not add any buttons.
            - btn -> Add one specific button value. Same as { btn }
            - nil -> Add ALL possible button inputs.
    --]]
    function targetedInput.addTargetButtons( buttons )
        if targetAllButtons then return end

        if buttons == nil then
            targetedInput.setTargetButtons( nil )

            return
        end

        if not buttons then return end

        if type( buttons ) ~= "table" then
            buttons = {
                buttons,
            }
        elseif tableIsEmpty( buttons ) then return end

        local combinedButtons = {}

        for button in pairs( targetButtons ) do
            combinedButtons[button] = true
        end

        for _, button in pairs( buttons ) do
            combinedButtons[button] = true
        end

        targetedInput.setTargetButtons( table.getKeys( combinedButtons ) )
    end


    ----- PRIVATE FUNCTIONS -----

    getHumans = function( plys )
        plys = plys or find.allPlayers()

        for i, ply in ipairs( plys ) do
            if not isValid( ply ) or ply:isBot() then
                tableRemove( plys, i )
            end
        end

        return plys
    end

    awaitResponseRetry = function( responseType, ply )
        if not responseType then return end
        if not isValid( ply ) then return end

        if responseType == "SetTargets" then
            net.start( "LKL_TargetedInput_SetTargets" )
            net.writeTable( targets )
            net.send( ply )
        elseif responseType == "SetTargetButtons" then
            net.start( "LKL_TargetedInput_SetTargetButtons" )
            net.writeBool( targetAllButtons )
            net.writeTable( targetButtons )
            net.send( ply )
        end
    end

    awaitResponse = function( responseType, waitFor )
        if not responseType then return end

        waitFor = waitFor or timeoutDelay

        local plys = getHumans()
        local plyLookup = {}

        for _, ply in ipairs( plys ) do
            plyLookup[ply] = true
        end

        incompleteResponses[responseType] = plyLookup

        timer.create( "LKL_TargetedInput_AwaitResponse_" .. responseType, waitFor, 1, function()
            local nonResponders = incompleteResponses[responseType] or {}

            for ply in pairs( nonResponders ) do
                awaitResponseRetry( responseType, ply )
            end

            incompleteResponses[responseType] = nil
        end )
    end


    ----- SETUP -----

    net.receive( "LKL_TargetedInput_InputClkFromNet", function( _, ply )
        if not targets[ply] then return end

        local key = net.readUInt( 10 )
        if not targetAllButtons and not targetButtons[key] then return end

        local state = net.readBool()
        local time = net.readFloat()

        fancyInput.runInput( ply, key, state, time )
    end )

    net.receive( "LKL_TargetedInput_RefreshMyButtonStates", function( _, ply )
        local states = {}

        for _ = 1, net.readUInt( 10 ) do
            states[net.readUInt( 10 )] = true
        end

        fancyInput.setButtonStates( ply, states )
    end )

    net.receive( "LKL_TargetedInput_Acknowledge", function( _, ply )
        local responseType = net.readString()
        local nonResponders = incompleteResponses[responseType]
        if not nonResponders then return end

        nonResponders[ply] = nil
    end )


    --[[
    timer.simple( 0.5, function() -- Net isn't reliable on init, so we'll send a delayed update on startup for just in case
        net.start( "LKL_TargetedInput_SetTargets" )
        net.writeTable( targets )
        net.send()

        net.start( "LKL_TargetedInput_SetTargetButtons" )
        net.writeBool( targetAllButtons )
        net.writeTable( targetButtons )
        net.send()
    end )
    --]]

    hook.add( "ClientInitialized", "LKL_TargetedInput_ClientInit", function( ply )
        timer.simple( 1, function()
            if not isValid( ply ) then return end

            net.start( "LKL_TargetedInput_SetTargets" )
            net.writeTable( targets )
            net.send( ply )

            net.start( "LKL_TargetedInput_SetTargetButtons" )
            net.writeBool( targetAllButtons )
            net.writeTable( targetButtons )
            net.send( ply )
        end )
    end )
else
    local iAmATarget = false


    local function refreshMyButtonStates()
        if not iAmATarget then return end

        local pressedButtons = fancyInput.getPressedButtons( ply )

        net.start( "LKL_TargetedInput_RefreshMyButtonStates" )
            net.writeUInt( #pressedButtons, 10 )

            for _, key in ipairs( pressedButtons ) do
                net.writeUInt( key, 10 )
            end
        net.send()
    end

    local function setTargets( newTargets )
        targets = newTargets
        iAmATarget = targets[player()]

        net.start( "LKL_TargetedInput_Acknowledge" )
        net.writeString( "SetTargets" )
        net.send()

        refreshMyButtonStates()
    end

    local function setTargetButtons( newTargetButtons, targetAll )
        targetAllButtons = targetAll
        targetButtons = newTargetButtons

        net.start( "LKL_TargetedInput_Acknowledge" )
        net.writeString( "SetTargetButtons" )
        net.send()

        refreshMyButtonStates()
    end

    local function keyClk( key, state )
        if not iAmATarget then return end
        if not targetAllButtons and not targetButtons[key] then return end

        net.start( "LKL_TargetedInput_InputClkFromNet" )
        net.writeUInt( key, 10 )
        net.writeBool( state )
        net.writeFloat( curtime() )
        net.send()
    end


    hook.add( "inputPressed", "LKL_TargetedInput_InputPressed", function( key )
        if not isFirstTimePredicted() then return end

        keyClk( key, true )
    end )

    hook.add( "inputReleased", "LKL_TargetedInput_InputReleased", function( key )
        if not isFirstTimePredicted() then return end

        keyClk( key, false )
    end )


    net.receive( "LKL_TargetedInput_SetTargets", function()
        setTargets( net.readTable() )
    end )

    net.receive( "LKL_TargetedInput_SetTargetButtons", function()
        local targetAll = net.readBool()
        local newTargetButtons = net.readTable()

        setTargetButtons( newTargetButtons, targetAll )
    end )
end