antiafk open source

 Players = :()
 VirtualUser = :()
 UserInputService = :()
 TweenService = :()
 RunService = :()

 player = Players.LocalPlayer
 playerGui = player:()

 playerGui:() 
    playerGui:():()


 environment = {
    isMobile = UserInputService.TouchEnabled   UserInputService.KeyboardEnabled,
    isPC = UserInputService.KeyboardEnabled,
    hasVirtualUser = (()  VirtualUser:() ),
    hasCamera = .CurrentCamera ~= ,
    executor = identifyexecutor  ()  
}

()
(, environment.isMobile    )
(, environment.executor)
(, environment.hasVirtualUser    )
(, environment.hasCamera    )
()

 settings = {
    enabled = ,
    baseInterval = ,
    jitter = ,
    burstChance = ,
    toggleKey = .KeyCode.F4,
    isWindowFocused = ,
    unfocusedMultiplier = 
}

 connections = {}
 isInitialized = 

  (a, b)
     a + .() * (b - a)


  ()
     base = settings.baseInterval
     jitter = base * settings.jitter
      = base + (-jitter, jitter)
    
     .() <  
         =  + (, )
    
    
      settings.isWindowFocused 
         =  * settings.unfocusedMultiplier
    
    
     .(, )


  (title, text, duration)
     success, err = (()
         notifGui = .()
        notifGui.Name = 
        notifGui.DisplayOrder = 
        notifGui.Parent = playerGui
        
         notif = .()
        notif.Size = .(, , , )
        notif.Position = .(, -, , -)
        notif.BackgroundColor3 = .(, , )
        notif.BorderSizePixel = 
        notif.Parent = notifGui
        
         notifCorner = .()
        notifCorner.CornerRadius = .(, )
        notifCorner.Parent = notif
        
         notifGradient = .()
        notifGradient.Color = ColorSequence.{
            ColorSequenceKeypoint.(, .(, , )),
            ColorSequenceKeypoint.(, .(, , ))
        }
        notifGradient.Rotation = 
        notifGradient.Parent = notif
        
         notifStroke = .()
        notifStroke.Color = .(, , )
        notifStroke.Thickness = 
        notifStroke.Transparency = 
        notifStroke.Parent = notif
        
         glow = .()
        glow.Size = .(, , , )
        glow.Position = .(, , , )
        glow.AnchorPoint = .(, )
        glow.BackgroundTransparency = 
        glow.Image = 
        glow.ImageColor3 = .(, , )
        glow.ImageTransparency = 
        glow.ScaleType = .ScaleType.Slice
        glow.SliceCenter = Rect.(, , , )
        glow.ZIndex = -
        glow.Parent = notif
        
         iconBg = .()
        iconBg.Size = .(, , , )
        iconBg.Position = .(, , , -)
        iconBg.BackgroundColor3 = .(, , )
        iconBg.BorderSizePixel = 
        iconBg.Parent = notif
        
         iconBgCorner = .()
        iconBgCorner.CornerRadius = .(, )
        iconBgCorner.Parent = iconBg
        
         iconBgGradient = .()
        iconBgGradient.Color = ColorSequence.{
            ColorSequenceKeypoint.(, .(, , )),
            ColorSequenceKeypoint.(, .(, , ))
        }
        iconBgGradient.Rotation = 
        iconBgGradient.Parent = iconBg
        
         notifIcon = .()
        notifIcon.Size = .(, , , )
        notifIcon.BackgroundTransparency = 
        notifIcon.Text = 
        notifIcon.TextColor3 = .(, , )
        notifIcon.Font = .Font.GothamBold
        notifIcon.TextSize = 
        notifIcon.Parent = iconBg
        
         textContainer = .()
        textContainer.Size = .(, -, , -)
        textContainer.Position = .(, , , )
        textContainer.BackgroundTransparency = 
        textContainer.Parent = notif
        
         notifTitle = .()
        notifTitle.Size = .(, , , )
        notifTitle.Position = .(, , , )
        notifTitle.BackgroundTransparency = 
        notifTitle.Text = title
        notifTitle.TextColor3 = .(, , )
        notifTitle.Font = .Font.GothamBold
        notifTitle.TextSize = 
        notifTitle.TextXAlignment = .TextXAlignment.Left
        notifTitle.Parent = textContainer
        
         notifText = .()
        notifText.Size = .(, , , )
        notifText.Position = .(, , , )
        notifText.BackgroundTransparency = 
        notifText.Text = text
        notifText.TextColor3 = .(, , )
        notifText.Font = .Font.Gotham
        notifText.TextSize = 
        notifText.TextXAlignment = .TextXAlignment.Left
        notifText.TextYAlignment = .TextYAlignment.Top
        notifText.TextWrapped = 
        notifText.Parent = textContainer
        
         slideIn = TweenService:(notif,
            TweenInfo.(, .EasingStyle.Back, .EasingDirection.Out),
            {Position = .(, -, , )}
        )
        
         pulse = TweenService:(iconBg,
            TweenInfo.(, .EasingStyle.Sine, .EasingDirection.InOut, -, ),
            {Size = .(, , , ), Position = .(, , , -)}
        )
        
         glowPulse = TweenService:(glow,
            TweenInfo.(, .EasingStyle.Sine, .EasingDirection.InOut, -, ),
            {ImageTransparency = }
        )
        
        slideIn:()
        ()
        pulse:()
        glowPulse:()
        
        (duration  )
        
        pulse:()
        glowPulse:()
        
         slideOut = TweenService:(notif,
            TweenInfo.(, .EasingStyle.Back, .EasingDirection.In),
            {Position = .(, -, , -)}
        )
        
        slideOut:()
        slideOut.Completed:()
        notifGui:()
    )
    
      success 
        (, err)
    


  (frame)
     success, err = (()
         dragging, dragStart, startPos
        
        .(connections, frame.InputBegan:((input)
             input.UserInputType == .UserInputType.MouseButton1  input.UserInputType == .UserInputType.Touch 
                dragging = 
                dragStart = input.Position
                startPos = frame.Position
                input.Changed:(()
                     input.UserInputState == .UserInputState.End 
                        dragging = 
                    
                )
            
        ))
        
        .(connections, frame.InputChanged:((input)
             dragging  (input.UserInputType == .UserInputType.MouseMovement  input.UserInputType == .UserInputType.Touch) 
                 delta = input.Position - dragStart
                frame.Position = .(
                    startPos.X.Scale, startPos.X.Offset + delta.X,
                    startPos.Y.Scale, startPos.Y.Offset + delta.Y
                )
            
        ))
    )
    
      success 
        (, err)
    


  ()
     success, result = (()
         gui = .()
        gui.Name = 
        gui.ResetOnSpawn = 
        gui.DisplayOrder = 
        gui.Parent = playerGui

         shadow = .()
        shadow.Size = .(, , , )
        shadow.Position = environment.isMobile  .(, -, , )  .(, , , )
        shadow.BackgroundColor3 = .(, , )
        shadow.BackgroundTransparency = 
        shadow.BorderSizePixel = 
        shadow.Parent = gui
        
         shadowCorner = .()
        shadowCorner.CornerRadius = .(, )
        shadowCorner.Parent = shadow

         panel = .()
        panel.Size = .(, , , )
        panel.Position = environment.isMobile  .(, -, , )  .(, , , )
        panel.BackgroundColor3 = .(, , )
        panel.BorderSizePixel = 
        panel.Active = 
        panel.Parent = gui
        
         panelCorner = .()
        panelCorner.CornerRadius = .(, )
        panelCorner.Parent = panel
        
         gradient = .()
        gradient.Color = ColorSequence.{
            ColorSequenceKeypoint.(, .(, , )),
            ColorSequenceKeypoint.(, .(, , ))
        }
        gradient.Rotation = 
        gradient.Parent = panel
        
         accent = .()
        accent.Size = .(, , , )
        accent.BackgroundColor3 = .(, , )
        accent.BorderSizePixel = 
        accent.Parent = panel
        
         accentCorner = .()
        accentCorner.CornerRadius = .(, )
        accentCorner.Parent = accent
        
         accentGradient = .()
        accentGradient.Color = ColorSequence.{
            ColorSequenceKeypoint.(, .(, , )),
            ColorSequenceKeypoint.(, .(, , )),
            ColorSequenceKeypoint.(, .(, , ))
        }
        accentGradient.Parent = accent

         icon = .()
        icon.Size = .(, , , )
        icon.Position = .(, , , )
        icon.BackgroundTransparency = 
        icon.Text = environment.isMobile    
        icon.TextColor3 = .(, , )
        icon.Font = .Font.GothamBold
        icon.TextSize = 
        icon.ClipsDescendants = 
        icon.ZIndex = 
        icon.Parent = panel
        
         iconShine = .()
        iconShine.Size = .(, , , )
        iconShine.Position = .(, -, -, )
        iconShine.BackgroundColor3 = .(, , )
        iconShine.BorderSizePixel = 
        iconShine.Rotation = 
        iconShine.BackgroundTransparency = 
        iconShine.ZIndex = 
        iconShine.Parent = icon
        
         shineGradient = .()
        shineGradient.Transparency = NumberSequence.{
            NumberSequenceKeypoint.(, ),
            NumberSequenceKeypoint.(, ),
            NumberSequenceKeypoint.(, ),
            NumberSequenceKeypoint.(, )
        }
        shineGradient.Rotation = 
        shineGradient.Parent = iconShine

         title = .()
        title.Size = .(, -, , )
        title.Position = .(, , , )
        title.BackgroundTransparency = 
        title.Text = 
        title.TextColor3 = .(, , )
        title.Font = .Font.GothamBold
        title.TextSize = 
        title.TextXAlignment = .TextXAlignment.Left
        title.Parent = panel

         toggle = .()
        toggle.Size = .(, , , )
        toggle.Position = .(, -, , )
        toggle.BackgroundColor3 = .(, , )
        toggle.TextColor3 = .(, , )
        toggle.Font = .Font.GothamBold
        toggle.TextSize = 
        toggle.Text = 
        toggle.AutoButtonColor = 
        toggle.Parent = panel
        
         toggleCorner = .()
        toggleCorner.CornerRadius = .(, )
        toggleCorner.Parent = toggle
        
         toggleStroke = .()
        toggleStroke.Color = .(, , )
        toggleStroke.Thickness = 
        toggleStroke.Transparency = 
        toggleStroke.Parent = toggle

         statusBar = .()
        statusBar.Size = .(, -, , )
        statusBar.Position = .(, , , )
        statusBar.BackgroundColor3 = .(, , )
        statusBar.BorderSizePixel = 
        statusBar.Parent = panel
        
         statusCorner = .()
        statusCorner.CornerRadius = .(, )
        statusCorner.Parent = statusBar

         statusDot = .()
        statusDot.Size = .(, , , )
        statusDot.Position = .(, , , -)
        statusDot.BackgroundColor3 = .(, , )
        statusDot.BorderSizePixel = 
        statusDot.Parent = statusBar
        
         dotCorner = .()
        dotCorner.CornerRadius = .(, )
        dotCorner.Parent = statusDot

         status = .()
        status.Size = .(, -, , )
        status.Position = .(, , , )
        status.BackgroundTransparency = 
        status.Text = 
        status.TextColor3 = .(, , )
        status.Font = .Font.GothamMedium
        status.TextSize = environment.isMobile    
        status.TextXAlignment = .TextXAlignment.Left
        status.Parent = statusBar

         {
            gui = gui, 
            panel = panel, 
            shadow = shadow,
            toggle = toggle, 
            toggleStroke = toggleStroke,
            status = status,
            statusDot = statusDot,
            accent = accent,
            icon = icon,
            iconShine = iconShine
        }
    )
    
      success 
        (, result)
         
    
    
     result


 ui = ()
  ui 
    ()
    


