auto block forsaken

 ReplicatedStorage = :()
 TweenService = :()
 RunService = :()
 Players = :()
 lp = Players.LocalPlayer
 PlayerGui = lp:()
 Humanoid, Animator
 StarterGui  = :()
 TestService = :()
 ChatEvents = ReplicatedStorage:()
 SayMessageRequest = ChatEvents  ChatEvents:()
 testRemote = ReplicatedStorage:():():()




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


 NoticeTab = Window:(, )
 AutoBlockTab = Window:(, )
 BDTab = Window:(, )
 TechTab = Window:(, )
 PredictiveTab = Window:(, )
 FakeBlockTab = Window:(, )
 AutoPunchTab = Window:(, )
 CustomAnimationsTab = Window:(, )
 MiscTab = Window:(, )




 autoBlockTriggerSounds = {
    [] = ,
    [] = ,
    [] = ,
    [] = ,
    [] = ,
    [] = ,
    [] = ,
    [] = ,
    [] = ,
    [] = ,
    [] = ,
    [] = ,
    [] = ,
    [] = ,
    [] = ,
    [] = ,
    [] = ,
    [] = ,
    [] = ,
    [] = ,
    [] = ,
    [] = ,
    [] = ,
    [] = ,
    [] = ,
    [] = ,
    [] = ,
    [] = ,
    [] = ,
    [] = ,
    [] = ,
    [] = ,
    [] = ,
    [] = ,
    [] = ,
    [] = ,
    [] = ,
    [] = ,
    [] = ,
    [] = ,
}


 lastAimTrigger = {}   
 AIM_WINDOW =       
 AIM_COOLDOWN =     


 _lastPunchMessageTime = _lastPunchMessageTime  
 MESSAGE_PUNCH_COOLDOWN =  
 _punchPrevPlaying = _punchPrevPlaying  {} 

 _lastBlockMessageTime = _lastBlockMessageTime  
 MESSAGE_BLOCK_COOLDOWN =  
 _blockPrevPlaying = _blockPrevPlaying  {} 


 autoBlockTriggerAnims = {
    , , , ,
    , , , ,
    , , , ,
    , , , ,
    , , , ,
    , ,
    
}


 autoBlockOn = 
 autoBlockAudioOn = 

 doubleblocktech = 
 blockdelay = 
 looseFacing = 
 detectionRange = 
 messageWhenAutoBlockOn = 
 messageWhenAutoBlock = 

 Debris = :()

 antiFlickOn = 

 antiFlickParts = 


 antiFlickBaseOffset = 


 antiFlickOffsetStep = 

 antiFlickDelay =  
 PRED_SECONDS_FORWARD =    
 PRED_SECONDS_LATERAL  =   
 PRED_MAX_FORWARD      =      
 PRED_MAX_LATERAL      =      
 ANG_TURN_MULTIPLIER   =    
 SMOOTHING_LERP        =   

 killerState = {} 



 predictionStrength =         
 predictionTurnStrength =     

 blockPartsSizeMultiplier = 

 autoAdjustDBTFBPS = 
 _savedManualAntiFlickDelay = antiFlickDelay   


 killerDelayMap = {
    [] = ,
    []    = ,
    []  = ,
    []  = ,
    []  = ,
    []     = ,
}

 predictiveBlockOn = 
 edgeKillerDelay = 
 killerInRangeSince = 
 predictiveCooldown = 

 Dspeed =  
 Ddelay = 

 killerNames = {, , , , , , }
 autoPunchOn = 
 messageWhenAutoPunchOn = 
 messageWhenAutoPunch = 
 flingPunchOn = 
 flingPower = 
 hiddenfling = 
 aimPunch = 

 customBlockEnabled = 
 customBlockAnimId = 
 customblockdelay = 
 customPunchEnabled = 
 customPunchAnimId = 
 custompunchdelay = 

 espEnabled = 
 KillersFolder = :():()

 lastBlockTime = 
 lastPunchTime = 


 blockAnimIds = {
,
,

}
 punchAnimIds = {
,
,
,
,
,
,
,
,
,
,
,
,
,

}

 chargeAnimIds = {
    
}

 customChargeEnabled = 
 customChargeAnimId = 
 chargeAnimIds = {  }


 cachedAnimator = 
  ()
     char = lp.Character
      char 
        cachedAnimator = 
        
    
     hum = char:()
     hum 
         anim = hum:()
        cachedAnimator = anim  
    
        cachedAnimator = 
    


lp.CharacterAdded:((char)
    .() 
    ()
)



 cachedPlayerGui = PlayerGui
 cachedPunchBtn, cachedBlockBtn, cachedCharges, cachedCooldown, cachedChargeBtn, cachedCloneBtn = , , , , , 
 detectionRangeSq = detectionRange * detectionRange

  ()
    
    cachedPlayerGui = lp:()  PlayerGui
     main = cachedPlayerGui  cachedPlayerGui:()
     main 
         ability = main:()
        cachedPunchBtn = ability  ability:()
        cachedBlockBtn = ability  ability:()
        cachedChargeBtn = ability  ability:()
        cachedCloneBtn = ability  ability:()
        cachedCharges = cachedPunchBtn  cachedPunchBtn:()
        cachedCooldown = cachedBlockBtn  cachedBlockBtn:()
    
        cachedPunchBtn, cachedBlockBtn, cachedCharges, cachedCooldown, cachedChargeBtn, cachedCloneBtn = , , , , , 
    



()


 cachedPlayerGui 
    cachedPlayerGui.ChildAdded:((child)
         child.Name ==  
            .(, refreshUIRefs)
        
    )


lp.CharacterAdded:(()
    .(, refreshUIRefs)
)

NoticeTab:({
    Title = ,
    Content = 
})

NoticeTab:({
    Title = ,
    Content = 
})

NoticeTab:({
    Title = ,
    Content = 
})


AutoBlockTab:({
Name = ,
CurrentValue = ,
Flag = ,
Callback = (Value) autoBlockOn = Value 
})


AutoBlockTab:({
    Name = ,
    CurrentValue = ,
    Flag = ,
    Callback = (state)
        autoBlockAudioOn = state
    ,
})


 autoblocktype = 

 StarterGui = :()


  (title, text, duration)
    StarterGui:(, {
        Title = title  ,
        Text = text  ,
        Duration = duration   
    })


AutoBlockTab:({
    Name = ,
    Callback = ()
         autoblocktype ==  
            autoblocktype = 
            (, , )
         autoblocktype ==  
            autoblocktype = 
            (, , )
         autoblocktype ==  
            autoblocktype = 
            (, , )
        
    ,
})










AutoBlockTab:({
    Title = ,
    Content = 
})

AutoBlockTab:({
Name = ,
CurrentValue = ,
Flag = ,
Callback = (Value) messageWhenAutoBlockOn = Value 
})

AutoBlockTab:({
Name = ,
PlaceholderText = ,
RemoveTextAfterFocusLost = ,
Flag = ,
Callback = (Text)
blockdelay = (Text)  blockdelay

})

AutoBlockTab:({
    Name = ,
    PlaceholderText = ,
    RemoveTextAfterFocusLost = ,
    Flag = ,
    Callback = (Text) messageWhenAutoBlock = Text 
})

AutoBlockTab:({
    Title = ,
    Content = 
})

 facingCheckEnabled = 
 customFacingDot = -

