BOOGA BOOGA KEYLESS OPEN SOURCE

 Players = :()
 RunService = :()
 Workspace = :()
 UserInputService = :()
 CoreGui = :()

 LocalPlayer = Players.LocalPlayer




 Rayfield

     ok, err = (()
        Rayfield = (:())()
    )
      ok   Rayfield 
        ( .. (err))
        
    





 Settings = {
    
    GodsESP = ,
    GodHighlight = ,
    GodName = ,
    GodDistance = ,
    GodVisCheck = ,
    GodColor = .(, , ),
    GodMaxDist = ,
    GodDebug = ,

    
    PlayersESP = ,
    PlayerBox2D = ,
    PlayerBox3D = ,
    PlayerName = ,
    PlayerDistance = ,
    PlayerHealth = ,
    PlayerHealthBar = ,
    PlayerSkeleton = ,
    PlayerChams = ,
    PlayerVisCheck = ,
    PlayerColor = .(, , ),
    PlayerTeamColor = ,
    PlayerMaxDist = ,
}

 GODS_LIST = {
    , , , , ,
    , , , , ,
    , , , , ,
}


 CLEAN_GODS = {}
 i = , #GODS_LIST 
    CLEAN_GODS[i] = (.(.(GODS_LIST[i]), , ))


 FALSE_POSITIVES = {  }

 HEAVY_INTERVAL =   
 GOD_INTERVAL   =   




 DrawingSupported = 

     ok = (()
         t = .()
        t:()
    )
    DrawingSupported = ok


 SKELETON_R15 = {
    {, },
    {, },
    {, }, {, }, {, },
    {, }, {, }, {, },
    {, }, {, }, {, },
    {, }, {, }, {, },
}

 SKELETON_R6 = {
    {, },
    {, }, {, },
    {, }, {, },
}





 ().GodsPlayersESP_Destroy 
    (().GodsPlayersESP_Destroy)


 Active = 
 Connections = {}
  (conn)
    Connections[#Connections + ] = conn
     conn






.(()
     descendants = Workspace:()
     i = , #descendants 
         inst = descendants[i]
         inst.Name ==  
            (() inst:() )
        
    
)




 _, name  ({, , }) 
     old = CoreGui:(name)
     old  old:() 


 GodsFolder = .()
GodsFolder.Name = 
GodsFolder.Parent = CoreGui

 PlayersFolder = .()
PlayersFolder.Name = 
PlayersFolder.Parent = CoreGui

 ScreenGui = .()
ScreenGui.Name = 
ScreenGui.ResetOnSpawn = 
ScreenGui.IgnoreGuiInset = 
ScreenGui.DisplayOrder = 
ScreenGui.Parent = CoreGui

 GodESPData = {}
 PlayerESPData = {}
 CachedPlayers = {} 




 RayParams = RaycastParams.()
RayParams.FilterType = .RaycastFilterType.Exclude
RayParams.IgnoreWater = 

  (part, origin, ignoreModel)
     dir = part.Position - origin
     dir.Magnitude <     

     myChar = LocalPlayer.Character
     ignoreModel  myChar 
        RayParams.FilterDescendantsInstances = {myChar, ignoreModel}
     ignoreModel 
        RayParams.FilterDescendantsInstances = {ignoreModel}
     myChar 
        RayParams.FilterDescendantsInstances = {myChar}
    
        RayParams.FilterDescendantsInstances = {}
    

     result = Workspace:(origin, dir, RayParams)
      result    
     hit = result.Instance
     hit == part  hit:(part)





  (rawName)
     lower = .(rawName)
    
      .(lower, , , )    

     clean = .(lower, , )
     i = , #CLEAN_GODS 
         .(clean, CLEAN_GODS[i], , )    
    
     i = , #FALSE_POSITIVES 
         .(clean, FALSE_POSITIVES[i], , )    
    
     


  (god)
     god:()   god 
     pp = god.PrimaryPart
     pp  pp.Parent   pp 
     _, c  (god:()) 
         c:()   c 
    
     _, d  (god:()) 
         d:()   d 
    
     


  (god)
    
     ok, size = (()
         god:() 
             (, god:())
         god:() 
             god.Size
        
         .zero
    )
     ok  size  size.Y >  
         .(, size.Y *  + , )
    
     .(, , )





  (god)
     GodESPData[god]   

     folder = .()
    folder.Name =  .. god.Name

     highlight = .()
    highlight.FillColor = Settings.GodColor
    highlight.FillTransparency = 
    highlight.OutlineColor = Settings.GodColor
    highlight.OutlineTransparency = 
    highlight.DepthMode = .HighlightDepthMode.AlwaysOnTop
    highlight.Adornee = god
    highlight.Enabled = 
    highlight.Parent = folder

     billboard = .()
    billboard.Size = .(, )
    billboard.StudsOffset = (god)
    billboard.AlwaysOnTop = 
    billboard.LightInfluence = 
    billboard.MaxDistance = Settings.GodMaxDist
    billboard.Enabled = 
    billboard.Parent = folder

     label = .()
    label.Size = .(, )
    label.BackgroundTransparency = 
    label.TextColor3 = Settings.GodColor
    label.TextStrokeTransparency = 
    label.Font = .Font.GothamBold
    label.TextScaled = 
    label.Text = 
    label.Parent = billboard

    folder.Parent = GodsFolder

    GodESPData[god] = {
        god = god,
        folder = folder,
        highlight = highlight,
        billboard = billboard,
        label = label,
        root = ,
        lastRoot = ,
        rootRetryAt = ,
        lastText = ,
        labelColor = ,
        rangeOn = ,
    }

     Settings.GodDebug 
        ( .. god.Name ..  .. god.ClassName .. )
    


  (god, data, cam, now)
      god.Parent 
         data.folder  (() data.folder:() ) 
        GodESPData[god] = 
        
    

    
     root = data.root
      root   root.Parent 
        root = 
         (now - data.rootRetryAt) >=  
            data.rootRetryAt = now
            root = (god)
            data.root = root
        
          root 
            data.highlight.Enabled = 
            data.billboard.Enabled = 
            
        
    

     dist = (root.Position - cam.CFrame.Position).Magnitude
     dist > Settings.GodMaxDist 
         data.rangeOn 
            data.rangeOn = 
            data.highlight.Enabled = 
            data.billboard.Enabled = 
        
        
    
    data.rangeOn = 

     visible = 
     Settings.GodVisCheck 
        visible = (root, cam.CFrame.Position, god)
    

    data.highlight.Enabled = Settings.GodHighlight  visible
    data.highlight.FillColor = Settings.GodColor
    data.highlight.OutlineColor = Settings.GodColor

     data.lastRoot ~= root 
        data.lastRoot = root
        data.billboard.Adornee = root 
    

     showText = Settings.GodName  Settings.GodDistance
    data.billboard.Enabled = showText
     showText 
         text = 
         Settings.GodName  text = god.Name 
         Settings.GodDistance 
             text ~=   text = text ..  
            text = text .. .(, dist)
        
         data.lastText ~= text  
            data.lastText = text
            data.label.Text = text
        
         data.labelColor ~= Settings.GodColor 
            data.labelColor = Settings.GodColor
            data.label.TextColor3 = Settings.GodColor
        
        data.billboard.MaxDistance = Settings.GodMaxDist
    


  (inst)
     GodESPData[inst]   
      (inst:()  inst:())   
      (inst.Name)   
     Players:(inst)   
    (inst)



  ()
    .(()
         ok, err = (()
             stack = {Workspace}
             processed = 
             #stack >   Active 
                  Settings.GodsESP   
                 inst = .(stack)
                (inst)
                 children = inst:()
                 i = , #children 
                    stack[#stack + ] = children[i]
                
                processed += 
                 processed %  ==  
                    .() 
                
            
        )
          ok 
            ( .. (err))
        
    )



(Workspace.DescendantAdded:((inst)
     Active  Settings.GodsESP 
        (inst)
    
))

  ()
     god, data  (GodESPData) 
         data.folder  (() data.folder:() ) 
    
    .(GodESPData)





  (player)
     data = PlayerESPData[player]
      data   
    PlayerESPData[player] = 
    (() data.folder:() )
    (() data.box2d:() )
    (() data.healthbar:() )
     data.box3d  (() data.box3d:() ) 
     data.skeletonLines 
         i = , #data.skeletonLines 
            (() data.skeletonLines[i]:() )
        
    


  (player)
     player == LocalPlayer    
     data = PlayerESPData[player]
     data   data 

     folder = .()
    folder.Name =  .. player.Name

    
     chams = .()
    chams.FillColor = Settings.PlayerColor
    chams.FillTransparency = 
    chams.OutlineColor = Settings.PlayerColor
    chams.OutlineTransparency = 
    chams.DepthMode = .HighlightDepthMode.AlwaysOnTop
    chams.Enabled = 
    chams.Parent = folder

    
     billboard = .()
    billboard.Size = .(, )
    billboard.StudsOffset = .(, , )
    billboard.AlwaysOnTop = 
    billboard.LightInfluence = 
    billboard.Enabled = 
    billboard.Parent = folder

     nameLabel = .()
    nameLabel.Size = .(, , , )
    nameLabel.BackgroundTransparency = 
    nameLabel.TextColor3 = Settings.PlayerColor
    nameLabel.TextStrokeTransparency = 
    nameLabel.Font = .Font.GothamBold
    nameLabel.TextScaled = 
    nameLabel.Text = player.Name
    nameLabel.Parent = billboard

     distLabel = .()
    distLabel.Position = .(, )
    distLabel.Size = .(, , , )
    distLabel.BackgroundTransparency = 
    distLabel.TextColor3 = Settings.PlayerColor
    distLabel.TextStrokeTransparency = 
    distLabel.Font = .Font.Gotham
    distLabel.TextScaled = 
    distLabel.Text = 
    distLabel.Parent = billboard

     healthLabel = .()
    healthLabel.Position = .(, )
    healthLabel.Size = .(, , , )
    healthLabel.BackgroundTransparency = 
    healthLabel.TextColor3 = .(, , )
    healthLabel.TextStrokeTransparency = 
    healthLabel.Font = .Font.Gotham
    healthLabel.TextScaled = 
    healthLabel.Text = 
    healthLabel.Parent = billboard

    
     box3d = .()
    box3d.SurfaceTransparency = 
    box3d.LineThickness = 
    box3d.Color3 = Settings.PlayerColor
    box3d.Visible = 
    box3d.Parent = Workspace.CurrentCamera

    
     box2d = .()
    box2d.BackgroundColor3 = .(, , )
    box2d.BackgroundTransparency = 
    box2d.BorderSizePixel = 
    box2d.Visible = 
    box2d.Parent = ScreenGui

     box2dStroke = .()
    box2dStroke.Color = Settings.PlayerColor
    box2dStroke.Thickness = 
    box2dStroke.Parent = box2d

    
     hbBg = .()
    hbBg.Size = .(, )
    hbBg.BackgroundColor3 = .(, , )
    hbBg.BackgroundTransparency = 
    hbBg.BorderSizePixel = 
    hbBg.Visible = 
    hbBg.Parent = ScreenGui

     hbFill = .()
    hbFill.AnchorPoint = .(, )
    hbFill.Position = .(, , , )
    hbFill.Size = .(, )
    hbFill.BackgroundColor3 = .(, , )
    hbFill.BorderSizePixel = 
    hbFill.Parent = hbBg

    folder.Parent = PlayersFolder

    data = {
        player = player,
        folder = folder,
        chams = chams,
        billboard = billboard,
        nameLabel = nameLabel,
        distLabel = distLabel,
        healthLabel = healthLabel,
        box3d = box3d,
        box2d = box2d,
        box2dStroke = box2dStroke,
        healthbar = hbBg,
        healthbarFill = hbFill,
        skeletonLines = {},
        lastHeavy = ,
        shown = ,
        boxShown = ,
        hbShown = ,
        skelOn = ,
        visible = ,
    }
    PlayerESPData[player] = data
     data


  (data)
      data.skelOn    
    data.skelOn = 
     lines = data.skeletonLines
     i = , #lines 
        (() lines[i].Visible =  )
    


  (data, char, cam, color)
      Settings.PlayerSkeleton   DrawingSupported   char 
        (data)
        
    

     list = SKELETON_R6
      char:() 
        list = char:()  SKELETON_R15  
    
      list 
        (data)
        
    

    data.skelOn = 
     lines = data.skeletonLines
     i = , #list 
         line = lines[i]
          line 
             ok, l = (.new, )
             ok 
                l.Thickness = 
                l.Transparency = 
                l.Visible = 
                lines[i] = l
                line = l
            
        
         line 
             a = char:(list[i][])
             b = char:(list[i][])
             a  b 
                 pa, oa = cam:(a.Position)
                 pb, ob = cam:(b.Position)
                 oa  ob 
                    line.From = .(pa.X, pa.Y)
                    line.To = .(pb.X, pb.Y)
                    line.Color = color
                      line.Visible  line.Visible =  
                 line.Visible 
                    line.Visible = 
                
             line.Visible 
                line.Visible = 
            
        
    
     i = #list + , #lines 
         lines[i]  lines[i].Visible 
            lines[i].Visible = 
        
    



  (player, data, cam)
     char = player.Character
     humanoid = char  char:()
     root = char  (char:()  char.PrimaryPart  char:())
     head = char  (char:()  root)

    data.char = char
    data.root = root
    data.head = head

     visible = 
     dist = .huge
     hp = 

     root  head  humanoid  humanoid.Health >  
        dist = (root.Position - cam.CFrame.Position).Magnitude
        hp = .(humanoid.Health / .(humanoid.MaxHealth, ), , )
         dist <= Settings.PlayerMaxDist 
             Settings.PlayerVisCheck 
                visible = (head, cam.CFrame.Position, char)
            
                visible = 
            
        
    

    data.dist = dist
    data.hp = hp
    data.visible = visible

      visible 
         data.shown  
            data.shown = 
            data.chams.Enabled = 
            data.billboard.Enabled = 
             data.box3d  data.box3d.Visible =  
            data.box2d.Visible = 
            data.healthbar.Visible = 
            data.boxShown = 
            data.hbShown = 
            (data)
        
        
    
    data.shown = 

     color = Settings.PlayerColor
     Settings.PlayerTeamColor  player.Team 
        color = player.TeamColor.Color
    
     data.color ~= color  
        data.color = color
        data.box2dStroke.Color = color
        data.chams.FillColor = color
        data.chams.OutlineColor = color
        data.nameLabel.TextColor3 = color
        data.distLabel.TextColor3 = color
         data.box3d  data.box3d.Color3 = color 
    

    
     data.lastAdorn ~= char 
        data.lastAdorn = char
        data.chams.Adornee = char
         data.box3d  data.box3d.Adornee = char 
        data.billboard.Adornee = head
    

    data.chams.Enabled = Settings.PlayerChams

     data.box3d 
         data.box3d.Parent ~= cam  
             ok = (() data.box3d.Parent = cam )
              ok 
                 nb = .()
                nb.SurfaceTransparency = 
                nb.LineThickness = 
                nb.Color3 = color
                nb.Adornee = char
                nb.Parent = cam
                data.box3d = nb
            
        
        data.box3d.Visible = Settings.PlayerBox3D
    

     anyText = Settings.PlayerName  Settings.PlayerDistance  Settings.PlayerHealth
    data.billboard.Enabled = anyText
     anyText 
        data.nameLabel.Visible = Settings.PlayerName
        data.distLabel.Visible = Settings.PlayerDistance
        data.healthLabel.Visible = Settings.PlayerHealth

         Settings.PlayerName 
             t = player.Name
             player.DisplayName ~= player.Name 
                t = player.DisplayName ..  .. player.Name .. 
            
             data.lastName ~= t 
                data.lastName = t
                data.nameLabel.Text = t
            
        
         Settings.PlayerDistance 
             t = .(, dist)
             data.lastDist ~= t 
                data.lastDist = t
                data.distLabel.Text = t
            
        
         Settings.PlayerHealth 
             t = .(, .(humanoid.Health + ), .(humanoid.MaxHealth + ))
             data.lastHpText ~= t 
                data.lastHpText = t
                data.healthLabel.Text = t
            
        
    



  (data, cam)
     char = data.char

     Settings.PlayerSkeleton  DrawingSupported  char 
        (data, char, cam, data.color  Settings.PlayerColor)
    
        (data)
    

      (Settings.PlayerBox2D  Settings.PlayerHealthBar) 
         data.boxShown  data.boxShown = ; data.box2d.Visible =  
         data.hbShown  data.hbShown = ; data.healthbar.Visible =  
        
    

     head, root = data.head, data.root
      head   root   

     headPos, headOn = cam:(head.Position + .(, , ))
     footPos, footOn = cam:(root.Position - .(, , ))

     headOn  footOn 
         height = .(footPos.Y - headPos.Y)
         height <   height =  
         width = .(height * , )
         x = headPos.X - width * 
         y = .(headPos.Y, footPos.Y)

         Settings.PlayerBox2D 
            data.box2d.Position = .(x, y)
            data.box2d.Size = .(width, height)
              data.boxShown 
                data.boxShown = 
                data.box2d.Visible = 
            
         data.boxShown 
            data.boxShown = 
            data.box2d.Visible = 
        

         Settings.PlayerHealthBar 
            data.healthbar.Position = .(x - , y)
            data.healthbar.Size = .(, height)
             data.lastHp ~= data.hp 
                data.lastHp = data.hp
                data.healthbarFill.Size = .(, data.hp)
                data.healthbarFill.BackgroundColor3 = .( - data.hp, data.hp, )
            
              data.hbShown 
                data.hbShown = 
                data.healthbar.Visible = 
            
         data.hbShown 
            data.hbShown = 
            data.healthbar.Visible = 
        
    
         data.boxShown  data.boxShown = ; data.box2d.Visible =  
         data.hbShown  data.hbShown = ; data.healthbar.Visible =  
    


  ()
     player  (PlayerESPData) 
        (player)
    
    .(PlayerESPData)





(Players.PlayerAdded:((p)
     p ~= LocalPlayer 
        CachedPlayers[#CachedPlayers + ] = p
    
))

(Players.PlayerRemoving:((p)
    (p)
     i = #CachedPlayers, , - 
         CachedPlayers[i] == p 
            .(CachedPlayers, i)
            
        
    
))

 _, p  (Players:()) 
     p ~= LocalPlayer 
        CachedPlayers[#CachedPlayers + ] = p
    





 LastGodTick = 

(RunService.RenderStepped:(()
      Active   
     cam = Workspace.CurrentCamera
      cam   
     now = .()

     Settings.PlayersESP 
         perFrame2D = Settings.PlayerBox2D  Settings.PlayerHealthBar
             (Settings.PlayerSkeleton  DrawingSupported)

         i = , #CachedPlayers 
             plr = CachedPlayers[i]
             plr.Parent 
                 data = PlayerESPData[plr]
                  data 
                    data = (plr)
                
                 data 
                     (now - data.lastHeavy) >= HEAVY_INTERVAL 
                        data.lastHeavy = now
                        (plr, data, cam)
                    
                     data.visible  perFrame2D 
                        (data, cam)
                    
                
            
                (plr)
            
        
    

    
    
     Settings.GodsESP  (now - LastGodTick) >= GOD_INTERVAL 
        LastGodTick = now
         god, data  (GodESPData) 
            (god, data, cam, now)
        
    
))




  ()
    Active = 
     i = , #Connections 
        (() Connections[i]:() )
    
    .(Connections)

    ()
     god, data  (GodESPData) 
         data.folder  (() data.folder:() ) 
    
    .(GodESPData)

    (() GodsFolder:() )
    (() PlayersFolder:() )
    (() ScreenGui:() )
    (() Rayfield:() )

    
    (()
         _, inst  (Workspace:()) 
             inst.Name ==  
                inst:()
            
        
    )


().GodsPlayersESP_Destroy = FullCleanup




 Window = Rayfield:({
    Name = ,
    Subtitle = ,
    Icon = ,
    SidebarLayout = ,
    DisableBuildWarnings = ,
    ConfigurationSaving = {
        Enabled = ,
        FolderName = ,
        FileName = ,
    },
})

  (tab, info)
     (tab.CreateText) ==  
        tab:(info)
     (tab.CreateParagraph) ==  
        tab:(info)
    



 GodsTab = Window:({ Name = , Icon =  })

GodsTab:()
GodsTab:({
    Name = ,
    CurrentValue = Settings.GodsESP,
    Flag = ,
    Callback = (v)
        Settings.GodsESP = v
         v 
            ()
        
            ()
        
    ,
})

GodsTab:()
GodsTab:({ Name = , CurrentValue = Settings.GodHighlight, Flag = , Callback = (v) Settings.GodHighlight = v  })
GodsTab:({ Name = , CurrentValue = Settings.GodName, Flag = , Callback = (v) Settings.GodName = v  })
GodsTab:({ Name = , CurrentValue = Settings.GodDistance, Flag = , Callback = (v) Settings.GodDistance = v  })
GodsTab:({ Name = , CurrentValue = Settings.GodVisCheck, Flag = , Callback = (v) Settings.GodVisCheck = v  })

GodsTab:()
GodsTab:({ Name = , Color = Settings.GodColor, Flag = , Callback = (v) Settings.GodColor = v  })
GodsTab:({ Name = , Range = {, }, Increment = , CurrentValue = Settings.GodMaxDist, Flag = , Callback = (v) Settings.GodMaxDist = v  })

GodsTab:()
GodsTab:({ Name = , CurrentValue = Settings.GodDebug, Flag = , Callback = (v) Settings.GodDebug = v  })
GodsTab:({
    Name = ,
    Callback = ()
        ()
    ,
})
GodsTab:({
    Name = ,
    Callback = ()
        .(()
             count = 
             _, inst  (Workspace:()) 
                 .(.(inst.Name), , , ) 
                    count += 
                    ( .. inst:() ..  .. inst.ClassName .. )
                
            
            ( .. count)
        )
    ,
})

(GodsTab, {
    Title = ,
    Content = ,
})


 PlayersTab = Window:({ Name = , Icon =  })

PlayersTab:()
PlayersTab:({
    Name = ,
    CurrentValue = Settings.PlayersESP,
    Flag = ,
    Callback = (v)
        Settings.PlayersESP = v
          v  () 
    ,
})

PlayersTab:()
PlayersTab:({ Name = , CurrentValue = Settings.PlayerBox2D, Flag = , Callback = (v) Settings.PlayerBox2D = v  })
PlayersTab:({ Name = , CurrentValue = Settings.PlayerBox3D, Flag = , Callback = (v) Settings.PlayerBox3D = v  })

PlayersTab:()
PlayersTab:({ Name = , CurrentValue = Settings.PlayerName, Flag = , Callback = (v) Settings.PlayerName = v  })
PlayersTab:({ Name = , CurrentValue = Settings.PlayerDistance, Flag = , Callback = (v) Settings.PlayerDistance = v  })
PlayersTab:({ Name = , CurrentValue = Settings.PlayerHealth, Flag = , Callback = (v) Settings.PlayerHealth = v  })
PlayersTab:({ Name = , CurrentValue = Settings.PlayerHealthBar, Flag = , Callback = (v) Settings.PlayerHealthBar = v  })
PlayersTab:({ Name = , CurrentValue = Settings.PlayerSkeleton, Flag = , Callback = (v) Settings.PlayerSkeleton = v  })

PlayersTab:()
PlayersTab:({ Name = , CurrentValue = Settings.PlayerChams, Flag = , Callback = (v) Settings.PlayerChams = v  })
PlayersTab:({ Name = , CurrentValue = Settings.PlayerVisCheck, Flag = , Callback = (v) Settings.PlayerVisCheck = v  })
PlayersTab:({ Name = , CurrentValue = Settings.PlayerTeamColor, Flag = , Callback = (v) Settings.PlayerTeamColor = v  })
PlayersTab:({ Name = , Color = Settings.PlayerColor, Flag = , Callback = (v) Settings.PlayerColor = v  })
PlayersTab:({ Name = , Range = {, }, Increment = , CurrentValue = Settings.PlayerMaxDist, Flag = , Callback = (v) Settings.PlayerMaxDist = v  })

(PlayersTab, {
    Title = ,
    Content = DrawingSupported
         
         ,
})


 MiscTab = Window:({ Name = , Icon =  })

MiscTab:({
    Name = ,
    Callback = ()
        .(()
             n = 
             _, inst  (Workspace:()) 
                 inst.Name ==  
                    inst:()
                    n += 
                
            
            ( .. n)
        
    ,
})

MiscTab:({
    Name = ,
    Callback = ()
        ()
    ,
})

(MiscTab, {
    Title = ,
    Content = ,
})




(UserInputService.InputBegan:((input, processed)
     processed   
     input.KeyCode == .KeyCode.RightShift 
        (()
             (Rayfield.Toggle) ==  
                Rayfield:()
            
        )
    
))


 Settings.GodsESP 
    ()


()
()
()
()
()
()