Eni v3 | Free Aimbot & ESP script

 Players          = :()
 RunService       = :()
 UserInputService = :()
 Lighting         = :()
 Camera           = .CurrentCamera
 LP               = Players.LocalPlayer
 Mouse            = LP:()




 Cfg = {
    Aimbot = {
        Enabled     = ,
        SilentAim   = ,
        Prediction  = ,
        AimPart     = ,
        FOV         = ,
        Smooth      = ,
        TeamCheck   = ,
        HoldKey     = .KeyCode.Q,
        BulletSpeed = ,
    },
    Triggerbot = {
        Enabled   = ,
        Delay     = ,
        TeamCheck = ,
    },
    Hitbox = {
        Enabled = ,
        Size    = ,
    },
    ESP = {
        Enabled    = ,
        Box        = ,
        Name       = ,
        Distance   = ,
        Tracer     = ,
        HealthBar  = ,
        Skeleton   = ,
        TeamCheck  = ,
        MaxDist    = ,
        EnemyColor = .(, , ),
    },
    Visual = {
        RainbowESP   = ,
        RainbowSpeed = ,
        Chams        = ,
        ChamsColor   = .(, , ),
        RainbowGUI   = ,
        Fullbright   = ,
        RainbowWorld = ,
        Radar        = ,
        RadarScale   = ,
    },
    Crosshair = {
        Enabled = ,
        Color   = .(, , ),
        Size    = ,
        Gap     = ,
        Thick   = ,
    },
    FOVChanger = {
        Enabled = ,
        Value   = ,
    },
    Player = {
        FlyEnabled    = ,
        FlySpeed      = ,
        InfJump       = ,
        JumpPower     = ,
        AntiFall      = ,
        NoclipEnabled = ,
    },
}




 FOVCircle, CHLines, RainbowBorder, RadarBG, RadarBorder, RadarCenter
CHLines       = {}
RainbowBorder = {}
 Pool        = {}
 ChamsPool   = {}
 RadarDots   = {}
 RainbowHue  = 
 TriggerDebounce = 
 TriggerTimer    = 


 R15_BONES = {
    {,},{,},
    {,},{,},
    {,},{,},
    {,},{,},
    {,},{,},
}
 R6_BONES = {
    {,},{,},{,},
    {,},{,},
}




 OrigLight = {
    Brightness     = Lighting.Brightness,
    Ambient        = Lighting.Ambient,
    OutdoorAmbient = Lighting.OutdoorAmbient,
}

  (v)
     v 
        Lighting.Brightness     = 
        Lighting.Ambient        = .(, , )
        Lighting.OutdoorAmbient = .(, , )
    
        Lighting.Brightness     = OrigLight.Brightness
        Lighting.Ambient        = OrigLight.Ambient
        Lighting.OutdoorAmbient = OrigLight.OutdoorAmbient
    



 ChamsFolder = .()
ChamsFolder.Name   = 
ChamsFolder.Parent = 




  (kind, props)
     o = .(kind)
     k, v  (props)  o[k] = v 
     o





  ()
     (, {Visible=, Thickness=Cfg.Crosshair.Thick, Color=Cfg.Crosshair.Color})


  ()
     _, l  (CHLines)  l:() 
    CHLines = {}
     i = ,   CHLines[i] = () 





  ()
    Cfg.Player.FlyEnabled = 


  ()
    Cfg.Player.FlyEnabled = 
     char = LP.Character;   char   
     hum  = char:();   hum   
     hrp  = char:();   hrp   
    hum:(.HumanoidStateType.Freefall, )
    hum:(.HumanoidStateType.Jumping, )
    hum:(.HumanoidStateType.Freefall)
    hrp.AssemblyLinearVelocity = .zero


  ()
      Cfg.Player.FlyEnabled   
     char = LP.Character;   char   
     hrp  = char:();   hrp   
     hum  = char:();   hum   

    
    hum:(.HumanoidStateType.Freefall, )
    hum:(.HumanoidStateType.Jumping,  )
    hum:(.HumanoidStateType.Physics)

     cf  = Camera.CFrame
     dir = .zero
     UserInputService:(.KeyCode.W)            dir += cf.LookVector         
     UserInputService:(.KeyCode.S)            dir -= cf.LookVector         
     UserInputService:(.KeyCode.A)            dir -= cf.RightVector        
     UserInputService:(.KeyCode.D)            dir += cf.RightVector        
     UserInputService:(.KeyCode.Space)        dir += .(, , )  
     UserInputService:(.KeyCode.LeftControl)  dir -= .(, , )  
     dir.Magnitude >   dir = dir.Unit 

    hrp.AssemblyLinearVelocity = dir * Cfg.Player.FlySpeed


