kill aura

().vars = ().vars  {
    Enabled = ,
    MaxDistance = ,
    ESPEnabled = ,
}

().Main = ().Main  {
    connections = {},
    services = {
        RunService = :(),
        Players = :(),
        ReplicatedStorage = :(),
        TweenService = :(),
        HttpService = :(),
        UserInputService = :(),
        ContextActionService = :(),
        PathfindingService = :(),
        TeleportService = :(),
        Lighting = :(),
        Workspace = :(),
        StarterGui = :(),
        StarterPack = :(),
        StarterPlayer = :(),
        SoundService = :(),
        CollectionService = :(),
        Debris = :(),
        Stats = :(),
        GuiService = :(),
        MarketplaceService = :(),
        InsertService = :(),
        PolicyService = :(),
        TextService = :(),
        VirtualInputManager = :(),
        ProximityPromptService = :(),
        Teams = :(),
        BadgeService = :(),
        AnalyticsService = :(),
    }
}


 i,v  ,().Main.connections 
    v:()
    (,i,v)

().Main.connections = {}

 Services = ().Main.services
 Players = Services.Players
 RunService = Services.RunService
 Teams = Services.Teams

 vars = ().vars
 lp = Players.LocalPlayer


 currentTarget = 
 currentHighlight = 

  ()
     currentHighlight 
        currentHighlight:()
        currentHighlight = 
    


  (player)
     player == currentTarget   

    currentTarget = player
    ()

      vars.ESPEnabled   
      player   player.Character   

     char = player.Character
     highlight = .()
    highlight.Name = 
    highlight.Adornee = char
    highlight.DepthMode = .HighlightDepthMode.AlwaysOnTop
    highlight.FillTransparency = 
    highlight.OutlineTransparency = 
    highlight.Parent = char

    currentHighlight = highlight


  (p)
     p == lp    
      p.Character    
     hrp = p.Character:()
     hum = p.Character:()
      hrp   hum  hum.Health <=     

     Teams  lp.Team  p.Team  p.Team == lp.Team 
         
    

     


  (maxDistance)
     char = lp.Character
      char    
     hrp = char:()
      hrp    

     closestPlayer = 
     closestDist = 

     _, plr  , Players:() 
         (plr) 
             thrp = plr.Character  plr.Character:()
             thrp 
                 dist = (hrp.Position - thrp.Position).Magnitude
                 dist <= maxDistance  ( closestDist  dist < closestDist) 
                    closestDist = dist
                    closestPlayer = plr
                
            
        
    

     closestPlayer


  ()
     char = lp.Character
      char    
     vamp = char:()
      vamp    
     remote = vamp:()
     remote


  ()
     char = lp.Character  lp.CharacterAdded:()
     vamp = char:()
     remote = vamp:()

     initArgs = {,,}
     _,v  , initArgs 
        remote:(v)
    



 Rayfield = (:())()

 Window = Rayfield:({
    Name = ,
    LoadingTitle = ,
    LoadingSubtitle = ,
    Theme = ,
    DisableRayfieldPrompts = ,
    DisableBuildWarnings = ,
    ConfigurationSaving = {
        Enabled = ,
        FolderName = ,
        FileName = 
    },
    KeySystem = ,
    KeySettings = {
        Title = ,
        Subtitle = ,
        Note = ,
        FileName = ,
        SaveKey = ,
        GrabKeyFromSite = ,
        Key = {}
    }
})

 CombatTab = Window:(, )
CombatTab:()


CombatTab:({
    Name = ,
    CurrentValue = vars.Enabled,
    Flag = ,
    Callback = (Value)
        vars.Enabled = Value
         Value 
            .(()
                (VampireInit)
            )
        
            ()
        
    ,
})


CombatTab:({
    Name = ,
    Range = {, },
    Increment = ,
    Suffix = ,
    CurrentValue = vars.MaxDistance,
    Flag = ,
    Callback = (Value)
        vars.MaxDistance = Value
    ,
})


CombatTab:({
    Name = ,
    CurrentValue = vars.ESPEnabled,
    Flag = ,
    Callback = (Value)
        vars.ESPEnabled = Value
          Value 
            ()
         currentTarget 
            (currentTarget)
        
    ,
})


 hbConn = RunService.Heartbeat:(()
      vars.Enabled 
        
        ()
        
    

     char = lp.Character
      char   
     hrp = char:()
      hrp   

     remote = ()
      remote   

     target = (vars.MaxDistance  )
    (target)

     target  target.Character  target.Character:() 
     args = {;;;}
 i,v  ,args  
:().LocalPlayer.Character:():():(v)

         args = {
            ,
            {
                hit = target.Character.HumanoidRootPart
            }
        }
        remote:((args))
    
)

.(().Main.connections, hbConn)