AutoBlockTab:({
    Name = ,
    CurrentValue = ,
    Flag = ,
    Callback = (Value)
        facingCheckEnabled = Value
    
})



  (localRoot, targetRoot)
      facingCheckEnabled 
         
    

     dir = (localRoot.Position - targetRoot.Position).Unit
     dot = targetRoot.CFrame.LookVector:(dir)
     looseFacing  dot > customFacingDot



  (localRoot, targetRoot)
    
     enabled = facingCheckEnabled
      enabled    

     loose = looseFacing

    
     dx = localRoot.Position.X - targetRoot.Position.X
     dy = localRoot.Position.Y - targetRoot.Position.Y
     dz = localRoot.Position.Z - targetRoot.Position.Z

    
     mag = .(dx*dx + dy*dy + dz*dz)
     mag ==  
        
         
    
     invMag =  / mag

    
     ux, uy, uz = dx * invMag, dy * invMag, dz * invMag

    
     lv = targetRoot.CFrame.LookVector
     lx, ly, lz = lv.X, lv.Y, lv.Z

    
     dot = lx * ux + ly * uy + lz * uz

    
     dot > (customFacingDot  -)



 facingVisualOn = 
 facingVisuals = {} 

  (killer, visual)
      (killer  visual  visual.Parent)   
     hrp = killer:()
      hrp   

    
     dot = .(customFacingDot  -, -, )
     angle = .(dot)              
     frac = angle / .pi              

    
     minFrac =                       
     radius = .(, detectionRange * (minFrac + ( - minFrac) * frac))
    visual.Radius = radius
    visual.Height = 

    
     forwardDist = detectionRange * ( +  * frac) 
     yOffset = -(hrp.Size.Y /  + )
    visual.CFrame = .(, yOffset, -forwardDist) * .(.(), , )

    
     myRoot = lp.Character  lp.Character:()
     inRange = 
     facingOkay = 

     myRoot  hrp 
         dist = (hrp.Position - myRoot.Position).Magnitude
        inRange = dist <= detectionRange
        facingOkay = ( facingCheckEnabled)  ((isFacing) ==   (myRoot, hrp))
    

    
     inRange  facingOkay 
        visual.Color3 = .(, , )
        visual.Transparency = 
    
        visual.Color3 = .(, , ) 
        visual.Transparency = 
    


  (killer)
      killer   killer:()   
     facingVisuals[killer]   
     hrp = killer:()
      hrp   

     visual = .()
    visual.Name = 
    visual.Adornee = hrp
    visual.AlwaysOnTop = 
    visual.ZIndex = 
    visual.Transparency = 
    visual.Color3 = .(, , ) 

    visual.Parent = hrp
    facingVisuals[killer] = visual

    
    (killer, visual)


  (killer)
     v = facingVisuals[killer]
     v 
        v:()
        facingVisuals[killer] = 
    


  ()
     _, k  (KillersFolder:()) 
         facingVisualOn 
            
             hrp = k:()  k:(, )
             hrp  (k) 
        
            (k)
        
    



RunService.RenderStepped:(()
     killer, visual  (facingVisuals) 
        
          killer.Parent   killer:() 
            (killer)
        
            (killer, visual)
        
    
)


KillersFolder.ChildAdded:((killer)
     facingVisualOn 
        .(()
             hrp = killer:(, )
             hrp  (killer) 
        )
    
)
KillersFolder.ChildRemoved:((killer) (killer) )


AutoBlockTab:({
    Name = ,
    CurrentValue = ,
    Flag = ,
    Callback = (state)
        facingVisualOn = state
        ()
    
})

AutoBlockTab:({
    Title = ,
    Content = 
})

AutoBlockTab:({
Name = ,
PlaceholderText = ,
RemoveTextAfterFocusLost = ,
Flag = ,
Callback = (Text)
customFacingDot = (Text)  customFacingDot

})

AutoBlockTab:({
    Title = ,
    Content = 
})

AutoBlockTab:({
Name = ,
PlaceholderText = ,
RemoveTextAfterFocusLost = ,
Flag = ,
Callback = (Text)
detectionRange = (Text)  detectionRange
detectionRangeSq = detectionRange * detectionRange

})



 detectionCircles = {} 
 killerCirclesVisible = 



  (killer)
      killer:()   
     detectionCircles[killer]   

     hrp = killer.HumanoidRootPart
     circle = .()
    circle.Name = 
    circle.Adornee = hrp
    circle.Color3 = .(, , )
    circle.AlwaysOnTop = 
    circle.ZIndex = 
    circle.Transparency = 
    circle.Radius = detectionRange            
    circle.Height =                       
    
     yOffset = -(hrp.Size.Y /  + )  
    circle.CFrame = .(, yOffset, ) * .(.(), , )
    circle.Parent = hrp

    detectionCircles[killer] = circle






  (killer)
     detectionCircles[killer] 
        detectionCircles[killer]:()
        detectionCircles[killer] = 
    



  ()
     _, killer  (KillersFolder:()) 
         killerCirclesVisible 
            (killer)
        
            (killer)
        
    



RunService.RenderStepped:(()
     killer, circle  (detectionCircles) 
         circle  circle.Parent 
            circle.Radius = detectionRange
        
    
)


KillersFolder.ChildAdded:((killer)
     killerCirclesVisible 
        .(()
            
             hrp = killer:(, )
             hrp 
                (killer)
            
        )
    
)

KillersFolder.ChildRemoved:((killer)
    (killer)
)


AutoBlockTab:({
    Name = ,
    CurrentValue = ,
    Flag = ,
    Callback = (state)
        killerCirclesVisible = state
        ()
    
})

BDTab:({
    Title = ,
    Content = 
})

BDTab:({
    Name = ,
    CurrentValue = ,
    Flag = ,
    Callback = (state)
        antiFlickOn = state
    ,
})

BDTab:({
    Name = ,
    Range = {, },       
    Increment = ,         
    Suffix = ,
    CurrentValue = ,      
    Flag = ,
    Callback = (val)
        antiFlickParts = .(, .(val))
    ,
})

BDTab:({
    Name = ,
    Range = {, },      
    Increment = ,
    Suffix = ,
    CurrentValue = ,      
    Flag = ,
    Callback = (val)
        blockPartsSizeMultiplier = (val)  
    ,
})

BDTab:({
    Name = ,
    Range = {, },        
    Increment = ,
    Suffix = ,
    CurrentValue = ,
    Flag = ,
    Callback = (val)
        predictionStrength = val
    ,
})

BDTab:({
    Name = ,
    Range = {, },        
    Increment = ,
    Suffix = ,
    CurrentValue = ,
    Flag = ,
    Callback = (val)
        predictionTurnStrength = val
    ,
})

BDTab:({
    Name = ,
    PlaceholderText = ,
    RemoveTextAfterFocusLost = ,
    Flag = ,
    Callback = (text)
         num = (text)
         num 
            antiFlickDelay = .(, num) 
        
    ,
})



  ()
     myChar = lp.Character
     myRoot = myChar  myChar:()
      myRoot    

     closest, closestDist = , .huge
     _, k  (KillersFolder:()) 
         k  k:() 
             hrp = k:()
             hrp 
                 d = (hrp.Position - myRoot.Position).Magnitude
                 d < closestDist 
                    closest, closestDist = k, d
                
            
        
    
     closest


  (killerModel)
      killerModel 
        
         antiFlickDelay ~= _savedManualAntiFlickDelay 
            antiFlickDelay = _savedManualAntiFlickDelay
            (():((antiFlickDelay)))
        
        
    

     key = ((killerModel.Name)  ):()
     mapped = killerDelayMap[key]

     mapped ~=  
         antiFlickDelay ~= mapped 
            antiFlickDelay = mapped
            (():(killerModel.Name, (mapped)))
        
    
        
         antiFlickDelay ~= _savedManualAntiFlickDelay 
            antiFlickDelay = _savedManualAntiFlickDelay
            (():(killerModel.Name, (_savedManualAntiFlickDelay)))
        
    



 adjustTicker = 
RunService.Heartbeat:((dt)
      autoAdjustDBTFBPS   
    adjustTicker = adjustTicker + dt
     adjustTicker <     
    adjustTicker = 

     nearest = ()
    (nearest)
)


  ()
      autoAdjustDBTFBPS   
     nearest = ()
    (nearest)



KillersFolder.ChildAdded:(() .(, doImmediateUpdate) )
KillersFolder.ChildRemoved:(() .(, doImmediateUpdate) )


BDTab:({
    Name = ,
    CurrentValue = ,
    Flag = ,
    Callback = (state)
        autoAdjustDBTFBPS = state
         state 
            
            _savedManualAntiFlickDelay = antiFlickDelay  
            ()
            ( .. (_savedManualAntiFlickDelay) .. )
        
            
            antiFlickDelay = _savedManualAntiFlickDelay
            ( .. (antiFlickDelay))
        
    ,
})



 stagger  = 

BDTab:({
    Name = ,
    PlaceholderText = ,
    RemoveTextAfterFocusLost = ,
    Flag = ,
    Callback = (text)
         num = (text)
         num 
            stagger = .(, num) 
        
    ,
})



BDTab:({
    Name = ,
    PlaceholderText = ,
    RemoveTextAfterFocusLost = ,
    Flag = ,
    Callback = (text)
         num = (text)
         num 
            antiFlickBaseOffset = .(, num) 
        
    ,
})

TechTab:({
    Name = ,
    CurrentValue = ,
    Flag = ,
    Callback = (state)
        doubleblocktech = state
    ,
})


 hitboxDraggingTech = 
 _hitboxDraggingDebounce = 
 HITBOX_DRAG_DURATION = 
 HITBOX_DETECT_RADIUS = 

TechTab:({
    Name = ,
    CurrentValue = ,
    Flag = ,
    Callback = (state)
        hitboxDraggingTech = state
    ,
})

TechTab:({
    Name = ,
    PlaceholderText = ,
    RemoveTextAfterFocusLost = ,
    Flag = ,
    Callback = (Text) Dspeed = Text 
})