LP.CharacterAdded:(()
    .()
     Cfg.Player.FlyEnabled  () 
)




 Rayfield = (:())()

 Win = Rayfield:({
    Name            = ,
    LoadingTitle    = ,
    LoadingSubtitle = ,
    ConfigurationSaving = {
        Enabled    = ,
        FolderName = ,
        FileName   = ,
    },
    KeySystem = ,
})

 T_Combat  = Win:(,   )
 T_Visuals = Win:(,  )
 T_Effects = Win:(,  )
 T_Player  = Win:(,   )
 T_Misc    = Win:(,     )




T_Combat:()
T_Combat:({ Name=, CurrentValue=, Flag=,
    Callback=(v) Cfg.Aimbot.Enabled=v  })
T_Combat:({ Name=, CurrentValue=, Flag=,
    Callback=(v) Cfg.Aimbot.SilentAim=v  })
T_Combat:({ Name=, CurrentValue=, Flag=,
    Callback=(v) Cfg.Aimbot.Prediction=v  })
T_Combat:({ Name=, CurrentKeybind=,
    HoldToInteract=, Flag=, Callback=()  })
T_Combat:({ Name=, Range={,}, Increment=,
    Suffix=, CurrentValue=, Flag=,
    Callback=(v) Cfg.Aimbot.FOV=v;  FOVCircle  FOVCircle.Radius=v   })
T_Combat:({ Name=, Range={,}, Increment=,
    Suffix=, CurrentValue=, Flag=,
    Callback=(v) Cfg.Aimbot.Smooth=v  })
T_Combat:({ Name=, Range={,}, Increment=,
    Suffix=, CurrentValue=, Flag=,
    Callback=(v) Cfg.Aimbot.BulletSpeed=v  })
T_Combat:({ Name=,
    Options={,,,,},
    CurrentOption={}, Flag=,
    Callback=(v) Cfg.Aimbot.AimPart=v[]  })
T_Combat:({ Name=, CurrentValue=, Flag=,
    Callback=(v) Cfg.Aimbot.TeamCheck=v  })

T_Combat:()
T_Combat:({ Name=, CurrentValue=, Flag=,
    Callback=(v) Cfg.Triggerbot.Enabled=v  })
T_Combat:({ Name=, Range={,}, Increment=,
    Suffix=, CurrentValue=, Flag=,
    Callback=(v) Cfg.Triggerbot.Delay=v  })
T_Combat:({ Name=, CurrentValue=, Flag=,
    Callback=(v) Cfg.Triggerbot.TeamCheck=v  })

T_Combat:()
T_Combat:({ Name=, CurrentValue=, Flag=,
    Callback=(v) Cfg.Hitbox.Enabled=v  })
T_Combat:({ Name=, Range={,}, Increment=,
    Suffix=, CurrentValue=, Flag=,
    Callback=(v) Cfg.Hitbox.Size=v  })
T_Combat:()




T_Visuals:()
T_Visuals:({ Name=, CurrentValue=, Flag=,
    Callback=(v) Cfg.ESP.Enabled=v  })
T_Visuals:({ Name=, CurrentValue=, Flag=,
    Callback=(v) Cfg.ESP.Box=v  })
T_Visuals:({ Name=, CurrentValue=, Flag=,
    Callback=(v) Cfg.ESP.Name=v  })
T_Visuals:({ Name=, CurrentValue=, Flag=,
    Callback=(v) Cfg.ESP.Distance=v  })
T_Visuals:({ Name=, CurrentValue=, Flag=,
    Callback=(v) Cfg.ESP.TeamCheck=v  })
T_Visuals:({ Name=, Range={,},
    Increment=, Suffix=, CurrentValue=, Flag=,
    Callback=(v) Cfg.ESP.MaxDist=v  })
