net-transfer.yue

:Broadcast, :Start, :Send, :SendToServer, :ReadBool, :ReadData, :ReadString, :ReadUInt, :WriteBool, :WriteData, :WriteString, :WriteUInt = net
ErrorNoHaltWithStack = ErrorNoHaltWithStack
:CRC, :Compress, :Decompress = util
:sub, :find, :format, :len = string
:Simple, :Create, :Remove = timer
:abs, :ceil, :log = math
tostring = tostring
tonumber = tonumber
TypeID = TypeID
xpcall = xpcall
error = error

NET_LIMIT = 2 ^ 16 - 2 ^ 10
NetTransfers = {}

if SERVER
    util.AddNetworkString( "NetTransfer::NS" )

net.Receive "NetTransfer::NS", ( bits, ply ) ->
    netTransfer = NetTransfers[ ReadString! ]
    if netTransfer
        netTransfer\Incoming( bits, ply )

-- Smart player filter
PerformFilter = ( netTransfer, filter, ply ) ->
    if filter
        switch TypeID( filter )
            when TYPE_BOOL
                return filter

            when TYPE_NUMBER
                return ply\EntIndex! == filter

            when TYPE_STRING
                unless ply\IsBot!
                    if ply\SteamID64! == filter
                        return true

                    if ply\SteamID! == filter
                        return true

                return find( ply\Nick!, filter ) ~= nil

            when TYPE_TABLE
                for value in *filter
                    if PerformFilter( netTransfer, value, ply )
                        return true

                return false

            when TYPE_FUNCTION
                return filter( netTransfer, ply )

            when TYPE_ENTITY
                return ply == filter

            when TYPE_VECTOR
                return ply\TestPVS( filter )

            when TYPE_RECIPIENTFILTER
                return PerformFilter( netTransfer, filter\GetPlayers!, ply )

    return true