TechTab:({
    Name = ,
    PlaceholderText = ,
    RemoveTextAfterFocusLost = ,
    Flag = ,
    Callback = (Text) Ddelay = Text 
})

TechTab:({
    Title = ,
    Content = 
})

TechTab:({
    Name = ,
    Callback = ()
        (()
             char = lp.Character  lp.CharacterAdded:()
             humanoid = char  char:()
              humanoid   

             animator = humanoid:()  .(, humanoid)

            
             _, t  (animator:()) 
                 id = (t.Animation  t.Animation.AnimationId  ):()
                 id ==  
                    (() t:() )
                
            

             anim = .()
            anim.AnimationId = 
             track = animator:(anim)
            track:()
        )
    ,
})

PredictiveTab:({
    Name = ,
    CurrentValue = ,
    Callback = (Value)
        predictiveBlockOn = Value
    ,
})

PredictiveTab:({
    Name = ,
    PlaceholderText = ,
    RemoveTextAfterFocusLost = ,
    Callback = (text)
         num = (text)
         num 
            detectionRange = num
        
    ,
})


PredictiveTab:({
    Name = ,
    Range = {, },
    Increment = ,
    CurrentValue = ,
    Flag = ,
    Callback = (val)
        edgeKillerDelay = val
    ,
})

PredictiveTab:({
    Title = ,
    Content = 
})

FakeBlockTab:({
    Name = ,
    Callback = ()
        (()
             fakeGui = PlayerGui:()
              fakeGui 
                 success, result = (()
                     (:())()
                )
                  success 
                    (, result)
                
            
                fakeGui.Enabled = 
                ()
            
        )
    
})


AutoPunchTab:({
Name = ,
CurrentValue = ,
Flag = ,
Callback = (Value) autoPunchOn = Value 
})

AutoPunchTab:({
Name = ,
CurrentValue = ,
Flag = ,
Callback = (Value) messageWhenAutoPunchOn = Value 
})

AutoPunchTab:({
    Name = ,
    PlaceholderText = ,
    RemoveTextAfterFocusLost = ,
    Flag = ,
    Callback = (Text) messageWhenAutoPunch = Text 
})

AutoPunchTab:({
Name = ,
CurrentValue = ,
Callback = (Value) flingPunchOn = Value 
})

AutoPunchTab:({
Name = ,
CurrentValue = ,
Flag = ,
Callback = (Value) aimPunch = Value 
})


 predictionValue = 

AutoPunchTab:({
    Name = ,
    Range = {, },
    Increment = ,
    Suffix = ,
    CurrentValue = predictionValue,
    Flag = ,
    Callback = (Value)
        predictionValue = Value
    ,
})

AutoPunchTab:({
Name = ,
Range = {, },
Increment = ,
CurrentValue = ,
Flag = ,
Callback = (Value) flingPower = Value 
})


CustomAnimationsTab:({
    Name = ,
    PlaceholderText = ,
    RemoveTextAfterFocusLost = ,
    Flag = ,
    Callback = (Text) customBlockAnimId = Text 
})

CustomAnimationsTab:({
Name = ,
CurrentValue = ,
Callback = (Value) customBlockEnabled = Value 
})

CustomAnimationsTab:({
    Name = ,
    PlaceholderText = ,
    RemoveTextAfterFocusLost = ,
    Flag = ,
    Callback = (Text) customblockdelay = Text 
})

CustomAnimationsTab:({
    Name = ,
    PlaceholderText = ,
    RemoveTextAfterFocusLost = ,
    Flag = ,
    Callback = (Text) customPunchAnimId = Text 
})

CustomAnimationsTab:({
Name = ,
CurrentValue = ,
Callback = (Value) customPunchEnabled = Value 
})

CustomAnimationsTab:({
    Name = ,
    PlaceholderText = ,
    RemoveTextAfterFocusLost = ,
    Flag = ,
    Callback = (Text) custompunchdelay = Text 
})


CustomAnimationsTab:({
    Name = ,
    PlaceholderText = ,
    RemoveTextAfterFocusLost = ,
    Flag = ,
    Callback = (input)
        customChargeAnimId = input
    ,
})

CustomAnimationsTab:({
    Name = ,
    CurrentValue = ,
    Callback = (value)
        customChargeEnabled = value
    ,
})


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

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






 RunService = :()
 Players = :()
 lp = Players.LocalPlayer


 detectorChargeIds = ((chargeAnimIds) ==   chargeAnimIds)  {}







 ORIGINAL_DASH_SPEED = 


 controlChargeEnabled = 
 controlChargeActive = 
 overrideConnection = 


 savedHumanoidState = {}

  ()
      lp   lp.Character    
     lp.Character:()


  (hum)
      hum   
     savedHumanoidState[hum]   
     s = {}
    (()
        s.WalkSpeed = hum.WalkSpeed
        
         ok, _ = (() s.JumpPower = hum.JumpPower )
          ok 
            (() s.JumpPower = hum.JumpHeight )
        
        
         ok2, ar = (()  hum.AutoRotate )
         ok2  s.AutoRotate = ar 
        s.PlatformStand = hum.PlatformStand
    )
    savedHumanoidState[hum] = s


  (hum)
      hum   
     s = savedHumanoidState[hum]
      s   
    (()
         s.WalkSpeed ~=   hum.WalkSpeed = s.WalkSpeed 
         s.JumpPower ~=  
             ok, _ = (() hum.JumpPower = s.JumpPower )
              ok  (() hum.JumpHeight = s.JumpPower ) 
        
         s.AutoRotate ~=   (() hum.AutoRotate = s.AutoRotate ) 
         s.PlatformStand ~=   hum.PlatformStand = s.PlatformStand 
    )
    savedHumanoidState[hum] = 



  ()
     controlChargeActive   
     hum = ()
      hum   

    controlChargeActive = 
    (hum)

    
    (()
        hum.WalkSpeed = ORIGINAL_DASH_SPEED
        hum.AutoRotate = 
    )

    
    overrideConnection = RunService.RenderStepped:(()
         humanoid = ()
         rootPart = humanoid  humanoid.Parent  humanoid.Parent:()
          humanoid   rootPart   

        
        (()
            humanoid.WalkSpeed = ORIGINAL_DASH_SPEED
            humanoid.AutoRotate = 
        )

         direction = rootPart.CFrame.LookVector
         horizontal = .(direction.X, , direction.Z)
         horizontal.Magnitude >  
            humanoid:(horizontal.Unit)
        
            humanoid:(.(,,))
        
    )



  ()
      controlChargeActive   
    controlChargeActive = 

    
     overrideConnection 
        (() overrideConnection:() )
        overrideConnection = 
    

    
     hum = ()
     hum 
        (()
            
            (hum)
            
            humanoid:(.(,,))
        )
    



  ()
     hum = ()
      hum    
     _, track  (hum:()) 
         ok, animId = (()
             (track.Animation  track.Animation.AnimationId  ):()
        )
         ok  animId  animId ~=  
             detectorChargeIds  .(detectorChargeIds, animId) 
                 
            
             ((customChargeEnabled) ==   customChargeEnabled)  customChargeAnimId  (customChargeAnimId) ~=  
                 (animId) == (customChargeAnimId) 
                     
                
            
        
    
     



  (val)
    controlChargeEnabled = val    
      controlChargeEnabled  controlChargeActive 
        ()
    



RunService.RenderStepped:(()
      controlChargeEnabled 
         controlChargeActive  () 
        
    

    
     hum = ()
      hum 
         controlChargeActive  () 
        
    

     isCharging = ()

     isCharging 
          controlChargeActive 
            ()
        
    
         controlChargeActive 
            ()
        
    
)


lp.CharacterAdded:((char)
    
    .(()
         hum = char:(, )
         hum 
            
        
    )
)


.ControlCharge_SetEnabled = ControlCharge_SetEnabled










.ControlCharge_DashSpeed = .ControlCharge_DashSpeed  
.ControlCharge_CustomEnabled = .ControlCharge_CustomEnabled  
.ControlCharge_CustomAnimId = .ControlCharge_CustomAnimId  


MiscTab:({
    Name = ,
    CurrentValue = ,
    Callback = (val)
        
         .ControlCharge_SetEnabled 
            (() .(val) )
        
            
            .ControlCharge_WantedEnabled = val
        
    ,
})