T_Visuals:({ Name=,
    Color=.(,,), Flag=,
    Callback=(v) Cfg.ESP.EnemyColor=v  })

T_Visuals:()
T_Visuals:({ Name=, CurrentValue=, Flag=,
    Callback=(v) Cfg.ESP.Tracer=v  })
T_Visuals:({ Name=, CurrentValue=, Flag=,
    Callback=(v) Cfg.ESP.HealthBar=v  })
T_Visuals:({ Name=, CurrentValue=, Flag=,
    Callback=(v) Cfg.ESP.Skeleton=v  })
T_Visuals:({ Name=, CurrentValue=, Flag=,
    Callback=(v)
        Cfg.Visual.Chams=v
         _,h  (ChamsPool)  h.Enabled=v 
     })
T_Visuals:({ Name=,
    Color=.(,,), Flag=,
    Callback=(v)
        Cfg.Visual.ChamsColor=v
         _,h  (ChamsPool)  h.FillColor=v 
     })

T_Visuals:()
T_Visuals:({ Name=, CurrentValue=, Flag=,
    Callback=(v) Cfg.Crosshair.Enabled=v  })
T_Visuals:({ Name=, Range={,}, Increment=,
    Suffix=, CurrentValue=, Flag=,
    Callback=(v) Cfg.Crosshair.Size=v; ()  })
T_Visuals:({ Name=, Range={,}, Increment=,
    Suffix=, CurrentValue=, Flag=,
    Callback=(v) Cfg.Crosshair.Gap=v; ()  })
T_Visuals:({ Name=, Range={,}, Increment=,
    Suffix=, CurrentValue=, Flag=,
    Callback=(v) Cfg.Crosshair.Thick=v; ()  })
T_Visuals:({ Name=,
    Color=.(,,), Flag=,
    Callback=(v) Cfg.Crosshair.Color=v; ()  })

T_Visuals:()
T_Visuals:({ Name=, CurrentValue=, Flag=,
    Callback=(v)
        Cfg.FOVChanger.Enabled=v
          v  Camera.FieldOfView= 
     })
T_Visuals:({ Name=, Range={,}, Increment=,
    Suffix=, CurrentValue=, Flag=,
    Callback=(v)
        Cfg.FOVChanger.Value=v
         Cfg.FOVChanger.Enabled  Camera.FieldOfView=v 
     })

T_Visuals:()
T_Visuals:({ Name=, CurrentValue=, Flag=,
    Callback=(v)
        Cfg.Visual.Radar=v
         RadarBG  RadarBG.Visible=v 
         RadarBorder  RadarBorder.Visible=v 
         RadarCenter  RadarCenter.Visible=v 
     })
T_Visuals:({ Name=, Range={,}, Increment=,
    Suffix=, CurrentValue=, Flag=,
    Callback=(v) Cfg.Visual.RadarScale=v/  })




T_Effects:()
T_Effects:({ Name=, CurrentValue=, Flag=,
    Callback=(v) Cfg.Visual.RainbowESP=v  })
T_Effects:({ Name=, CurrentValue=, Flag=,
    Callback=(v)
        Cfg.Visual.RainbowWorld=v
          v 
            Lighting.Ambient=OrigLight.Ambient
            Lighting.OutdoorAmbient=OrigLight.OutdoorAmbient
        
     })
T_Effects:({ Name=, CurrentValue=, Flag=,
    Callback=(v)
        Cfg.Visual.RainbowGUI=v
          v   _,l  (RainbowBorder)  l.Visible=  
     })
T_Effects:({ Name=, Range={,}, Increment=,
    Suffix=, CurrentValue=, Flag=,
    Callback=(v) Cfg.Visual.RainbowSpeed=v  })

T_Effects:()
T_Effects:({ Name=, CurrentValue=, Flag=,
    Callback=(v)
        Cfg.Visual.Fullbright=v
        (v)
     })

T_Effects:()
T_Effects:({ Name=,
    Color=.(,,), Flag=,
    Callback=(v)
          Cfg.Visual.RainbowWorld   Cfg.Visual.Fullbright 
            Lighting.Ambient=v
        
     })




T_Player:()
T_Player:({ Name=, CurrentValue=, Flag=,
    Callback=(v)
         v  ()  () 
     })
