Opensource and No Key

 Rayfield = (:())()  (:())()

 Players = :()
 Workspace = :()
 ReplicatedStorage = :()
 RunService = :()

 LocalPlayer = Players.LocalPlayer


 .ProjectRealCleanup 
    (.ProjectRealCleanup)


 Connections = {}
 Running = 

.ProjectRealCleanup = ()
    Running = 
     _, conn  (Connections) 
         conn  conn.Disconnect 
            conn:()
        
    
    ()





 Remotes = (ReplicatedStorage.Shared.Remotes)

 VirtualUser = :()

 HttpService = :()
 CONFIG_FILE = 




 Config = {
    FloatEnabled = ,
    HeightOffset = , 
    AutoCollectShards = ,
    ShardDelay = ,
    AutoUpgrade = ,
    AutoAttack = ,
    AutoAim = ,
    AntiDeath = ,
    AutoAbility = ,
    AutoSkipWave = ,
    AntiAFK = ,
    InfinitePierce = ,
    MultiShot = ,
    HugeHitbox = ,
    UltraHoming = ,
}

  ()
    (()
         writefile 
            (CONFIG_FILE, HttpService:(Config))
        
    )


  ()
     success = (()
         isfile  (CONFIG_FILE)  readfile 
             data = HttpService:((CONFIG_FILE))
             (data) ==  
                 k, v  (data) 
                    Config[k] = v
                
            
        
    )
     success





 Window = Rayfield:({
    name = ,
    subtitle = ,
    configuration = {
        autoSave = ,
        autoLoad = ,
        fileName = 
    }
})




 hasOldConfig = ((isfile) ==   (CONFIG_FILE))

 hasOldConfig 
    Window:({
        title = ,
        subtitle = ,
        content = ,
        dismissable = ,
        options = {
            {
                text = ,
                style = ,
                callback = ()
                     () 
                        Window:({
                            title = ,
                            content = ,
                        })
                    
                ,
            },
            {
                text = ,
                style = ,
                callback = ()
                    Window:({
                        title = ,
                        content = ,
                    })
                ,
            },
        },
    })


 MainTab = Window:({ name =  })

MainTab:()

MainTab:({
    name = ,
    currentValue = Config.FloatEnabled,
    callback = (Value)
        Config.FloatEnabled = Value
        ()
    ,
})

MainTab:({
    name = ,
    range = {, },
    increment = ,
    suffix = ,
    currentValue = Config.HeightOffset,
    callback = (Value)
        Config.HeightOffset = Value
        ()
    ,
})

MainTab:()

MainTab:({
    name = ,
    currentValue = Config.InfinitePierce,
    callback = (Value)
        Config.InfinitePierce = Value
        ()
    ,
})

MainTab:({
    name = ,
    currentValue = Config.MultiShot,
    callback = (Value)
        Config.MultiShot = Value
        ()
    ,
})

MainTab:({
    name = ,
    currentValue = Config.HugeHitbox,
    callback = (Value)
        Config.HugeHitbox = Value
        ()
    ,
})

MainTab:({
    name = ,
    currentValue = Config.UltraHoming,
    callback = (Value)
        Config.UltraHoming = Value
        ()
    ,
})

MainTab:()

MainTab:({
    name = ,
    currentValue = Config.AutoAim,
    callback = (Value)
        Config.AutoAim = Value
        ()
    ,
})

MainTab:({
    name = ,
    currentValue = Config.AutoAttack,
    callback = (Value)
        Config.AutoAttack = Value
        ()
    ,
})

MainTab:({
    name = ,
    currentValue = Config.AntiDeath,
    callback = (Value)
        Config.AntiDeath = Value
        ()
    ,
})

MainTab:({
    name = ,
    currentValue = Config.AntiAFK,
    callback = (Value)
        Config.AntiAFK = Value
        ()
    ,
})

MainTab:()

MainTab:({
    name = ,
    currentValue = Config.AutoAbility,
    callback = (Value)
        Config.AutoAbility = Value
        ()
    ,
})

MainTab:({
    name = ,
    currentValue = Config.AutoSkipWave,
    callback = (Value)
        Config.AutoSkipWave = Value
        (()
            Remotes.SetAutoSkip.(Value)
        )
        ()
    ,
})

MainTab:({
    name = ,
    currentValue = Config.AutoCollectShards,
    callback = (Value)
        Config.AutoCollectShards = Value
        ()
    ,
})





 ConfigTab = Window:({ name =  })