MiscTab:({
    Title = ,
    Content = 
})


  (obj)
      obj:()   
      obj:()   

     plr = Players:(obj)
      plr    

    
     obj:()   

    
     highlight = .()
    highlight.Name = 
    highlight.FillColor = .(, , )
    highlight.OutlineColor = .(, , )
    highlight.DepthMode = .HighlightDepthMode.AlwaysOnTop
    highlight.Adornee = obj
    highlight.Parent = obj

    
     billboard = .()
    billboard.Name = 
    billboard.Size = .(, , , )
    billboard.AlwaysOnTop = 
    billboard.Adornee = obj:()
    billboard.Parent = obj

     textLabel = .()
    textLabel.Name = 
    textLabel.Size = .(, , , )
    textLabel.BackgroundTransparency = 
    textLabel.TextColor3 = .(, , )
    textLabel.TextScaled = 
    textLabel.Font = .Font.SourceSansBold
    textLabel.Text = obj.Name
    textLabel.Parent = billboard



  (obj)
     obj:() 
        obj.ESP_Highlight:()
    
     obj:() 
        obj.ESP_Billboard:()
    



  ()
      espEnabled 
         _, killer  (KillersFolder:()) 
            (killer)
        
        
    

     _, killer  (KillersFolder:()) 
        (killer)
    




KillersFolder.ChildAdded:((child)
     espEnabled 
        .() 
        (child)
    
)


KillersFolder.ChildRemoved:((child)
    (child)
)


RunService.RenderStepped:(()
      espEnabled   
     char = lp.Character
     hrp = char  char:()
      hrp   

     _, killer  (KillersFolder:()) 
         billboard = killer:()
         billboard  billboard:()  killer:() 
             dist = (killer.HumanoidRootPart.Position - hrp.Position).Magnitude
            billboard.ESP_Text.Text = .(, killer.Name, dist)
        
    
)

MiscTab:({
    Name = ,
    CurrentValue = ,
    Flag = ,
    Callback = (Value)
        espEnabled = Value
        ()
    ,
})

MiscTab:({
    Name = ,
    Callback = (Value)
        :().Modules.StatusEffects.Slowness:()
    ,
})

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


  ()
 args = {, }
ReplicatedStorage:():():():((args))


  ()
 args = {, }
ReplicatedStorage:():():():((args))





  (animId, isPunch)
      Humanoid 
        ()
        
    

      animId  animId ==  
        ()
        
    

     now = ()
     lastTime = isPunch  lastPunchTime  lastBlockTime
     now - lastTime <  
        
    

    
     _, track  (Humanoid:()) 
         animNum = (track.Animation  track.Animation.AnimationId):()
         .(isPunch  punchAnimIds  blockAnimIds, animNum) 
            (() track:() )
        
    

     anim = .()
    anim.AnimationId =  .. animId

     success, track = (()
         Humanoid:(anim)
    )

     success  track 
        ( .. (isPunch    ) .. , animId)
        track:()

        
         isPunch 
            lastPunchTime = now
        
            lastBlockTime = now
        

        
         duration = isPunch    
        
        .(duration, ()
            (()
                 track  track.IsPlaying 
                    track:()
                
            )
        )
    
        ( .. (animId))
    






.(()
     hrp, c, vel, movel = , , , 
      
        RunService.Heartbeat:()
         hiddenfling 
             hiddenfling   (c  c.Parent  hrp  hrp.Parent) 
                RunService.Heartbeat:()
                c = lp.Character
                hrp = c  c:()
            
             hiddenfling 
                vel = hrp.Velocity
                hrp.Velocity = vel * flingPower + .(, flingPower, )
                RunService.RenderStepped:()
                hrp.Velocity = vel
                RunService.Stepped:()
                hrp.Velocity = vel + .(, movel, )
                movel = movel * -
            
        
    
)()

  (text)
      text  text:()   
     TextChatService = :()
     channel = TextChatService.TextChannels.RBXGeneral

    channel:(text)



 soundHooks = {}     
 soundBlockedUntil = {} 

  (maxDist)
     killersFolder = :()  .Players:()
      killersFolder    

     myRoot = lp.Character  lp.Character:()
      myRoot    

     closest, closestDist = , maxDist  .huge
     _, killer  (killersFolder:()) 
         hrp = killer:()
         hrp 
             dist = (hrp.Position - myRoot.Position).Magnitude
             dist < closestDist 
                closest, closestDist = hrp, dist
            
        
    
     closest



 string_match = .match
 tostring_local = 

  (sound)
      sound    

     sid = sound.SoundId
      sid    
    sid = ((sid) == )  sid  (sid)

    
     num =
        (sid, ) 
        (sid, ) 
        (sid, )

     num  #num >  
         num
    

    
     hash = (sid, )
     hash 
          .. hash
    

     path = (sid, )
     path 
         path
    

     



 KF = KillersFolder

  (sound)
      sound    

     parent = sound.Parent
     parent 
         parent:() 
             parent.Position, parent
        

         parent:() 
             gp = parent.Parent
             gp  gp:() 
                 gp.Position, gp
            
        
    

    
     KF  sound:(KF) 
        
         root = parent  sound
         found = root:(, )
         found 
             found.Position, found
        
    

     , 


  (inst)
      inst    
     model = inst:()
     model  model:() 
         model
    
     


  (part, point)
      (part  point)    
    
     rel = part.CFrame:(point)
     half = part.Size * 
     .(rel.X) <= half.X +  
           .(rel.Y) <= half.Y +  
           .(rel.Z) <= half.Z + 





RunService.RenderStepped:((dt)
     dt <=    
     killersFolder = :()  .Players:()
      killersFolder   

     _, killer  (killersFolder:()) 
         killer  killer.Parent 
             hrp = killer:()
             hrp 
                 st = killerState[killer]  { prevPos = hrp.Position, prevLook = hrp.CFrame.LookVector, vel = .(), angVel =  }
                
                 newVel = (hrp.Position - st.prevPos) / .(dt, )
                st.vel = st.vel  st.vel:(newVel, SMOOTHING_LERP)  newVel

                
                 prevLook = st.prevLook  hrp.CFrame.LookVector
                 look = hrp.CFrame.LookVector
                 dot = .(prevLook:(look), -, )
                 angle = .(dot) 
                 crossY = prevLook:(look).Y
                 angSign = (crossY >= )    -
                 newAngVel = (angle / .(dt, )) * angSign
                st.angVel = (st.angVel * ( - SMOOTHING_LERP)) + (newAngVel * SMOOTHING_LERP)

                st.prevPos = hrp.Position
                st.prevLook = look
                killerState[killer] = st
            
        
    
)


 _LP = Players.LocalPlayer
 _isFacing = isFacing
 _fireRemoteBlock = fireRemoteBlock
 _fireRemotePunch = fireRemotePunch
 _cachedBlockBtn = cachedBlockBtn
 _cachedCooldown = cachedCooldown            
 _cachedCharges = cachedCharges
 LOCAL_BLOCK_COOLDOWN =    
 lastLocalBlockTime = 

  (btn)
      btn    
     _, conn  ((btn.MouseButton1Click)) 
        conn:()
    





  ()
     blockAction = 
     blockData = {buffer.()}
    
    testRemote:(blockAction, blockData)


  ()
     punchAction = 
     punchData = {buffer.()}
    
    testRemote:(punchAction, punchData)


  ()
     blockAction = 
     blockData = {buffer.()}
    
    testRemote:(blockAction, blockData)


  ()
     blockAction = 
     blockData = {buffer.()}

    testRemote:(blockAction, blockData)


 chargeAimActive = 
 chargeAimThread = 

  ()
    chargeAimActive = 
    




  (fallbackSec)
    
    ()
    chargeAimActive = 

    chargeAimThread = .(()
         startWatch = ()
         fallback = (fallbackSec)  

        
          ()
             char = lp.Character
              char   , ,  
             hum = char:()
             hrp = char:()
             animator = char:()
             hum, hrp, animator
        

         humanoid, myRoot, animator = ()
         humanoid 
            (() humanoid.AutoRotate =  )
        

         seenChargeAnim = 
         watchStart = ()

         chargeAimActive 
            
            humanoid, myRoot, animator = ()
              myRoot   

            
             killerModel = ()
             targetHRP = (killerModel  killerModel:())  

             targetHRP 
                
                 pred = ((predictionValue) == )  predictionValue  
                 predictedPos = targetHRP.Position + (targetHRP.CFrame.LookVector * pred)

                
                (()
                    myRoot.CFrame = .(myRoot.Position, predictedPos)
                )
            

            
             stillPlaying = 
             animator 
                 ok, tracks = (()  animator:() )
                 ok  tracks 
                     _, track  (tracks) 
                         animId = 
                        (() animId = tostring(track.Animation and track.Animation.AnimationId or ""):match("%d+") end)
                        if animId and table.find(chargeAnimIds, animId) then
                            stillPlaying = true
                            seenChargeAnim = true
                            break
                        end
                    end
                end
            end

            -- stop conditions:
            -- 1) we saw a charge anim and now it's gone -> stop
            if seenChargeAnim and not stillPlaying then
                break
            end

            -- 2) we never saw a charge anim and we've exceeded fallback -> stop
            if not seenChargeAnim and (tick() - watchStart) > fallback then
                break
            end

            task.wait()
        end

        -- restore AutoRotate
        if humanoid then
            pcall(function() humanoid.AutoRotate = true end)
        end

        chargeAimActive = false
    end)