T_Player:({ Name=, Range={,}, Increment=,
    Suffix=, CurrentValue=, Flag=,
    Callback=(v) Cfg.Player.FlySpeed=v  })

T_Player:()
T_Player:({ Name=, CurrentValue=, Flag=,
    Callback=(v) Cfg.Player.InfJump=v  })
T_Player:({ Name=, Range={,}, Increment=,
    Suffix=, CurrentValue=, Flag=,
    Callback=(v)
        Cfg.Player.JumpPower=v
         char=LP.Character
         char 
             hum=char:()
             hum  hum.JumpPower=v 
        
     })
T_Player:({ Name=, CurrentValue=, Flag=,
    Callback=(v) Cfg.Player.AntiFall=v  })
T_Player:({ Name=, CurrentValue=, Flag=,
    Callback=(v) Cfg.Player.NoclipEnabled=v  })




T_Misc:()
T_Misc:({ Name=,
    Callback=()
        Rayfield:({
            Title   = ,
            Content = .(
                ,
                Cfg.Aimbot.Enabled ,
                Cfg.Aimbot.SilentAim ,
                Cfg.Triggerbot.Enabled ,
                Cfg.Player.FlyEnabled ,
                Cfg.ESP.Enabled ,
                Cfg.Visual.Chams 
            ),
            Duration=, Image=,
        })
     })
T_Misc:({ Name=,
    Callback=()
        Cfg.Visual.Fullbright=
        Cfg.Visual.RainbowWorld=
        ()
        Rayfield:({Title=,Content=,Duration=})
     })
T_Misc:({ Name=,
    Callback=()
        Cfg.Player.JumpPower=
         char=LP.Character
         char 
             hum=char:()
             hum  hum.JumpPower= 
        
     })
T_Misc:()
T_Misc:()
T_Misc:()




FOVCircle = (, {
    Visible=, Radius=Cfg.Aimbot.FOV,
    Color=.(,,), Thickness=, Filled=,
})

()


 i = ,  
    RainbowBorder[i] = (, {
        Visible=, Thickness=, Color=.(,,),
    })



 RW, RH = , 
RadarBG = (, {
    Visible=, Filled=, Thickness=,
    Color=.(,,),
    Position=.(,), Size=.(RW,RH),
})
RadarBorder = (, {
    Visible=, Filled=, Thickness=,
    Color=.(,,),
    Position=.(,), Size=.(RW,RH),
})
RadarCenter = (, {
    Visible=, Filled=, Radius=,
    Color=.(,,), Thickness=,
})




  (p)
     skelLines = {}
     i = ,  
        skelLines[i] = (, {
            Visible=, Thickness=, Color=Cfg.ESP.EnemyColor,
        })
    
    Pool[p] = {
        Box      = (,{Visible=,Thickness=,Filled=,Color=Cfg.ESP.EnemyColor}),
        Name     = (,  {Visible=,Size=,Center=,Outline=,Color=.(,,)}),
        Dist     = (,  {Visible=,Size=,Center=,Outline=,Color=.(,,)}),
        Tracer   = (,  {Visible=,Thickness=,Color=Cfg.ESP.EnemyColor}),
        HealthBG = (,{Visible=,Filled=,Thickness=,Color=.(,,)}),
        HealthBar= (,{Visible=,Filled=,Thickness=,Color=.(,,)}),
        SkelLines= skelLines,
    }


  (p)
     Pool[p] 
         _, o  (Pool[p]) 
             (o) ==  
                 _, l  (o)  l:() 
            
                o:()
            
        
        Pool[p] = 
    


 _, p  (Players:())   p ~= LP  (p)  
Players.PlayerAdded:((p)    p ~= LP  (p)  )
Players.PlayerRemoving:(KillESP)




  (p)
     ChamsPool[p]   
     char = p.Character;   char   
     h              = .()
    h.Adornee            = char
    h.FillColor          = Cfg.Visual.ChamsColor
    h.OutlineColor       = .(, , )
    h.FillTransparency   = 
    h.OutlineTransparency = 
    h.Enabled            = Cfg.Visual.Chams
    h.Parent             = ChamsFolder
    ChamsPool[p]         = h


  (p)
     ChamsPool[p] 
        ChamsPool[p]:()
        ChamsPool[p] = 
    


 _, p  (Players:())   p ~= LP  (p)  