class NetTransfer
    __tostring: =>
        return format( "NetTransfer: %p [%s]", @, @TransferName )

    new: ( transferName, verifyChecksums, unreliable ) =>
        assert isstring( transferName ), "First argument must be a 'string'!"
        NetTransfers[ transferName ] = @

        @TransferName = transferName
        @Receiving = false
        @Sending = false

        @SetVerifyChecksums( verifyChecksums )
        @SetTransmissionSpeed( 1.2, true )
        @SetUnreliable( unreliable )
        @SetTimeout( 10 )

    -- Receive timeout
    GetTimeout: =>
        return @Timeout

    SetTimeout: ( int ) =>
        assert isnumber( int ), "Second argument must be a 'number'!"
        @Timeout = abs( int )

    -- Transmission speed ( Packet per second )
    --[[

        Maximum speed is available at value 4,
        values higher than this do not guarantee
        speed increase, 0.8 guarantees synchronization
        between receiving and sending.

        High speed may interfere with
        normal net library operations.

    ]]

    GetTransmissionSpeed: =>
        return 1 / @TransmissionSpeed

    SetTransmissionSpeed: ( pps, noCeil ) =>
        assert isnumber( pps ), "Second argument must be a 'number'!"
        @TransmissionSpeed = 1 / ( noCeil and pps or ceil( pps ) )

    -- Unreliable networking
    IsUnreliable: =>
        return @Unreliable

    SetUnreliable: ( value ) =>
        @Unreliable = value == true

    -- Checksums verify
    IsVerifyChecksums: =>
        return @VerifyChecksums

    SetVerifyChecksums: ( value ) =>
        @VerifyChecksums = value == true

    -- Player filter
    GetFilter: =>
        return @Filter

    SetFilter: ( value ) =>
        @Filter = value

    IsAllowedPlayer: ( ply ) =>
        return PerformFilter( @, @Filter, ply )

    -- LZMA data compression
    IsCompressedData: =>
        return @Compressed

    CompressData: =>
        transmittedData = @TransmittedData
        if @Compressed
            return transmittedData

        transmittedData = Compress( transmittedData )
        @TransmittedData = transmittedData
        @Compressed = true
        return transmittedData

    DecompressData: =>
        transmittedData = @TransmittedData
        unless @Compressed
            return transmittedData

        transmittedData = Decompress( transmittedData )
        @TransmittedData = transmittedData
        @Compressed = false
        return transmittedData

    -- Transmitted data
    GetTransmittedData: =>
        return @TransmittedData

    SetTransmittedData: ( transmittedData, compress, decompress ) =>
        assert isstring( transmittedData ), "Second argument must be a 'string'!"
        @TransmittedData = transmittedData

        if compress
            return @CompressData!
        elseif decompress
            return @DecompressData!
        return transmittedData

    -- Networking
    StartTransmission: =>
        Start( "NetTransfer::NS", @Unreliable )
        WriteString( @TransferName )

    EndTransmission: ( target ) =>
        if SERVER
            if target
                Send( target )
            else
                Broadcast!
        else
            SendToServer!

    -- Sending
    IsSending: =>
        return @Sending

    Send: ( ply ) =>
        if @Sending
            return

        unless @IsAllowedPlayer( ply )
            return

        transmittedData = @TransmittedData
        dataSize = len( transmittedData )
        messageCount = ceil( dataSize / NET_LIMIT )
        totalBits = ceil( log( messageCount + 1, 2 ) )
        totalBits = totalBits < 1 and 1 or totalBits
        @Sending = true

        @StartTransmission!
        WriteUInt( totalBits - 1, 5 )
        WriteUInt( messageCount, totalBits )
        WriteBool( @Compressed )

        if @VerifyChecksums
            WriteUInt( tonumber( CRC( transmittedData ) ), 32 )

        @EndTransmission( ply )

        pointer = 0
        for number = 1, messageCount
            size = dataSize > NET_LIMIT and NET_LIMIT or dataSize
            dataSize -= size

            data = sub( transmittedData, pointer + 1, pointer + size )
            pointer += size

            Simple number * @TransmissionSpeed, ->
                unless @Sending
                    return

                @StartTransmission!
                WriteData( data, size )
                @EndTransmission( ply )

                progressFunc = @ProgressFunc
                if progressFunc
                    xpcall( progressFunc, ErrorNoHaltWithStack, @, number / messageCount, size )

                if number == messageCount
                    @Sending = false

    -- Receiving
    IsReceiving: =>
        return @Receiving

    Receive: ( func, permanent ) =>
        assert isfunction( func ), "Second argument must be a 'function'!"
        @PermanentReceive = permanent == true
        @ReceiveFunc = func

    Incoming: ( bits, ply ) =>
        receiveFunc = @ReceiveFunc
        unless receiveFunc
            return

        unless @IsAllowedPlayer( ply )
            return

        Create tostring( @ ), @Timeout, 1, ->
            @Error( format( "Timeout, no response for %d seconds.", @Timeout ) )

        unless @Receiving
            @MessageCount = ReadUInt( ReadUInt( 5 ) + 1 )
            @Compressed = ReadBool!

            if @VerifyChecksums
                @FileCRC = tostring( ReadUInt( 32 ) )

            @TransmittedData = ""
            @Receiving = true
            @Received = 0
            return

        bytes = ( bits / 8 ) - ( #@TransferName + 1 )
        received = @Received + 1
        @Received = received

        transmittedData = @TransmittedData .. ReadData( bytes )
        @TransmittedData = transmittedData

        fraction = received / @MessageCount

        progressFunc = @ProgressFunc
        if progressFunc
            xpcall( progressFunc, ErrorNoHaltWithStack, @, fraction, bytes )

        if fraction >= 1
            @Finish!

            if not @VerifyChecksums or CRC( transmittedData ) == @FileCRC
                if @Compressed
                    transmittedData = Decompress( transmittedData )
                    @TransmittedData = transmittedData

                xpcall( receiveFunc, ErrorNoHaltWithStack, @, transmittedData, ply )
                return

            @Error( "Checksum does not match expected, failure." )

    -- Other
    OnProgress: ( func ) =>
        assert isfunction( func ), "Second argument must be a 'function'!"
        @ProgressFunc = func

    Error: ( message, ... ) =>
        @Finish!

        errorFunc = @ErrorFunc
        if errorFunc
            xpcall( errorFunc, ErrorNoHaltWithStack, @, message, ... )

        error( "#{@} error: " .. message )

    OnError: ( func ) =>
        assert isfunction( func ), "Second argument must be a 'function'!"
        @ErrorFunc = func

    Finish: =>
        Remove tostring( @ )
        @Receiving = false
        @Sending = false

        unless @PermanentReceive
            @ReceiveFunc = nil

    Remove: =>
        NetTransfers[ @TransferName ] = nil
        @Finish!

_G.NetTransfer = NetTransfer
export default NetTransfer