end

-- modify hookSound: store extracted id once

-- optimized attemptBlockForSound (accepts optional precomputed id)
-- Replace your existing attemptBlockForSound with this improved version
-- TUNABLES (put near top of file so you can tweak for high ping)
local AUDIO_PREDICT_DT = 0.08        -- seconds to predict forward (increase for high ping)
local AUDIO_LOCAL_COOLDOWN = 0.35    -- local throttle between blocks (seconds)
local AUDIO_SOUND_THROTTLE = 1.0     -- how long to throttle the same sound (seconds)

-- helper: fast squared distance (no sqrt)
local function distSq(a, b)
    local dx = a.X - b.X
    local dy = a.Y - b.Y
    local dz = a.Z - b.Z
    return dx*dx + dy*dy + dz*dz
end

local _getSoundWorldPosition = getSoundWorldPosition

-- shared heavy work helper (local to file/scope)
local function _attemptForSound(sound, idParam, mode)
    -- quick guards (keep same order)
    if not autoBlockAudioOn then return end
    if not sound or not sound:IsA("Sound") then return end
    if not sound.IsPlaying then return end

    -- hot locals
    local now = tick()
    local hooks = soundHooks
    local hook = hooks and hooks[sound]

    -- id resolution (prefer cached)
    local id = idParam or (hook and hook.id) or extractNumericSoundId(sound)
    if not id or not autoBlockTriggerSounds[id] then return end

    -- per-sound throttle
    if soundBlockedUntil[sound] and now < soundBlockedUntil[sound] then return end

    -- global local cooldown
    if now - lastLocalBlockTime < AUDIO_LOCAL_COOLDOWN then return end

    -- ensure UI refs depending on mode (preserve original checks)
    if mode == "Block" or mode == "Charge" then
        if not cachedBlockBtn or not cachedCooldown or not cachedCharges then
            refreshUIRefs()
        end
    elseif mode == "Clone" then
        if not cachedCloneBtn then
            refreshUIRefs()
        end
    end

    -- local player root
    local lpLocal = _LP or Players.LocalPlayer
    local myChar = lpLocal and lpLocal.Character
    local myRoot = myChar and myChar:FindFirstChild("HumanoidRootPart")
    if not myRoot then return end

    -- cached hook mapping (may be nil)
    local char = hook and hook.char
    local hrp = hook and hook.hrp

    if not hrp then
        -- expensive path: only when cache missing
        local soundPos, soundPart = getSoundWorldPosition(sound)
        if not soundPart then return end
        char = getCharacterFromDescendant(soundPart)
        hrp = char and char:FindFirstChild("HumanoidRootPart")
        -- cache mapping for next time
        if hook then
            hook.char = char
            hook.hrp = hrp
        else
            soundHooks[sound] = { id = id, char = char, hrp = hrp }
            hook = soundHooks[sound]
        end
    end

    if not hrp then return end

    -- predicted position using velocity (unrolled for speed)
    local v = hrp.Velocity or Vector3.new()
    local predictedX = hrp.Position.X + v.X * AUDIO_PREDICT_DT
    local predictedY = hrp.Position.Y + v.Y * AUDIO_PREDICT_DT
    local predictedZ = hrp.Position.Z + v.Z * AUDIO_PREDICT_DT

    local dx = predictedX - myRoot.Position.X
    local dy = predictedY - myRoot.Position.Y
    local dz = predictedZ - myRoot.Position.Z
    local distSqPred = dx*dx + dy*dy + dz*dz

    -- detection range check (preserve grace fallback logic)
    if detectionRangeSq and distSqPred > detectionRangeSq then
        local dx2 = hrp.Position.X - myRoot.Position.X
        local dy2 = hrp.Position.Y - myRoot.Position.Y
        local dz2 = hrp.Position.Z - myRoot.Position.Z
        local distSqNow = dx2*dx2 + dy2*dy2 + dz2*dz2
        local grace = (detectionRange + 3) * (detectionRange + 3)
        if distSqNow > grace then
            return
        end
    end

    -- verify sound world position (kept as in original)
    local soundPos, soundPart = _getSoundWorldPosition(sound)
    if not soundPart then return end

    -- climb to Model & validate humanoid
    local model = soundPart and soundPart:FindFirstAncestorOfClass("Model") or nil
    if not model then return end

    local humanoid = model:FindFirstChildWhichIsA("Humanoid")
    if not humanoid then return end

    local plr = Players:GetPlayerFromCharacter(model)
    if not plr or plr == lp then return end

    -- facing check (cached _isFacing)
    if facingCheckEnabled and not _isFacing(myRoot, hrp) then
        return
    end

    task.wait(blockdelay)

    -- mode-specific extra checks & actions (preserve prints and exact calls)
    if mode == "Block" then
        if cachedCooldown and cachedCooldown.Text == "" then
            print("yay")
        else
            return
        end
        fireGuiBlock()
        if doubleblocktech == true then
            fireGuiPunch()
        end
    elseif mode == "Charge" then
        if cachedChargeBtn and cachedChargeBtn:FindFirstChild("CooldownTime") and cachedChargeBtn.CooldownTime.Text == "" then
            print("yay")
        else
            return
        end
        fireGuiCharge()
        startChargeAimUntilChargeEnds(0.4)
    elseif mode == "Clone" then
        if cachedCloneBtn and cachedCloneBtn:FindFirstChild("CooldownTime") and cachedCloneBtn.CooldownTime.Text == "" then
            print("yay")
        else
            return
        end
        fireGuiClone()
        startChargeAimUntilChargeEnds(0.4)
    end

    -- optimistic local timestamp & throttle this sound (identical)
    lastLocalBlockTime = now
    soundBlockedUntil[sound] = now + AUDIO_SOUND_THROTTLE
end

-- public wrappers to preserve original names/behavior
local function attemptBlockForSound(sound, idParam)
    return _attemptForSound(sound, idParam, "Block")
end

local function attemptChargeForSound(sound, idParam)
    return _attemptForSound(sound, idParam, "Charge")
end

local function attemptCloneForSound(sound, idParam)
    return _attemptForSound(sound, idParam, "Clone")
end

-- Improved hookSound: cache id and keep placeholder for hrp/char (so attemptBlock hot-path reads cached data)