Players.PlayerAdded:((p)
    .()
     p ~= LP  (p) 
)
Players.PlayerRemoving:(KillChams)




  (p)
    RadarDots[p] = (, {
        Visible=, Filled=, Radius=,
        Color=Cfg.ESP.EnemyColor, Thickness=,
    })


  (p)
     RadarDots[p]  RadarDots[p]:(); RadarDots[p]= 


 _, p  (Players:())   p ~= LP  (p)  
Players.PlayerAdded:((p)    p ~= LP  (p)  )
Players.PlayerRemoving:(KillRadarDot)




UserInputService.JumpRequest:(()
      Cfg.Player.InfJump   
     char = LP.Character;   char   
     hum  = char:()
     hum  hum:() ~= .HumanoidStateType.Dead 
        hum:(.HumanoidStateType.Jumping)
    
)




RunService.Stepped:(()
      Cfg.Player.NoclipEnabled   
     char = LP.Character;   char   
     _, p  (char:()) 
         p:()  p.CanCollide =  
    
)




  (part)
     hrp = part.Parent  part.Parent:()
      hrp   part.Position 
     myHRP = LP.Character  LP.Character:()
      myHRP   part.Position 
     travelTime = (part.Position - myHRP.Position).Magnitude / Cfg.Aimbot.BulletSpeed
     part.Position + hrp.AssemblyLinearVelocity * travelTime


  ()
     ctr = .(Camera.ViewportSize.X/, Camera.ViewportSize.Y/)
     best, bestD = , Cfg.Aimbot.FOV
     _, p  (Players:()) 
         p == LP   
         Cfg.Aimbot.TeamCheck  p.Team == LP.Team   
         char = p.Character;   char   
         part = char:(Cfg.Aimbot.AimPart);   part   
         aimPos = Cfg.Aimbot.Prediction  (part)  part.Position
         sp, vis = Camera:(aimPos)
          vis   
         d = (.(sp.X, sp.Y) - ctr).Magnitude
         d < bestD  bestD=d; best={part=part, pos=aimPos} 
    
     best


  ()
     t = Mouse.Target;   t    
     parent = t.Parent
     _, p  (Players:()) 
         p == LP   
         Cfg.Triggerbot.TeamCheck  p.Team == LP.Team   
         p.Character == parent  p.Character == parent.Parent    
    
     


  ()
      Cfg.Hitbox.Enabled   
     _, p  (Players:()) 
         p == LP   
         char = p.Character;   char   
         hrp  = char:();   hrp   
        hrp.Size         = .(Cfg.Hitbox.Size, Cfg.Hitbox.Size, Cfg.Hitbox.Size)
        hrp.Transparency = 
    