ConfigTab:()

 hasOldConfig = ((isfile) ==   (CONFIG_FILE))

 hasOldConfig 
    ConfigTab:()
    ConfigTab:({
        name = ,
        callback = ()
             () 
                Window:({
                    title = ,
                    content = ,
                })
            
        ,
    })
    ConfigTab:({
        name = ,
        callback = ()
            Window:({
                title = ,
                content = ,
            })
        ,
    })


ConfigTab:()

ConfigTab:({
    name = ,
    callback = ()
        ()
        Window:({
            title = ,
            content =  .. CONFIG_FILE,
        })
    ,
})

ConfigTab:({
    name = ,
    callback = ()
         () 
            Window:({
                title = ,
                content = ,
            })
        
    ,
})





 cachedFloorFilter = {}

  ()
     filter = {}
     map = Workspace:()
     map 
         floor = map:()
         floor 
            .(filter, floor)
        
         _, child  (map:()) 
             name = child.Name:()
             name:()  name:()  name:() 
                  .(filter, child) 
                    .(filter, child)
                
            
        
    
     Workspace.Terrain 
        .(filter, Workspace.Terrain)
    
     filter


cachedFloorFilter = ()

.(Connections, Workspace.ChildAdded:((child)
     child.Name ==  
        .()
        cachedFloorFilter = ()
    
))




 floorRayParams = RaycastParams.()
floorRayParams.FilterType = .RaycastFilterType.Include

 fallbackRayParams = RaycastParams.()
fallbackRayParams.FilterType = .RaycastFilterType.Exclude

  (xPos, zPos, character)
     #cachedFloorFilter >  
        floorRayParams.FilterDescendantsInstances = cachedFloorFilter
         result = Workspace:(.(xPos, , zPos), .(, -, ), floorRayParams)
         result 
             result.Position.Y
        
    
    fallbackRayParams.FilterDescendantsInstances = {character}
     result = Workspace:(.(xPos, , zPos), .(, -, ), fallbackRayParams)
     result 
         result.Position.Y
    
     





  (playerPos, cameraLookCF)
     bestAimPos = 
     bestBodyPos = 
     bestScore = -.huge
    
    (()
         roundState = (ReplicatedStorage.Client.RoundClient.RoundStateClient)
          (roundState  roundState.state  roundState.state.entityMap)   
        
         _, entity  (roundState.state.entityMap) 
             entity.team ~=   entity.spawnTimer  entity.spawnTimer <=  
                 hitPos = entity.hitboxPosition
                  hitPos 
                    hitPos = entity.position
                     hitPos  entity.hitboxPositionOffset 
                        hitPos = hitPos + entity.hitboxPositionOffset
                    
                
                 hitPos 
                     cameraLookCF 
                         localPoint = cameraLookCF:(hitPos)
                         depth = -localPoint.Z
                         depth >  
                             angularDev = (localPoint.X * localPoint.X + localPoint.Y * localPoint.Y * ) / depth
                             angularDev <=  
                                 score = ( - angularDev) *  - angularDev * depth * 
                                 score > bestScore 
                                    bestScore = score
                                    bestAimPos = entity.position + .(, , )
                                    bestBodyPos = entity.position
                                
                            
                        
                    
                         dist = (hitPos - playerPos).Magnitude
                         score = -dist
                         score > bestScore 
                            bestScore = score
                            bestAimPos = entity.position + .(, , )
                            bestBodyPos = entity.position
                        
                    
                
            
        
    )
    
     bestAimPos, bestBodyPos





  ()
     character = LocalPlayer.Character
      character   
    
     hum = character:()
      hum  hum.Health <=    

     hrp = character:()
      hrp   hrp.Parent   

     camera = Workspace.CurrentCamera

     Config.FloatEnabled 
        hrp.AssemblyLinearVelocity = .zero
        hrp.AssemblyAngularVelocity = .zero
        
         floorY = (hrp.Position.X, hrp.Position.Z, character)
        
         floorY 
             targetY = floorY + Config.HeightOffset
             targetPos = .(hrp.Position.X, targetY, hrp.Position.Z)
            
             Config.AutoAim 
                 camLookCF = camera  .(camera.CFrame.Position, camera.CFrame.Position + camera.CFrame.LookVector * )  
                 aimPos, bodyPos = (hrp.Position, camLookCF)
                 aimPos  bodyPos 
                     lookTarget = .(bodyPos.X, targetY, bodyPos.Z)
                    hrp.CFrame = .(targetPos, lookTarget)
                    
                     camera 
                        camera.CFrame = .(camera.CFrame.Position, aimPos)
                    
                    
                
            
            
            hrp.CFrame = .(targetPos) * hrp.CFrame.Rotation
        
     Config.AutoAim 
         camLookCF = camera  .(camera.CFrame.Position, camera.CFrame.Position + camera.CFrame.LookVector * )  
         aimPos, bodyPos = (hrp.Position, camLookCF)
         aimPos  bodyPos 
             lookTarget = .(bodyPos.X, hrp.Position.Y, bodyPos.Z)
            hrp.CFrame = .(hrp.Position, lookTarget)
            
             camera 
                camera.CFrame = .(camera.CFrame.Position, aimPos)
            
        
    