local function attemptBDParts(sound)
    if not autoBlockAudioOn then return end
    if not sound or not sound:IsA("Sound") then return end
    if not sound.IsPlaying then return end

    local id = extractNumericSoundId(sound)
    if not id or not autoBlockTriggerSounds[id] then return end

    local t = tick()
    if soundBlockedUntil[sound] and t < soundBlockedUntil[sound] then return end

    local lp = Players.LocalPlayer
    local myChar = lp and lp.Character
    local myRoot = myChar and myChar:FindFirstChild("HumanoidRootPart")
    if not myRoot then return end

    local soundPos, soundPart = getSoundWorldPosition(sound)
    if not soundPos or not soundPart then return end

    local char = getCharacterFromDescendant(soundPart)
    local plr = char and Players:GetPlayerFromCharacter(char)
    if not plr or plr == lp then return end

    local hrp = char:FindFirstChild("HumanoidRootPart")
    if not hrp then return end

    local Debris = game:GetService("Debris")

    if antiFlickOn then
        local basePartSize = Vector3.new(5.5, 7.5, 8.5)  -- original / default size
        local partSize = basePartSize * (blockPartsSizeMultiplier or 1)
        local count = math.max(1, antiFlickParts or 4)
        local base  = antiFlickBaseOffset or 2.5
        local step  = antiFlickOffsetStep or 0.2
        local lifeTime = 0.2

        task.spawn(function()
            local blocked = false
            task.wait(antiFlickDelay or 0)
            for i = 1, count do
                if not hrp or not myRoot then break end

                local dist = base + (i - 1) * step

                local st = killerState[char] or { vel = hrp.Velocity or Vector3.new(), angVel = 0 }
                local vel = st.vel or hrp.Velocity or Vector3.new()

                local forwardSpeed = vel:Dot(hrp.CFrame.LookVector)
                local lateralSpeed = vel:Dot(hrp.CFrame.RightVector)

                -- separate multipliers
                local pStrength = (type(predictionStrength) == "number" and predictionStrength) or 1
                local pTurn = (type(predictionTurnStrength) == "number" and predictionTurnStrength) or 1

                -- raw predicted displacements
                local forwardPredictRaw = forwardSpeed * PRED_SECONDS_FORWARD * pStrength
                local lateralPredictRaw = lateralSpeed * PRED_SECONDS_LATERAL * pStrength
                local turnLateralRaw    = st.angVel * ANG_TURN_MULTIPLIER * pTurn

                -- clamps (scaled separately)
                local forwardClamp = PRED_MAX_FORWARD * pStrength
                local lateralClamp = PRED_MAX_LATERAL * pStrength
                local turnClamp    = PRED_MAX_LATERAL * pTurn

                local forwardPredict = math.clamp(forwardPredictRaw, -forwardClamp, forwardClamp)
                local lateralPredict = math.clamp(lateralPredictRaw, -lateralClamp, lateralClamp)
                local turnLateral = math.clamp(turnLateralRaw, -turnClamp, turnClamp)

                local forwardDist = dist + forwardPredict

                local spawnPos = hrp.Position
                                + hrp.CFrame.LookVector * forwardDist
                                + hrp.CFrame.RightVector * (lateralPredict + turnLateral)

                local part = Instance.new("Part")
                part.Name = "AntiFlickZone"
                part.Size = partSize
                part.Transparency = 0.45
                part.Anchored = true
                part.CanCollide = false
                part.CFrame = CFrame.new(spawnPos, hrp.Position)
                part.BrickColor = BrickColor.new("Bright blue")
                part.Parent = workspace

                Debris:AddItem(part, lifeTime)

                if isPointInsidePart(part, myRoot.Position) then
                    blocked = true
                else
                    local touching = {}
                    pcall(function() touching = myRoot:GetTouchingParts() end)
                    for _, p in ipairs(touching) do
                        if p == part then
                            blocked = true
                            break
                        end
                    end
                end

                if blocked then
                    if not (facingCheckEnabled and not isFacing(myRoot, hrp)) then
                        if autoblocktype == "Block" then
                            fireGuiBlock()
                        elseif autoblocktype == "Charge" then
                            fireGuiCharge()
                        elseif autoblocktype == "7n7 Clone" then
                            fireGuiClone()
                        end
                        soundBlockedUntil[sound] = t + 1.2
                    end
                    break
                end

                if stagger and stagger > 0 then
                    task.wait(stagger)
                else
                    task.wait(0)
                end
            end
        end)
        return
    end
end

local function hookSound(sound)
    if not sound or not sound:IsA("Sound") then return end
    if soundHooks[sound] then return end

    local preId = extractNumericSoundId(sound)

    -- create entry with id; hrp/char may be nil initially and will be cached later
    soundHooks[sound] = { id = preId, hrp = nil, char = nil }

    -- helper: centralize the logic so behaviour remains identical but without duplication
    local function handleAttempt(snd, id)
        if not autoBlockAudioOn then return end

        if not antiFlickOn then
            local at = autoblocktype
            if at == "Block" then
                attemptBlockForSound(snd, id)
            elseif at == "Charge" then
                attemptChargeForSound(snd, id)
            elseif at == "7n7 Clone" then
                attemptCloneForSound(snd, id)
            end
        else
            attemptBDParts(snd, id)
        end
    end

    -- connections
    local playedConn = sound.Played:Connect(function()
        handleAttempt(sound, preId)
    end)

    local propConn = sound:GetPropertyChangedSignal("IsPlaying"):Connect(function()
        if sound.IsPlaying then
            handleAttempt(sound, preId)
        end
    end)

    local destroyConn
    destroyConn = sound.Destroying:Connect(function()
        if playedConn and playedConn.Connected then playedConn:Disconnect() end
        if propConn and propConn.Connected then propConn:Disconnect() end
        if destroyConn and destroyConn.Connected then destroyConn:Disconnect() end
        soundHooks[sound] = nil
        soundBlockedUntil[sound] = nil
    end)

    -- store connections & metadata in hook table for later cleanup if you want (optional)
    soundHooks[sound].playedConn = playedConn
    soundHooks[sound].propConn = propConn
    soundHooks[sound].destroyConn = destroyConn

    -- If currently playing, handle immediately (cheap)
    if sound.IsPlaying then
        handleAttempt(sound, preId)
    end
end

-- Hook existing Sounds across the game (covers workspace, SoundService, Lighting, etc.)
for _, desc in ipairs(KillersFolder:GetDescendants()) do
    if desc:IsA("Sound") then
        hookSound(desc)
    end
end

-- Hook any future Sounds
KillersFolder.DescendantAdded:Connect(function(desc)
    if desc:IsA("Sound") then
        hookSound(desc)
    end
end)
-- ===== End Robust Sound Auto Block =====

-- Utility to safely get a killer HRP
local function getKillerHRP(killerModel)
    if not killerModel then return nil end
    if killerModel:FindFirstChild("HumanoidRootPart") then
        return killerModel:FindFirstChild("HumanoidRootPart")
    end
    if killerModel.PrimaryPart then
        return killerModel.PrimaryPart
    end
    -- try finding any basepart descendant
    return killerModel:FindFirstChildWhichIsA("BasePart", true)
end

local function beginDragIntoKiller(killerModel)
    -- Basic guards
    if _hitboxDraggingDebounce then return end
    if not killerModel or not killerModel.Parent then return end
    local char = lp and lp.Character
    if not char then return end
    local hrp = char:FindFirstChild("HumanoidRootPart")
    local humanoid = char:FindFirstChildOfClass("Humanoid")
    if not hrp or not humanoid then return end

    local targetHRP = getKillerHRP(killerModel)
    if not targetHRP then
        warn("beginDragIntoKiller: killer has no HRP/PrimaryPart")
        return
    end

    _hitboxDraggingDebounce = true

    -- save old locomotion state so we can restore it
    local oldWalk = humanoid.WalkSpeed
    local oldJump = humanoid.JumpPower
    local oldPlatformStand = humanoid.PlatformStand

    -- block normal movement by zeroing walk/jump (works for mobile joystick too)
    humanoid.WalkSpeed = 0
    humanoid.JumpPower = 0
    humanoid.PlatformStand = false  -- keep physics normal so BodyVelocity works

    -- create BodyVelocity to push the HRP toward the killer smoothly
    local bv = Instance.new("BodyVelocity")
    bv.MaxForce = Vector3.new(1e5, 0, 1e5)     -- allow horizontal movement, keep y free
    bv.Velocity = Vector3.new(0,0,0)
    bv.Parent = hrp

    -- optional: lightly damp vertical to avoid sudden pops (leave Y alone to respect gravity)
    local conn
    conn = RunService.Heartbeat:Connect(function(dt)
        if not _hitboxDraggingDebounce then
            conn:Disconnect()
            if bv and bv.Parent then pcall(function() bv:Destroy() end) end
            humanoid.WalkSpeed = oldWalk
            humanoid.JumpPower = oldJump
            humanoid.PlatformStand = oldPlatformStand
            return
        end

        -- abort if character/killer removed
        if not (char and char.Parent) or not (killerModel and killerModel.Parent) then
            _hitboxDraggingDebounce = false
            return
        end

        -- refresh target HRP (killer may respawn)
        targetHRP = getKillerHRP(killerModel)
        if not targetHRP then
            _hitboxDraggingDebounce = false
            return
        end

        -- compute desired horizontal velocity toward the target
        local toTarget = (targetHRP.Position - hrp.Position)
        local dist = toTarget.Magnitude
        -- desired speed: based on distance but clamped so it feels natural
        
        local horiz = Vector3.new(toTarget.X, 0, toTarget.Z)
        if horiz.Magnitude > 0.01 then
            local dir = horiz.Unit
            bv.Velocity = Vector3.new(dir.X * Dspeed, bv.Velocity.Y, dir.Z * Dspeed)
        else
            bv.Velocity = Vector3.new(0, bv.Velocity.Y, 0)
        end

        -- stop condition: when very close to killer (adjust threshold as needed)
        local stopDist = 2.0
        if dist <= stopDist then
            _hitboxDraggingDebounce = false
            -- cleanup will happen in next loop tick
        end
    end)

    -- final cleanup safety (timeout)
    task.delay(0.4, function()
        if _hitboxDraggingDebounce then
            _hitboxDraggingDebounce = false
        end
    end)
end

-- Example call:
-- beginDragIntoKiller(someKillerModel)