(ui.panel)

(()
    .(connections, ui.panel:():(()
        ui.shadow.Position = .(
            ui.panel.Position.X.Scale,
            ui.panel.Position.X.Offset - ,
            ui.panel.Position.Y.Scale,
            ui.panel.Position.Y.Offset - 
        )
    ))
)

  ()
    (()
         camera = .CurrentCamera
          camera   environment.hasCamera   
        
         original = camera.CFrame
         pattern = .(, )
        
         pattern ==  
             yaw = .((-, ))
             pitch = .((-, ))
             target = original * .(pitch, yaw, )
            
             success = (()
                 tween = TweenService:(camera,
                    TweenInfo.((, ), .EasingStyle.Sine),
                    { = target}
                )
                tween:()
                tween.Completed:()
            )
            
              success 
                camera.CFrame = camera.CFrame:(target, )
            
            
            ((, ))
            
            (()
                TweenService:(camera, TweenInfo.((, ), .EasingStyle.Sine),
                    { = original}):()
            )
                
         pattern ==  
             yaw = .((-, ))
             pitch = .((-, ))
             target = original * .(pitch, yaw, )
            
             success = (()
                 tween = TweenService:(camera,
                    TweenInfo.((, ), .EasingStyle.Linear),
                    { = target}
                )
                tween:()
                tween.Completed:()
            )
            
              success 
                 i = ,  
                    camera.CFrame = camera.CFrame:(target, )
                    ()
                
            
            
            (()
                TweenService:(camera, TweenInfo.((, ), .EasingStyle.Sine),
                    { = original}):()
            )
                
        
             steps = .(, )
             i = , steps 
                  settings.enabled   
                 angle = (i / steps) * .pi * 
                 yaw = .(.(angle) * )
                 pitch = .(.(angle) * )
                 target = original * .(pitch, yaw, )
                camera.CFrame = camera.CFrame:(target, )
                ((, ))
            
            camera.CFrame = camera.CFrame:(original, )
        
    )


  ()
    (()
         character = player.Character
          character   
        
         humanoid = character:()
         rootPart = character:()
        
         humanoid  rootPart 
             moveDirection = .(, )
             directions = {
                .(, , ),
                .(-, , ),
                .(, , ),
                .(, , -)
            }
            
            humanoid:(directions[moveDirection], )
            ((, ))
            humanoid:(.(, , ), )
            
             .() <  
                (()
                    humanoid.Jump = 
                )
            
        
    )


  ()
    (()
         count = .(, )
         i = , count 
              settings.enabled   
            
             success = 
            
             environment.hasVirtualUser 
                success = (()
                    VirtualUser:()
                    VirtualUser:(.(, ))
                )
            
            
              success 
                (()
                    VirtualUser:(.(, ), )
                    ()
                    VirtualUser:(.(, ), )
                )
            
            
              success  environment.isMobile 
                (()
                     touch = .()
                    touch.Position = .(, )
                )
            
            
            ((, ))
        
    )


  ()
      settings.enabled   
    
    (()
         methods = {}
        
         environment.hasCamera 
            .(methods, cameraNudge)
        
        
         environment.hasVirtualUser 
            .(methods, virtualAction)
        
        
        .(methods, characterMovement)
        
         #methods ==  
            ()
            
        
        
         action = .(, )
        
         action <=  
             environment.hasCamera 
                ()
            
                methods[.(#methods)]()
            
         action <=  
             environment.hasVirtualUser 
                ()
             environment.hasCamera 
                ()
            
                ()
            
        
             environment.hasCamera 
                ()
                ((, ))
            
            
             environment.hasVirtualUser 
                ()
            
                ()
            
        
    )


  (state)
      ui   ui.toggle   
    
    (()
        settings.enabled = state
        ui.toggle.Text = state    
        
         statusText = 
         state 
             settings.isWindowFocused 
                statusText = 
            
                statusText = 
            
        
        ui.status.Text = statusText
        
         toggleColor = state  .(, , )  .(, , )
         strokeColor = state  .(, , )  .(, , )
         dotColor = state  .(, , )  .(, , )
         statusColor = state  .(, , )  .(, , )
        
        TweenService:(ui.toggle, TweenInfo.(, .EasingStyle.Quint), 
            {BackgroundColor3 = toggleColor}):()
        TweenService:(ui.toggleStroke, TweenInfo.(), 
            {Color = strokeColor}):()
        TweenService:(ui.statusDot, TweenInfo.(), 
            {BackgroundColor3 = dotColor}):()
        TweenService:(ui.status, TweenInfo.(), 
            {TextColor3 = statusColor}):()
        
         state 
             original = ui.toggle.Size
            ui.toggle.Size = .(, , , )
            TweenService:(ui.toggle, TweenInfo.(, .EasingStyle.Back), 
                {Size = original}):()
        
    )


 ui  ui.toggle 
    .(connections, ui.toggle.MouseButton1Click:(()
        ( settings.enabled)
    ))

     environment.isPC 
        .(connections, ui.toggle.MouseEnter:(()
            (()
                TweenService:(ui.toggle, TweenInfo.(), 
                    {Size = .(, , , )}):()
                TweenService:(ui.toggleStroke, TweenInfo.(), 
                    {Transparency = , Thickness = }):()
            )
        ))

        .(connections, ui.toggle.MouseLeave:(()
            (()
                TweenService:(ui.toggle, TweenInfo.(), 
                    {Size = .(, , , )}):()
                TweenService:(ui.toggleStroke, TweenInfo.(), 
                    {Transparency = , Thickness = }):()
            )
        ))
    
        .(connections, ui.toggle.InputBegan:((input)
             input.UserInputType == .UserInputType.Touch 
                (()
                    TweenService:(ui.toggle, TweenInfo.(), 
                        {Size = .(, , , )}):()
                    TweenService:(ui.toggleStroke, TweenInfo.(), 
                        {Transparency = , Thickness = }):()
                )
            
        ))
        
        .(connections, ui.toggle.InputEnded:((input)
             input.UserInputType == .UserInputType.Touch 
                (()
                    ()
                    TweenService:(ui.toggle, TweenInfo.(), 
                        {Size = .(, , , )}):()
                    TweenService:(ui.toggleStroke, TweenInfo.(), 
                        {Transparency = , Thickness = }):()
                )
            
        ))
    


  ()
    (()
        .(connections, player.Idled:(()
             settings.enabled 
                .(()
                    ()
                      settings.isWindowFocused 
                        ((, ))
                        ()
                    
                )
            
        ))
    )

()

.(connections, player.CharacterAdded:(()
    ()
    ()
))

.(()
     .() 
          settings.enabled   ui   ui.gui   ui.gui.Parent   
        
        (()
             .() < settings.burstChance 
                 i = , .(, ) 
                      settings.enabled   
                    ()
                    ((, ))
                
            
                ()
            
        )
        
         waitTime = ()
         i = , waitTime 
              settings.enabled   ui   ui.gui   ui.gui.Parent   
            ()
        
    
)

.(()
     .() 
          settings.enabled   ui   ui.gui   ui.gui.Parent   
        
        (()
              settings.isWindowFocused 
                ()
            
        )
        
          settings.isWindowFocused 
            ((, ))
        
    
)

.(()
     .() 
          ui   ui.statusDot   ui.gui   ui.gui.Parent   
        
        (()
             settings.enabled 
                TweenService:(ui.statusDot, TweenInfo.(, .EasingStyle.Sine), 
                    {BackgroundTransparency = }):()
                ()
                 ui  ui.statusDot 
                    TweenService:(ui.statusDot, TweenInfo.(, .EasingStyle.Sine), 
                        {BackgroundTransparency = }):()
                
            
                 ui  ui.statusDot 
                    ui.statusDot.BackgroundTransparency = 
                
            
        )
    
)

.(()
     .() 
          ui   ui.iconShine   ui.gui   ui.gui.Parent   
        
        (()
            ui.iconShine.Position = .(, -, -, )
             shine = TweenService:(ui.iconShine,
                TweenInfo.(, .EasingStyle.Quad, .EasingDirection.InOut),
                {Position = .(, , -, )}
            )
            shine:()
            shine.Completed:()
            ()
        )
    
)

.(()
     .() 
          ui   ui.accent   ui.gui   ui.gui.Parent   
        
        (()
             gradient = ui.accent:()
             gradient 
                 shimmer = TweenService:(gradient,
                    TweenInfo.(, .EasingStyle.Sine),
                    {Offset = .(, )}
                )
                shimmer:()
                shimmer.Completed:()
                 gradient 
                    gradient.Offset = .(-, )
                
            
        )
    
)

.(connections, UserInputService.InputBegan:((input, gp)
      gp  input.KeyCode == settings.toggleKey  environment.isPC 
        ( settings.enabled)
    
))

.(connections, UserInputService.WindowFocusReleased:(()
    settings.isWindowFocused = 
     settings.enabled  ui  ui.status 
        (()
            ui.status.Text = 
            TweenService:(ui.status, TweenInfo.(), 
                {TextColor3 = .(, , )}):()
        )
    
))

.(connections, UserInputService.WindowFocused:(()
    settings.isWindowFocused = 
     settings.enabled  ui  ui.status 
        (()
            ui.status.Text = 
            TweenService:(ui.status, TweenInfo.(), 
                {TextColor3 = .(, , )}):()
        )
    
))

 lastHeartbeatAction = ()
 nextActionTime = 

.(connections, RunService.Heartbeat:(()
      settings.enabled   
    
     currentTime = ()
     currentTime >= nextActionTime 
        nextActionTime = currentTime + ()
        .(()
            ()
        )
    
))

  ()
     _, conn  (connections) 
        (()
            conn:()
        )
    
    
     ui  ui.gui 
        (()
            ui.gui:()
        )
    


.(connections, :().PlayerRemoving:((plr)
     plr == player 
        ()
    
))

isInitialized = 
()

 platformText = environment.isMobile    
 toggleHint = environment.isMobile    
 methodsText = 
 environment.hasCamera  environment.hasVirtualUser 
    methodsText = 
 environment.hasCamera 
    methodsText = 
 environment.hasVirtualUser 
    methodsText = 

    methodsText = 


(, .(, platformText, methodsText, toggleHint), )