.(Connections, RunService.RenderStepped:(updateFloatAndAim))




  ()
      Config.AntiDeath   
     character = LocalPlayer.Character
      character   
     hum = character:()
     hum 
        
        (()
            hum:(.HumanoidStateType.Dead, )
        )
        
         hum.Health < hum.MaxHealth 
            hum.Health = hum.MaxHealth
        
    


.(Connections, RunService.RenderStepped:(applyInvincibility))
.(Connections, RunService.Stepped:(applyInvincibility))
.(Connections, RunService.Heartbeat:(applyInvincibility))






.(Connections, Remotes.SpawnCurrencyDrop.((dropId)
     Config.AutoCollectShards 
        (()
            Remotes.RequestClaimCurrencyDrop.(dropId)
        )
    
))

  ()
     ok, cdc = (, ReplicatedStorage.Client.RoundClient.CurrencyDropClient)
      ok   cdc   cdc.postSimulation    
    
     i = ,  
         success, val = (debug.getupvalue, cdc.postSimulation, i)
         success  (val) ==  
             _, entry  (val) 
                 (entry) ==   entry.state ~=  
                     val
                
            
        
    
     


.(()
     Running 
         Config.AutoCollectShards 
            
             dropMap = ()
             dropMap 
                 dropId, data  (dropMap) 
                     data.state ==   data.state ==  
                        data.state = 
                        Remotes.RequestClaimCurrencyDrop.(dropId)
                    
                
            
            
             _, obj  (Workspace:()) 
                 obj:() 
                     name = obj.Parent  obj.Parent.Name:()  
                     name:()  name:()  name:()  name:() 
                        (obj)
                    
                
            
        
        .()
    
)







  ()
     ok, hudClient = (, ReplicatedStorage.Client.HudClient)
      ok   hudClient    
    
     _, fnName  ({, }) 
         fn = hudClient[fnName]
         fn 
             i = ,  
                 success, val = (debug.getupvalue, fn, i)
                  success   
                 (val) ==  
                     k, v  (val) 
                         (v) ==   v.cooldown ~=  
                             val
                        
                    
                
            
        
    
     


.(()
     Running 
         Config.AutoAbility 
             slots = ()
             slots 
                 upgradeName, data  (slots) 
                     (data) ==  
                        data.cooldown = 
                        data.cooldownTimer = 
                        (()
                            Remotes.UseUpgrade.(upgradeName)
                            Remotes.ResetUpgradeCooldown.(upgradeName)
                        )
                    
                
            
        
        .()
    
)




.(()
    .()
     Config.AutoSkipWave 
        (()
            Remotes.SetAutoSkip.()
        )
    
)




(()
     toolClient = (ReplicatedStorage.Client.RoundClient.ToolClient)
    .(()
         Running 
             Config.AutoAttack 
                (()
                    
                    debug.(toolClient.postSimulation, , )
                    
                    
                     toolStateMap = debug.(toolClient.postSimulation, )
                     (toolStateMap) ==  
                         _, item  (toolStateMap) 
                             (item) ==  
                                
                                item.cooldownTimer = 
                                item.burstCooldownTimer = 
                                
                                 (item.info) ==  
                                    item.info.Cooldown = 
                                    item.info.BurstCooldown = 
                                     Config.InfinitePierce  item.info.Pierce =  
                                     Config.MultiShot  item.info.Projectiles =  
                                     Config.HugeHitbox  item.info.ProjectileRadius =  
                                     Config.UltraHoming 
                                        item.info.ProjectileHomingRadius = 
                                        item.info.ProjectileHomingForce = 
                                    
                                    item.info.ProjectileSpread = .zero
                                
                            
                        
                    
                )
            
            .()
        
    )
)






.(Connections, LocalPlayer.Idled:(()
     Config.AntiAFK 
        (()
            VirtualUser:()
            VirtualUser:(.zero)
        )
    
))

.(()
     Running 
         Config.AntiAFK 
            (()
                VirtualUser:()
                VirtualUser:(.zero)
            )
        
        .()
    
)

Window:({
    title = ,
    content = ,
})