RunService.RenderStepped:((dt)
     vp     = Camera.ViewportSize
     center = .(vp.X / , vp.Y / )

    
    RainbowHue = (RainbowHue + dt *  * Cfg.Visual.RainbowSpeed) % 
     rainbowColor = .(RainbowHue, , )

    
    FOVCircle.Position = center
    FOVCircle.Visible  = Cfg.Aimbot.Enabled  Cfg.Aimbot.SilentAim

    
     Cfg.FOVChanger.Enabled  Camera.FieldOfView = Cfg.FOVChanger.Value 

    
     Cfg.Visual.RainbowWorld   Cfg.Visual.Fullbright 
        Lighting.Ambient        = .(RainbowHue, , )
        Lighting.OutdoorAmbient = .((RainbowHue + ) % , , )
    

    
     Cfg.Visual.RainbowGUI 
         c0 = .(RainbowHue, , )
         c1 = .((RainbowHue+)%, , )
         c2 = .((RainbowHue+)%, , )
         c3 = .((RainbowHue+)%, , )
        
        RainbowBorder[].Visible=; RainbowBorder[].Color=c0
        RainbowBorder[].From=.(,); RainbowBorder[].To=.(vp.X,)
        
        RainbowBorder[].Visible=; RainbowBorder[].Color=c1
        RainbowBorder[].From=.(vp.X,); RainbowBorder[].To=.(vp.X,vp.Y)
        
        RainbowBorder[].Visible=; RainbowBorder[].Color=c2
        RainbowBorder[].From=.(vp.X,vp.Y); RainbowBorder[].To=.(,vp.Y)
        
        RainbowBorder[].Visible=; RainbowBorder[].Color=c3
        RainbowBorder[].From=.(,vp.Y); RainbowBorder[].To=.(,)
    
         _, l  (RainbowBorder)  l.Visible= 
    

    
     _, p  (Players:()) 
         p == LP   
         h = ChamsPool[p]
          h  (p);  
         p.Character  h.Adornee ~= p.Character 
            h.Adornee = p.Character
        
        h.Enabled   = Cfg.Visual.Chams  ( Cfg.ESP.TeamCheck  p.Team ~= LP.Team)
        h.FillColor = Cfg.Visual.RainbowESP  rainbowColor  Cfg.Visual.ChamsColor
    

    
     espColor = Cfg.Visual.RainbowESP  rainbowColor  Cfg.ESP.EnemyColor

     _, p  (Players:()) 
         p == LP   
         esp  = Pool[p];   esp   
         char = p.Character

          ()
            esp.Box.Visible      = 
            esp.Name.Visible     = 
            esp.Dist.Visible     = 
            esp.Tracer.Visible   = 
            esp.HealthBG.Visible = 
            esp.HealthBar.Visible= 
             _, l  (esp.SkelLines)  l.Visible= 
        

          char   Cfg.ESP.Enabled           ();  
         Cfg.ESP.TeamCheck  p.Team == LP.Team   ();  

         root = char:()
         head = char:()
          root   head  ();  

         myRoot = LP.Character  LP.Character:()
          myRoot  ();  

         dist3D = (root.Position - myRoot.Position).Magnitude
         dist3D > Cfg.ESP.MaxDist  ();  

         top, topV = Camera:(head.Position + .(, , ))
         bot, botV = Camera:(root.Position - .(, , ))
          (topV  botV)  ();  

         h  = .(bot.Y - top.Y)
         w  = h * 

        
        esp.Box.Visible   = Cfg.ESP.Box
        esp.Box.Color     = espColor
        esp.Box.Size      = .(w, h)
        esp.Box.Position  = .(top.X - w/, top.Y)

        
        esp.Name.Visible  = Cfg.ESP.Name
        esp.Name.Color    = espColor
        esp.Name.Text     = p.DisplayName
        esp.Name.Position = .(top.X, top.Y - )

        
        esp.Dist.Visible  = Cfg.ESP.Distance
        esp.Dist.Text     = .(, .(dist3D/))
        esp.Dist.Position = .(bot.X, bot.Y + )

        
        esp.Tracer.Visible = Cfg.ESP.Tracer
        esp.Tracer.Color   = espColor
        esp.Tracer.From    = .(center.X, vp.Y)
        esp.Tracer.To      = .(bot.X, bot.Y)

        
         hum = char:()
         hp  = hum  (hum.Health / .(hum.MaxHealth, ))  
         hpColor = .(hp * , , )
         barX = top.X - w/ - 

        esp.HealthBG.Visible  = Cfg.ESP.HealthBar
        esp.HealthBG.Position = .(barX, top.Y)
        esp.HealthBG.Size     = .(, h)

        esp.HealthBar.Visible  = Cfg.ESP.HealthBar
        esp.HealthBar.Color    = hpColor
        esp.HealthBar.Size     = .(, h * hp)
        esp.HealthBar.Position = .(barX, top.Y + h * ( - hp))

        
         _, l  (esp.SkelLines)  l.Visible= 
         Cfg.ESP.Skeleton 
             boneSet = char:()  R15_BONES  R6_BONES
             i, pair  (boneSet) 
                 a = char:(pair[])
                 b = char:(pair[])
                 sl = esp.SkelLines[i];   sl   
                 a  b 
                     ap, avis = Camera:(a.Position)
                     bp, bvis = Camera:(b.Position)
                     avis  bvis 
                        sl.Visible = 
                        sl.Color   = espColor
                        sl.From    = .(ap.X, ap.Y)
                        sl.To      = .(bp.X, bp.Y)
                    
                        sl.Visible = 
                    
                
                    sl.Visible = 
                
            
        
    

    
     rpX = vp.X - RW - 
     rpY = vp.Y - RH - 
     rCX = rpX + RW / 
     rCY = rpY + RH / 

    RadarBG.Visible     = Cfg.Visual.Radar
    RadarBorder.Visible = Cfg.Visual.Radar
    RadarCenter.Visible = Cfg.Visual.Radar

     Cfg.Visual.Radar 
        RadarBG.Position     = .(rpX, rpY)
        RadarBG.Size         = .(RW, RH)
        RadarBorder.Position = .(rpX, rpY)
        RadarBorder.Size     = .(RW, RH)
        RadarCenter.Position = .(rCX, rCY)

         myHRP  = LP.Character  LP.Character:()
         camYaw = .(-Camera.CFrame.LookVector.X, -Camera.CFrame.LookVector.Z)

         _, p  (Players:()) 
             p == LP   
             rdot = RadarDots[p];   rdot   
             Cfg.ESP.TeamCheck  p.Team == LP.Team  rdot.Visible=;  
             pChar = p.Character
             pHRP  = pChar  pChar:()
              pHRP   myHRP  rdot.Visible=;  

             rel  = pHRP.Position - myHRP.Position
             rx   = rel.X * .(camYaw) - rel.Z * .(camYaw)
             rz   = rel.X * .(camYaw) + rel.Z * .(camYaw)
             px   = rx * Cfg.Visual.RadarScale
             pz   = rz * Cfg.Visual.RadarScale
             maxR = .(RW, RH) /  - 
             mag  = .(px*px + pz*pz)
             mag > maxR  px=px/mag*maxR; pz=pz/mag*maxR 

            rdot.Visible  = 
            rdot.Color    = espColor
            rdot.Position = .(rCX + px, rCY + pz)
        
    
         _, dot  (RadarDots)  dot.Visible= 
    

    
     target = ()
     Cfg.Aimbot.Enabled  UserInputService:(Cfg.Aimbot.HoldKey)  target 
         cf   = Camera.CFrame
         dest = .(cf.Position, target.pos)
        Camera.CFrame = cf:(dest, Cfg.Aimbot.Smooth / )
    

    
     Cfg.Aimbot.SilentAim  target 
         UserInputService:(.UserInputType.MouseButton1) 
             savedCF = Camera.CFrame
            Camera.CFrame = .(savedCF.Position, target.pos)
            .(() Camera.CFrame = savedCF )
        
    

    
    TriggerTimer = TriggerTimer + dt * 
     Cfg.Triggerbot.Enabled  ()
     TriggerTimer >= Cfg.Triggerbot.Delay   TriggerDebounce 
        TriggerDebounce = 
        TriggerTimer    = 
        ()
        .(, ()
            ()
            TriggerDebounce = 
        )
    

    
    ()

    
     CHLines[] 
         s  = Cfg.Crosshair.Size
         g  = Cfg.Crosshair.Gap
         cc = Cfg.Visual.RainbowESP  rainbowColor  Cfg.Crosshair.Color
         cx, cy = center.X, center.Y
        CHLines[].Visible=Cfg.Crosshair.Enabled; CHLines[].Color=cc
        CHLines[].From=.(cx,cy-g);     CHLines[].To=.(cx,cy-g-s)
        CHLines[].Visible=Cfg.Crosshair.Enabled; CHLines[].Color=cc
        CHLines[].From=.(cx,cy+g);     CHLines[].To=.(cx,cy+g+s)
        CHLines[].Visible=Cfg.Crosshair.Enabled; CHLines[].Color=cc
        CHLines[].From=.(cx-g,cy);     CHLines[].To=.(cx-g-s,cy)
        CHLines[].Visible=Cfg.Crosshair.Enabled; CHLines[].Color=cc
        CHLines[].From=.(cx+g,cy);     CHLines[].To=.(cx+g+s,cy)
    

    
    ()

    
     char = LP.Character
     char 
         hum = char:()
         hum 
              Cfg.Player.FlyEnabled 
                hum.JumpPower = Cfg.Player.JumpPower
            
             Cfg.Player.AntiFall 
                hum:(.HumanoidStateType.FallingDown, )
            
        
    
)




.()
Rayfield:({
    Title    = ,
    Content  = ,
    Duration = ,
    Image    = ,
})