-- Watch for local block animations starting and trigger drag
RunService.RenderStepped:Connect(function()
    if not hitboxDraggingTech then return end
    if not cachedAnimator then refreshAnimator() end
    local animator = cachedAnimator
    if not animator then return end

    for _, track in ipairs(animator:GetPlayingAnimationTracks()) do
        local ok, animId = pcall(function()
            local a = track.Animation
            return a and tostring(a.AnimationId):match("%d+")
        end)
        if ok and animId and table.find(blockAnimIds, animId) then
            -- only trigger once when it starts (timepos ~ 0)
            local timePos = 0
            pcall(function() timePos = track.TimePosition or 0 end)
            if timePos <= 0.12 then
                local nearest = getNearestKillerModel()
                if nearest then
                    -- spawn so we don't block the RenderStepped loop
                    task.wait(Ddelay)
                    task.spawn(function() beginDragIntoKiller(nearest) end)
                    startChargeAimUntilChargeEnds(0.4)
                end
            end
        end
    end
end)

-- If Better Detection (antiFlickOn) is enabled, watch for blue AntiFlickZone parts near the player
-- and trigger dragging when they appear in range.
task.spawn(function()
    if not cachedBlockBtn or not cachedCooldown or not cachedCharges then
        refreshUIRefs()
    end

    if cachedBlockBtn and cachedBlockBtn:FindFirstChild("CooldownTime") and cachedBlockBtn.CooldownTime.Text == "" then
        print("yay")
    else
        return
    end

    while true do
        RunService.Heartbeat:Wait()
        if not (hitboxDraggingTech and antiFlickOn) then
            task.wait(0.15)
            continue
        end

        local char = lp.Character
        local myRoot = char and char:FindFirstChild("HumanoidRootPart")
        if not myRoot then task.wait(0.15) continue end

        -- look for parts named "AntiFlickZone" inside radius (fast and simple)
        local found = nil
        for _, part in ipairs(workspace:GetDescendants()) do
            if not part:IsA("BasePart") then continue end
            if part.Name ~= "AntiFlickZone" then continue end
            if (part.Position - myRoot.Position).Magnitude <= HITBOX_DETECT_RADIUS then
                found = part
                break
            end
        end        
        if found and not _hitboxDraggingDebounce then
            local nearest = getNearestKillerModel()
            if nearest then
                task.wait(Ddelay)
                task.spawn(function() beginDragIntoKiller(nearest) end)
                startChargeAimUntilChargeEnds(0.4)
            end
        end
        task.wait(0.12) -- throttle checks
    end
end)

-- double-punch tech detection
-- Replacement double-punch detection (safer + debounced)
local _REFRESH_UI_IF_NIL = true
local TRACK_DEBOUNCE = 0.45   -- seconds to avoid retriggering same track
local START_WINDOW = 0     -- consider a track "starting" if TimePosition <= START_WINDOW

local trackLastTriggered = setmetatable({}, { __mode = "k" }) -- weak keys (AnimationTrack -> last tick)


-- Play a custom charge animation and stop it when LP touches a non-player part or after 4s
local function playCustomChargeWithAutoStop(animId)
    if not lp or not lp.Character then return end
    local char = lp.Character
    local hum = char:FindFirstChildOfClass("Humanoid")
    local hrp = char:FindFirstChild("HumanoidRootPart")
    if not hum or not hrp then return end

    -- get or create Animator
    local animator = hum:FindFirstChildOfClass("Animator") or Instance.new("Animator", hum)

    local anim = Instance.new("Animation")
    anim.AnimationId = "rbxassetid://" .. tostring(animId)

    local ok, track = pcall(function() return animator:LoadAnimation(anim) end)
    if not ok or not track then
        warn("Failed to load charge animation:", animId)
        return
    end

    track:Play()

    local stopped = false
    local touchConn
    local timeoutConn

    -- stop function (safe, idempotent)
    local function stopTrack()
        if stopped then return end
        stopped = true
        pcall(function() track:Stop() end)
        if touchConn and touchConn.Connected then pcall(function() touchConn:Disconnect() end) end
        if timeoutConn and timeoutConn.Connected then pcall(function() timeoutConn:Disconnect() end) end
    end

    -- stop when HRP touches a part that's not part of our character
    touchConn = hrp.Touched:Connect(function(part)
        if stopped then return end
        if not part then return end
        if part:IsDescendantOf(char) then return end -- ignore touching own character parts
        -- optional: ignore other players' characters if you want; here we treat anything not part of our char as "wall"
        stopTrack()
    end)

    -- timeout after 4 seconds (hard stop)
    timeoutConn = nil
    task.spawn(function()
        local start = tick()
        while not stopped and (tick() - start) < 4 do
            task.wait(0.05)
        end
        if not stopped then
            stopTrack()
        end
    end)

    -- try to clean up if the track stops normally (AnimationTrack may have Stopped event)
    pcall(function()
        if track.Stopped then
            track.Stopped:Connect(stopTrack)
        end
    end)
end

local lastReplaceTime = {
    block = 0,
    punch = 0,
    charge = 0,
}

task.spawn(function()
    while true do
        RunService.Heartbeat:Wait()

        local char = lp.Character
        if not char then continue end

        local humanoid = char:FindFirstChildOfClass("Humanoid")
        local animator = humanoid and humanoid:FindFirstChildOfClass("Animator")
        if not animator then continue end

        for _, track in ipairs(animator:GetPlayingAnimationTracks()) do
            local animId = tostring(track.Animation.AnimationId):match("%d+")

            -- Block animation replacement
            if customBlockEnabled and customBlockAnimId ~= "" and table.find(blockAnimIds, animId) then
                if animId == tostring(customBlockAnimId) then
                    continue -- already custom anim
                end
            
                if tick() - lastReplaceTime.block >= 3 then
                    lastReplaceTime.block = tick()
                    track:Stop()

                    local newAnim = Instance.new("Animation")
                    newAnim.AnimationId = "rbxassetid://" .. customBlockAnimId
                    local newTrack = animator:LoadAnimation(newAnim)
                    newTrack:Play()

                    -- auto-stop after 2.7 seconds (safe)
                    task.delay(customblockdelay, function()
                        pcall(function()
                            if newTrack and newTrack.IsPlaying then
                                newTrack:Stop()
                            end
                        end)
                    end)

                    break
                end
            end

            -- Punch animation replacement
            if customPunchEnabled and customPunchAnimId ~= "" and table.find(punchAnimIds, animId) then
                if animId == tostring(customPunchAnimId) then
                    continue -- already custom anim
                end
            
                if tick() - lastReplaceTime.punch >= 3 then
                    lastReplaceTime.punch = tick()
                    track:Stop()
  
                    -- with this patch:
                    local newAnim = Instance.new("Animation")
                    newAnim.AnimationId = "rbxassetid://" .. customPunchAnimId
                    local newTrack = animator:LoadAnimation(newAnim)
                    newTrack:Play()

                    -- auto-stop after 2.7 seconds (safe)
                    task.delay(custompunchdelay, function()
                        pcall(function()
                            if newTrack and newTrack.IsPlaying then
                                newTrack:Stop()
                            end
                        end)
                    end)

                    break
                end
            end

            -- Charge animation replacement
            if customChargeEnabled and customChargeAnimId ~= "" and table.find(chargeAnimIds, animId) then
                if animId == tostring(customChargeAnimId) then
                    continue -- already custom anim
                end

                if tick() - lastReplaceTime.charge >= 3 then
                    lastReplaceTime.charge = tick()
                    track:Stop()

                    local newAnim = Instance.new("Animation")
                    newAnim.AnimationId = "rbxassetid://" .. customChargeAnimId
                    -- Instead of directly playing the custom track, use the helper so it auto-stops on touch or after 4s
                    playCustomChargeWithAutoStop(customChargeAnimId)
                    break
                end
            end
        end
    end
end)

-- Auto block + punch detection loop
RunService.RenderStepped:Connect(function()
    local gui = PlayerGui:FindFirstChild("MainUI")
    local punchBtn = gui and gui:FindFirstChild("AbilityContainer") and gui.AbilityContainer:FindFirstChild("Punch")
    local charges = punchBtn and punchBtn:FindFirstChild("Charges")
    local blockBtn = gui and gui:FindFirstChild("AbilityContainer") and gui.AbilityContainer:FindFirstChild("Block")
    local cooldown = blockBtn and blockBtn:FindFirstChild("CooldownTime")

    local myChar = lp.Character
    if not myChar then return end
    local myRoot = myChar:FindFirstChild("HumanoidRootPart")
    Humanoid = myChar:FindFirstChildOfClass("Humanoid")
        -- Auto Block: Trigger block if a valid animation is played by a killer
    for _, plr in ipairs(Players:GetPlayers()) do
        if plr ~= lp and plr.Character then
            local hrp = plr.Character:FindFirstChild("HumanoidRootPart")
            local hum = plr.Character:FindFirstChildOfClass("Humanoid")
            local animTracks = hum and hum:FindFirstChildOfClass("Animator") and hum:FindFirstChildOfClass("Animator"):GetPlayingAnimationTracks()

            if hrp and myRoot and (hrp.Position - myRoot.Position).Magnitude <= detectionRange then
                for _, track in ipairs(animTracks or {}) do
                    local id = tostring(track.Animation.AnimationId):match("%d+")
                    if table.find(autoBlockTriggerAnims, id) then
                        if autoBlockOn and (hrp.Position - myRoot.Position).Magnitude <= detectionRange then
                            if isFacing(myRoot, hrp) then
                                if cooldown and cooldown.Text == "" then
                                    fireRemoteBlock()
                                end
                                if doubleblocktech == true and charges and charges.Text == "1" then
                                    fireRemotePunch()
                                end
                            end
                        end
                    end
                end
            end
        end
    end

    -- Detect if player is playing a block animation, and blockTP is enabled

    -- Predictive Auto Block: Check killer range and time
    if predictiveBlockOn and tick() > predictiveCooldown then
        local killersFolder = workspace:FindFirstChild("Players") and workspace.Players:FindFirstChild("Killers")
        local myChar = lp.Character
        local myHRP = myChar and myChar:FindFirstChild("HumanoidRootPart")
        local myHum = myChar and myChar:FindFirstChild("Humanoid")

        if killersFolder and myHRP and myHum then
            local killerInRange = false

            for _, killer in ipairs(killersFolder:GetChildren()) do
                local hrp = killer:FindFirstChild("HumanoidRootPart")
                if hrp then
                    local dist = (myHRP.Position - hrp.Position).Magnitude
                    if dist <= detectionRange then
                        killerInRange = true
                        break
                    end
                end
            end

            -- Handle killer entering range
            if killerInRange then
                if not killerInRangeSince then
                    killerInRangeSince = tick()  -- Start the timer when the killer enters the range
                elseif tick() - killerInRangeSince >= edgeKillerDelay then
                    -- Block if the killer has stayed in range long enough
                    fireRemoteBlock()
                    predictiveCooldown = tick() + 2  -- Set cooldown to avoid blocking too quickly again
                    killerInRangeSince = nil  -- Reset the timer
                end
            else
                killerInRangeSince = nil  -- Reset timer if the killer leaves range
            end
        end
    end


    local myChar = lp.Character
    local myRoot = myChar and myChar:FindFirstChild("HumanoidRootPart")
    -- Auto Punch
    if autoPunchOn then
        if charges and charges.Text == "1" then
            
            for _, name in ipairs(killerNames) do
                local killer = workspace:FindFirstChild("Players")
                    and workspace.Players:FindFirstChild("Killers")
                    and workspace.Players.Killers:FindFirstChild(name)
                if killer and killer:FindFirstChild("HumanoidRootPart") then
                    local root = killer.HumanoidRootPart
                    if root and myRoot and (root.Position - myRoot.Position).Magnitude <= 10 then

                        -- Trigger punch GUI button
                        fireGuiPunch()

                        -- Fling Punch: Constant TP 2 studs in front of killer for 1 second
                        if flingPunchOn then
                            hiddenfling = true
                            local targetHRP = root
                            task.spawn(function()
                                local start = tick()
                                while tick() - start < 1 do
                                    if lp.Character and lp.Character:FindFirstChild("HumanoidRootPart") and targetHRP and targetHRP.Parent then
                                        local frontPos = targetHRP.Position + (targetHRP.CFrame.LookVector * 2)
                                        lp.Character.HumanoidRootPart.CFrame = CFrame.new(frontPos, targetHRP.Position)
                                    end
                                    task.wait()
                                end
                                hiddenfling = false
                            end)
                        end

                        -- Play custom punch animation if enabled
                        if customPunchEnabled and customPunchAnimId ~= "" then
                            playCustomAnim(customPunchAnimId, true)
                        end

                        break -- Only punch one killer per frame
                    end
                end
            end
        end
    end
    -- === Message-When-Punching: send once per animation start ===
    do
        local myChar = lp.Character
        local hum = myChar and myChar:FindFirstChildOfClass("Humanoid")
        local animator = cachedAnimator
        local currentPlaying = {} -- map animId -> true for tracks playing this frame
        if not animator then
            refreshAnimator()
            animator = cachedAnimator
        end
        if animator then
            local ok, tracks = pcall(function() return animator:GetPlayingAnimationTracks() end)
            if ok and tracks then
                for _, track in ipairs(tracks) do
                    local animId
                    pcall(function() animId = tostring(track.Animation and track.Animation.AnimationId or ""):match("%d+") end)
                    if animId and table.find(punchAnimIds, animId) then
                        currentPlaying[animId] = true
    
                        -- if it wasn't playing last frame, it's a newly-started punch animation
                        if not _punchPrevPlaying[animId] then
                            if messageWhenAutoPunchOn and messageWhenAutoPunch and tostring(messageWhenAutoPunch):match("%S") and (tick() - _lastPunchMessageTime) > MESSAGE_PUNCH_COOLDOWN then
                                pcall(function() sendChatMessage(messageWhenAutoPunch) end)
                                _lastPunchMessageTime = tick()
                            end
                        end
                    end
                end
            end
        end

        -- replace prev state with current state (garbage-collected)
        _punchPrevPlaying = currentPlaying
    end

    do
        local myChar = lp.Character
        local hum = myChar and myChar:FindFirstChildOfClass("Humanoid")
        local animator = cachedAnimator
        local currentPlaying = {} -- map animId -> true for tracks playing this frame
        if not animator then
            refreshAnimator()
            animator = cachedAnimator
        end
        if animator then
            local ok, tracks = pcall(function() return animator:GetPlayingAnimationTracks() end)
            if ok and tracks then
                for _, track in ipairs(tracks) do
                    local animId
                    pcall(function() animId = tostring(track.Animation and track.Animation.AnimationId or ""):match("%d+") end)
                    if animId and table.find(blockAnimIds, animId) then
                        currentPlaying[animId] = true
    
                        -- if it wasn't playing last frame, it's a newly-started punch animation
                        if not _blockPrevPlaying[animId] then
                            if messageWhenAutoBlockOn and messageWhenAutoBlock and tostring(messageWhenAutoBlock):match("%S") and (tick() - _lastBlockMessageTime) > MESSAGE_BLOCK_COOLDOWN then
                                pcall(function() sendChatMessage(messageWhenAutoBlock) end)
                                _lastBlockMessageTime = tick()
                            end
                        end
                    end
                end
            end
        end

        -- replace prev state with current state (garbage-collected)
        _blockPrevPlaying = currentPlaying
    end

    -- === end message-when-punching ===
    if aimPunch then
        if not cachedAnimator then
            refreshAnimator()
        end
        local animator = cachedAnimator
        if animator and myRoot and myChar then
            for _, name in ipairs(killerNames) do
                local killer = workspace:FindFirstChild("Players")
                    and workspace.Players:FindFirstChild("Killers")
                    and workspace.Players.Killers:FindFirstChild(name)
                if killer and killer:FindFirstChild("HumanoidRootPart") then
                    local root = killer.HumanoidRootPart

                    for _, track in ipairs(animator:GetPlayingAnimationTracks()) do
                        -- guard: want only punch tracks (vanilla or custom)
                        local animId = tostring(track.Animation.AnimationId):match("%d+")
                        if table.find(punchAnimIds, animId) then

                            -- Avoid retriggering for the same AnimationTrack within cooldown
                            local last = lastAimTrigger[track]
                            if last and tick() - last < AIM_COOLDOWN then
                                -- already triggered recently for this track -> skip
                            else
                                -- Only trigger when the track is just starting (helps avoid mid/late triggers)
                                local timePos = 0
                                pcall(function() timePos = track.TimePosition or 0 end) -- safe read
                                if timePos <= 0.1 then
                                    -- Lock it so we don't retrigger
                                    lastAimTrigger[track] = tick()

                                    -- Disable autoroate once and aim for AIM_WINDOW seconds
                                    local humanoid = myChar:FindFirstChild("Humanoid")
                                    if humanoid then
                                        humanoid.AutoRotate = false
                                    end

                                    task.spawn(function()
                                        local start = tick()
                                        while tick() - start < AIM_WINDOW do
                                            if myRoot and root and root.Parent then
                                                local predictedPos = root.Position + (root.CFrame.LookVector * predictionValue)
                                                myRoot.CFrame = CFrame.lookAt(myRoot.Position, predictedPos)
                                            end
                                            task.wait()
                                        end
                                        -- restore
                                        if humanoid then
                                            humanoid.AutoRotate = true
                                        end

                                        -- cleanup: allow retrigger later
                                        task.delay(AIM_COOLDOWN - AIM_WINDOW, function()
                                            lastAimTrigger[track] = nil
                                        end)
                                    end)
                                end
                            end
                        end
                    end
                end
            end
        end
    end
end)

Rayfield:LoadConfiguration()