Weird aimbot and esp

 
 
  

 
 
 
  
 
 
 
  
  
  
  
   
  
  
  
 
  
  
  
   
  
  
 
  
 
 
 
 
  
  
 
 
 
  
  
  
  
  
 
 
  
  
 
 ReplicatedStorage = :() 
 UserInputService = :()
 NetworkClient = :()
 TweenService = :()
 HttpService = :()
 RunService = :()
 Workspace = :()
 Players = :()

 localPlayer = Players.LocalPlayer 
 mouse = localPlayer:()

 functions = {
    [] = .HttpGet,
    [] = .FindFirstAncestor ,
    [] = .FindFirstAncestorOfClass,
    [] = .FindFirstAncestorWhichIsA,
    [] = .FindFirstChild,
    [] = .FindFirstChildOfClass,
    [] = .FindFirstChildWhichIsA,
    [] = .FindFirstDescendant,
    [] = .IsAncestorOf,
    [] = .IsDescendantOf,
    [] = .IsA,
    [] = .wrap,
    [] = .insert,
    [] = .remove,
    [] = .find,
    [] = UserInputService.GetMouseLocation,
    [] = UserInputService.GetFocusedTextBox,
    [] = UserInputService.IsKeyDown,
    [] = Players.GetPlayers,
    [] = ,
    [] = ,
    [] = .find,
    [] = .sin,
    [] = .cos,
    [] = .rad,
    [] = .floor,
    [] = .abs,
    [] = .huge,
    [] = .clamp,
    [] = Ray.new ,
    [] = RaycastParams.new,
    [] = .new,
    [] = .new,
    [] = .new,
    [] = .new,
    [] = .Angles,
    [] = .fromRGB,
    [] = .fromHSV,
    [] = .new,
    [] = .new,
    [] = ,
    [] = ,
    [] = ,
    [] = ,
    [] = ,
}

 constants = {
    [] = ,
    [] = ,
    [] = ,
    [] = ,
    [] = ,
    [] = ,
    [] = ,
    [] = ,
    [] = ,
    [] = ,
    [] = ,
    [] = ,
    [] = ,
    [] = ,
    [] = ,
    [] = ,
    [] = ,
    [] = ,
    [] = ,
    [] = ,
    [] = ,
    [] = ,
    [] = ,
    [] = ,
    [] = ,
    [] = ,
    [] = ,
    [] = ,
}

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

 insert = .insert 
 remove = .remove
 find = .find
 nVector2 = .new
 nRGB = .fromRGB
 nDrawing = .new

 screenSize = (Workspace.CurrentCamera.ViewportSize.X, Workspace.CurrentCamera.ViewportSize.Y) 
 screenCenter = (Workspace.CurrentCamera.ViewportSize.X/, Workspace.CurrentCamera.ViewportSize.Y/)

 frameworkHook
 framework = {
    connections = {},
    flags = {},
    esp = {},
    labels = {},
    theme = {
        font = .Fonts.Plex,
        fontSize = 
    },
    menu = {
        open = ,
        offset = -,
        bindingKey = ,
        currentItem = ,
        keybinds = {},
        list = {},
        drawings = {},
        hiddenDrawings = {},
    }
}

(framework, {
    __call = (self, key, args)
         key ==  
             i = (args.class)
             prop, val  , args.properties 
                i[prop] = val
            
              args.hidden 
                (self.menu.drawings, i)
            
                (self.menu.hiddenDrawings, i)
             
             i
         key ==  
              (tbl)
                 copy = {}
                 k, v  (tbl) 
                     (v) ==  
                        v = (v)
                    
                    copy[k] = v
                
                 copy
            
             (args.tbl)
         key ==  
             args.drawing 
                 (args.drawing, ) 
                     
                
                     
                
            
                 ()
            
         key ==   
             args.type ==  
                 x
                 y
                 args.relativeFrom 
                    x = args.xScale*args.relativeFrom.Size.X+args.xOffset
                    y = args.yScale*args.relativeFrom.Size.Y+args.yOffset
                
                    x = args.xScale*screenSize.X+args.xOffset
                    y = args.yScale*screenSize.Y+args.yOffset
                
                 (x,y)
             args.type ==  
                 x
                 y

                 args.relativeFrom 
                     (args.relativeFrom, ) 
                        x = args.relativeFrom.Position.X + args.xScale * args.relativeFrom.Size.X + args.xOffset
                        y = args.relativeFrom.Position.y + args.yScale * args.relativeFrom.Size.y + args.yOffset
                    
                        x = args.relativeFrom.Position.x + args.xOffset
                        y = args.relativeFrom.Position.y + args.yOffset
                    
                
                    x = args.xScale * screenSize.X + args.xOffset
                    y = args.yScale * screenSize.Y + args.yOffset
                
                 (x,y)
            
                 
            
         key ==   
              self.connections[args.name] 
                self.connections[args.name] = args.connection:(args.callback)
                 self.connections[args.name]
            
         key ==   
             self.connections[args.name] 
                self.connections[args.name]:()
                self.connections[args.name] = 
            
         key ==  
             copy = (, {tbl = self.flags})
	        (, HttpService:(copy))
         key ==  
             decodedData = HttpService:(())
             i,v  , decodedData 
                self.flags[i] = v
            
             i,v  , self.menu.list 
                v:()
            
         key ==  
             i,v  , framework.connections 
                v:()
                framework.connections[i] = 
            

             i,v  , framework.esp 
                 (v) ==   v.Destroy 
                    v.()
                    framework.esp[i] = 
                
            

             i,v  , framework.menu.drawings 
                 (v) ==   (v, ) 
                    v:()
                    framework.menu.drawings[i] = 
                
            

             i,v  , framework.menu.hiddenDrawings 
                 (v) ==   (v, ) 
                    v:()
                    framework.menu.hiddenDrawings[i] = 
                
            
        
    
})

 framework:(args)
     window = {name = args.name  }

    window.textShadow = (, {class = , properties = {
        Text = window.name,
        Font = self.theme.font,
        Size = self.theme.fontSize,
        Position = (, { = , xScale = , xOffset = , yScale = , yOffset = }),
        Visible = self.menu.open,
        Transparency = ,
        Color = (,,)
    }})

    window.text = (, {class = , properties = {
        Text = window.name,
        Font = self.theme.font,
        Size = self.theme.fontSize,
        Position = (, { = , xScale = , xOffset = -, yScale = , yOffset = -, relativeFrom = window.textShadow}),
        Visible = self.menu.open,
        Transparency = ,
        Color = (,,)
    }})
    
    self.menu.offset += 

     window:(args)
         framework.menu.currentItem 
             framework.menu.currentItem.type ==  
                framework.menu.currentItem:(framework.menu.currentItem.text)
                framework.menu.currentItem:()
             framework.menu.currentItem.type ==  
                framework.menu.currentItem:(framework.menu.currentItem.text.. ..(framework.menu.currentItem.value)..)
                framework.menu.currentItem:()
             framework.menu.currentItem.type ==  
                framework.menu.currentItem:(framework.menu.currentItem.text.. ..(framework.menu.currentItem.value)..)
                framework.menu.currentItem:()
             framework.menu.currentItem.type ==  
                framework.menu.currentItem:(framework.menu.currentItem.text.. ..(framework.menu.currentItem.key)..)
                framework.menu.currentItem:()
             framework.menu.currentItem.type ==  
                framework.menu.currentItem:(framework.menu.currentItem.text.. ..(framework.menu.currentItem.value)..)
                framework.menu.currentItem:()
            
        
        framework.menu.currentItem = args.item
         framework.menu.currentItem.type ==  
            framework.menu.currentItem:(framework.menu.currentItem.text..)
            framework.menu.currentItem:()
         framework.menu.currentItem.type ==  
            framework.menu.currentItem:(framework.menu.currentItem.text.. ..(framework.menu.currentItem.value)..)
            framework.menu.currentItem:()
         framework.menu.currentItem.type ==  
            framework.menu.currentItem:(framework.menu.currentItem.text.. ..(framework.menu.currentItem.value)..)
            framework.menu.currentItem:()
         framework.menu.currentItem.type ==  
            framework.menu.currentItem:(framework.menu.currentItem.text.. ..(framework.menu.currentItem.key)..)
            framework.menu.currentItem:()
         framework.menu.currentItem.type ==  
            framework.menu.currentItem:(framework.menu.currentItem.text.. ..(framework.menu.currentItem.value)..)
            framework.menu.currentItem:()
        

    

     window:(args)
         item = {text = args.text  , drawings = {},  = args.type  }

        item.drawings.textShadow = (, {class = , properties = {
            Text = item.text,
            Font = framework.theme.font,
            Size = framework.theme.fontSize,
            Position = (, { = , xScale = , xOffset = , yScale = , yOffset = framework.menu.offset, relativeFrom = window.textShadow}),
            Visible = framework.menu.open,
            Transparency = ,
            Color = (,,)
        }})
    
        item.drawings.text = (, {class = , properties = {
            Text = item.text,
            Font = framework.theme.font,
            Size = framework.theme.fontSize,
            Position = (, { = , xScale = , xOffset = -, yScale = , yOffset = -, relativeFrom = item.drawings.textShadow}),
            Visible = framework.menu.open,
            Transparency = ,
            Color = (,,)
        }})

         item:(text)
            item.drawings.textShadow.Text = text
            item.drawings.text.Text = text
        

         item:(bool)
             bool 
                item.drawings.text.Color = (,,)
            
                item.drawings.text.Color = (,,)    
            
        

        framework.menu.offset +=  

         #framework.menu.list ==  
            window:({item = item})
        
        
        (framework.menu.list, item)
         item
    

     window:(args)
         item = {text = args.text  , drawings = {},  = args.type  , flag = args.flag  ,  precision = args.offset  , value = args.default  , callback = args.callback  () }

        item.drawings.textShadow = (, {class = , properties = {
            Text = item.text.. ..(item.value)..,
            Font = framework.theme.font,
            Size = framework.theme.fontSize,
            Position = (, { = , xScale = , xOffset = , yScale = , yOffset = framework.menu.offset, relativeFrom = window.textShadow}),
            Visible = framework.menu.open,
            Transparency = ,
            Color = (,,)
        }})
    
        item.drawings.text = (, {class = , properties = {
            Text = item.text.. ..item.value..,
            Font = framework.theme.font,
            Size = framework.theme.fontSize,
            Position = (, { = , xScale = , xOffset = -, yScale = , yOffset = -, relativeFrom = item.drawings.textShadow}),
            Visible = framework.menu.open,
            Transparency = ,
            Color = (,,)
        }})

         item:(args)
            item.value += args.offset
            item.drawings.textShadow.Text = item.text.. ..item.value..
            item.drawings.text.Text = item.text.. ..item.value..
            framework.flags[item.flag] = item.value
            item.(item.value)
        
        framework.flags[item.flag] = item.value
        item.(item.value)

         item:(text)
            item.drawings.textShadow.Text = text
            item.drawings.text.Text = text
        

         item:(bool)
             bool 
                item.drawings.text.Color = (,,)
            
                item.drawings.text.Color = (,,)    
            
        

         item:()
            item.value = framework.flags[item.flag]
            item.drawings.textShadow.Text = item.text.. ..(item.value)..
            item.drawings.text.Text = item.text.. ..(item.value)..
            item.(item.value)
             framework.menu.currentItem == item 
                item.drawings.textShadow.Text = item.text.. ..(item.value)..
                item.drawings.text.Text = item.text.. ..(item.value)..
                item:()
            
        
        
        framework.menu.offset += 

         #framework.menu.list ==  
            window:({item = item})
        
        
        (framework.menu.list, item)
         item
    

     window:(args)
         item = {text = args.text  , drawings = {},  = args.type  , flag = args.flag  , value = args.default  , callback = args.callback  () }

        item.drawings.textShadow = (, {class = , properties = {
            Text = item.text.. ..(item.value)..,
            Font = framework.theme.font,
            Size = framework.theme.fontSize,
            Position = (, { = , xScale = , xOffset = , yScale = , yOffset = framework.menu.offset, relativeFrom = window.textShadow}),
            Visible = framework.menu.open,
            Transparency = ,
            Color = (,,)
        }})
    
        item.drawings.text = (, {class = , properties = {
            Text = item.text.. ..(item.value)..,
            Font = framework.theme.font,
            Size = framework.theme.fontSize,
            Position = (, { = , xScale = , xOffset = -, yScale = , yOffset = -, relativeFrom = item.drawings.textShadow}),
            Visible = framework.menu.open,
            Transparency = ,
            Color = (,,)
        }})

         item:()
            item.value =  item.value
            item.drawings.textShadow.Text = item.text.. ..(item.value)..
            item.drawings.text.Text = item.text.. ..((item.value))..
            framework.flags[item.flag] = item.value
            item.(item.value)
        
        framework.flags[item.flag] = item.value
        item.(item.value)

         item:(text)
            item.drawings.textShadow.Text = text
            item.drawings.text.Text = text
        

         item:(bool)
             bool 
                item.drawings.text.Color = (,,)
            
                item.drawings.text.Color = (,,)    
            
        

         item:()
            item.value = framework.flags[item.flag]
            item.drawings.textShadow.Text = item.text.. ..(item.value)..
            item.drawings.text.Text = item.text.. ..(item.value)..
            item.(item.value)
             framework.menu.currentItem == item 
                item.drawings.textShadow.Text = item.text.. ..(item.value)..
                item.drawings.text.Text = item.text.. ..(item.value)..
                item:()
            
        

        framework.menu.offset += 

         #framework.menu.list ==  
            window:({item = item})
        
        
        (framework.menu.list, item)
         item
    

     window:(args)
         item = {text = args.text  , drawings = {},  = args.type  , value = args.default  , flag = args.flag  , list = args.list  {}, callback = args.callback  () }

        item.drawings.textShadow = (, {class = , properties = {
            Text = item.text.. ..item.value..,
            Font = framework.theme.font,
            Size = framework.theme.fontSize,
            Position = (, { = , xScale = , xOffset = , yScale = , yOffset = framework.menu.offset, relativeFrom = window.textShadow}),
            Visible = framework.menu.open,
            Transparency = ,
            Color = (,,)
        }})
    
        item.drawings.text = (, {class = , properties = {
            Text = item.text.. ..item.value..,
            Font = framework.theme.font,
            Size = framework.theme.fontSize,
            Position = (, { = , xScale = , xOffset = -, yScale = , yOffset = -, relativeFrom = item.drawings.textShadow}),
            Visible = framework.menu.open,
            Transparency = ,
            Color = (,,)
        }})

         item:(option)
            item.value = option
            item.drawings.textShadow.Text = item.text.. ..item.value..
            item.drawings.text.Text = item.text.. ..item.value..
            framework.flags[item.flag] = item.value
            item.(item.value)
        
        framework.flags[item.flag] = item.value
        item.(item.value)

         item:(text)
            item.drawings.textShadow.Text = text
            item.drawings.text.Text = text
        

         item:(bool)
             bool 
                item.drawings.text.Color = (,,)
            
                item.drawings.text.Color = (,,)    
            
        

         item:()
            item.value = framework.flags[item.flag]
            item.drawings.textShadow.Text = item.text.. ..(item.value)..
            item.drawings.text.Text = item.text.. ..(item.value)..
            item.(item.value)
             framework.menu.currentItem == item 
                item.drawings.textShadow.Text = item.text.. ..(item.value)..
                item.drawings.text.Text = item.text.. ..(item.value)..
                item:()
            
        

        framework.menu.offset += 

         #framework.menu.list ==  
            window:({item = item})
        
        
        (framework.menu.list, item)
         item
    

     window:(args)
         item = 
        {
        text = args.text  ,
        key = args.defaultKey.Name  ,
        track = args.trackType  ,
        state = ,
        drawings = {},
         = args.type  ,
        callback = args.callback  () ,
        flag = args.flag  
        }

        item.drawings.textShadow = (, {class = , properties = {
            Text = item.text.. ..(item.key)..,
            Font = framework.theme.font,
            Size = framework.theme.fontSize,
            Position = (, { = , xScale = , xOffset = , yScale = , yOffset = framework.menu.offset, relativeFrom = window.textShadow}),
            Visible = framework.menu.open,
            Transparency = ,
            Color = (,,)
        }})
    
        item.drawings.text = (, {class = , properties = {
            Text = item.text.. ..(item.key)..,
            Font = framework.theme.font,
            Size = framework.theme.fontSize,
            Position = (, { = , xScale = , xOffset = -, yScale = , yOffset = -, relativeFrom = item.drawings.textShadow}),
            Visible = framework.menu.open,
            Transparency = ,
            Color = (,,)
        }})

         item:(Input)
             Input 
                item.key = Input.KeyCode.Name ~=   Input.KeyCode.Name  Input.UserInputType.Name
                item.drawings.textShadow.Text = item.text.. ..(item.key)..
                item.drawings.text.Text = item.text.. ..(item.key)..
                framework.flags[item.flag][] = item.key
            
                item.key = 
                item.state = 
                item.drawings.textShadow.Text = item.text.. 
                item.drawings.text.Text = item.text.. 
                framework.flags[item.flag][] = item.key
            
        

         item:(text)
            item.drawings.textShadow.Text = text
            item.drawings.text.Text = text
        

         item:(bool)
             bool 
                item.drawings.text.Color = (,,)
            
                item.drawings.text.Color = (,,)    
            
        

         item:()
            item.key = framework.flags[item.flag][]
            item.state = framework.flags[item.flag][]
            item.drawings.textShadow.Text = item.text.. ..(item.key)..
            item.drawings.text.Text = item.text.. ..(item.key)..
            item:()
             framework.menu.currentItem == item 
                item.drawings.textShadow.Text = item.text.. ..(item.key)..
                item.drawings.text.Text = item.text.. ..(item.key)..
                item:()
            
        

        framework.menu.offset += 

         #framework.menu.list ==  
            window:({item = item})
        

        framework.flags[item.flag] = {item.key, item.state}

        (framework.menu.keybinds, item)
        (framework.menu.list, item)
         item
    

    (, {connection = UserInputService.InputBegan, name = , callback = (Input)
         self.menu.bindingKey 
            self.menu.bindingKey = 
             Input.KeyCode.Name ~=   Input.KeyCode.Name:()  Input.UserInputType.Name:() 
                 Input.KeyCode.Name ==  
                    self.menu.currentItem:()
                
                    self.menu.currentItem:(Input)
                
            
        
             Input.KeyCode == .KeyCode.Home 
                 i,v  , self.menu.drawings 
                     (v) ==   (v, ) 
                        v.Visible =  v.Visible
                    
                
                self.menu.open =  self.menu.open
             Input.KeyCode == .KeyCode.End 
                ()
             Input.KeyCode == .KeyCode.PageUp 
                ()
             Input.KeyCode == .KeyCode.PageDown 
                ()
            
                 self.menu.open 
                     Input.KeyCode == .KeyCode.KeypadEight 
                         indexCurrent = (framework.menu.list, framework.menu.currentItem)
                         indexCurrent 
                             framework.menu.list[indexCurrent-] ~=  
                                window:({item = framework.menu.list[indexCurrent-]})
                            
                                window:({item = framework.menu.list[#framework.menu.list]})
                            
                        
                    
                     Input.KeyCode == .KeyCode.KeypadTwo 
                         indexCurrent = (framework.menu.list, framework.menu.currentItem)
                         indexCurrent 
                             framework.menu.list[indexCurrent+] ~=  
                                window:({item = framework.menu.list[indexCurrent+]})
                            
                                window:({item = framework.menu.list[]})
                            
                        
                    
                     Input.KeyCode == .KeyCode.KeypadSix 
                         self.menu.currentItem.type ~=  
                             self.menu.currentItem.type ==  
                                self.menu.currentItem:({offset = self.menu.currentItem.precision})
                            
                             self.menu.currentItem.type ==  
                                self.menu.currentItem:()
                            
                             self.menu.currentItem.type ==  
                                 indexCurrent = (self.menu.currentItem.list, self.menu.currentItem.value)
                                 indexCurrent 
                                     self.menu.currentItem.list[indexCurrent+] ~=  
                                        self.menu.currentItem:(self.menu.currentItem.list[indexCurrent+])
                                    
                                
                            
                             self.menu.currentItem.type ==  
                                self.menu.currentItem:(self.menu.currentItem.text..)
                               self.menu.bindingKey = 
                            
                        
                     
                     Input.KeyCode == .KeyCode.KeypadFour 
                         self.menu.currentItem.type ~=  
                             self.menu.currentItem.type ==  
                                self.menu.currentItem:({offset = -self.menu.currentItem.precision})
                            
                             self.menu.currentItem.type ==  
                                self.menu.currentItem:()
                            
                             self.menu.currentItem.type ==  
                                 indexCurrent = (self.menu.currentItem.list, self.menu.currentItem.value)
                                 indexCurrent 
                                     self.menu.currentItem.list[indexCurrent-] ~=  
                                        self.menu.currentItem:(self.menu.currentItem.list[indexCurrent-])
                                    
                                
                            
                             self.menu.currentItem.type ==  
                                self.menu.currentItem:(self.menu.currentItem.text..)
                               self.menu.bindingKey = 
                            
                        
                    
                
                 i,v  , self.menu.keybinds 
                     v.key ~=   
                         .(v.key, ) 
                             Input.UserInputType == .UserInputType[v.key] 
                                 v.track ==  
                                    v.state = 
                                    self.flags[v.flag][] = 
                                    v.(v)
                                 v.track ==  
                                    v.state =  v.state
                                    v.(v)
                                
                            
                        
                             Input.KeyCode == .KeyCode[v.key] 
                                 v.track ==  
                                    v.state = 
                                    self.flags[v.flag][] = 
                                    v.(v)
                                 v.track ==  
                                    v.state =  v.state
                                    v.(v)
                                
                            
                        
                    
                
            
        
    })

    (, {connection = UserInputService.InputEnded, name = , callback = (Input)
         i,v  , self.menu.keybinds 
             v.key ~=  
                 .(v.key, ) 
                     Input.UserInputType == .UserInputType[v.key] 
                         v.track ==  
                            v.state = 
                            self.flags[v.flag][] = 
                            v.(v)
                        
                    
                
                     Input.KeyCode == .KeyCode[v.key] 
                         v.track ==  
                            v.state = 
                            self.flags[v.flag][] = 
                            v.(v)
                        
                    
                
            
        
    })

     window


 framework:(args)
     screenLabel = {text = args.text  , position = args.position  functions[](,constants[]), drawings = {}}

    screenLabel.drawings.labelShadow = (, {hidden = constants[], class = , properties = {
        Text = screenLabel.text,
        Font = framework.theme.font,
        Size = framework.theme.fontSize,
        Position = (, { = , xScale = constants[], xOffset = screenLabel.position.X+constants[], yScale = constants[], yOffset = screenLabel.position.Y+constants[]}),
        Visible = constants[],
        Transparency = constants[],
        Color = functions[](constants[],constants[],constants[])
    }})

    screenLabel.drawings.label = (, {hidden = constants[], class = , properties = {
        Text = screenLabel.text,
        Font = framework.theme.font,
        Size = framework.theme.fontSize,
        Position = (, { = , xScale = constants[], xOffset = screenLabel.position.X, yScale = constants[], yOffset = screenLabel.position.Y}),
        Visible = constants[],
        Transparency = constants[],
        Color = functions[](constants[],constants[],constants[])
    }})
    
     screenLabel:(text)
        screenLabel.text = text
        screenLabel.drawings.labelShadow.Text = text
        screenLabel.drawings.label.Text = text
    

    functions[](self.labels, screenLabel)
     screenLabel


 client = {
    target = constants[],
    targetHitPart = constants[],
    packetVisualizer = constants[],
    offsetVisualizer = constants[],
    cursorOffset = functions[](constants[],constants[]),
    Spin = constants[],
}

 fovCircle = (, {class = , hidden = constants[], properties = {
    Filled = constants[],
    Transparency = constants[],
    Color = functions[](constants[],constants[],constants[]),
}})

 deadZoneCircle = (, {class = , hidden = constants[], properties = {
    Filled = constants[],
    Transparency = constants[],
    Color = functions[](constants[],constants[],constants[]),
}})

 client.(CFRAME)
     x, y, z = CFRAME:()
     functions[](CFRAME.Position) * functions[](constants[],y,constants[])


 client.(val)
     functions[](functions[](val.X),functions[](val.Y))


 client.()
     .CurrentCamera


 client.(chr)
     functions[](chr, ) 
         cf = chr.HumanoidRootPart.CFrame
         cameraCFrame = client.().CFrame
         size = chr.HumanoidRootPart.Size + functions[](constants[],,constants[])

         left, lvis = client.().(client.(),cf.p+(cameraCFrame.RightVector*-size.z))
         right, rvis = client.().(client.(),cf.p+(cameraCFrame.RightVector*size.z))
         top, tvis = client.().(client.(),cf.p+(cameraCFrame.UpVector*size.y)/constants[])
         bottom, bvis = client.().(client.(),cf.p+(cameraCFrame.UpVector*-size.y)/constants[])

          lvis   rvis   tvis   bvis  
             
        

         width = functions[](functions[](left.x - right.x))
         height = functions[](functions[](top.y - bottom.y))

         pos = client.().(client.(),cf.Position)
         size = functions[](width, height)
        size = client.(size)

         client.(functions[](pos.x-(size.x/constants[]), pos.y-(size.y/constants[]))), size
    


 client.(plr)
     cosmetic = :()[constants[]]
     catboyed = functions[]()
    catboyed.Name = 
    cosmetic.Parent = ReplicatedStorage
    catboyed.Parent = plr.Character

     plr.Character  functions[](plr.Character, ) 
         i,v  functions[], plr.Character:() 
             v:() 
                v.Handle.Transparency = constants[]
             v:() 
                v.ShirtTemplate = 
             v:() 
                v.PantsTemplate = 
                v.Color3 = functions[](constants[],constants[],constants[])
            
        
    

     ears = cosmetic.Ears:()
     hair = cosmetic.Hair:()
     earWeld = functions[](,ears)
     hairWeld = functions[](,hair)
    ears.Parent = plr.Character
    hair.Parent = plr.Character

    earWeld.Part0 = ears.Handle
    hairWeld.Part0 = hair.Handle
    earWeld.Part1 = plr.Character.Head
    hairWeld.Part1 = plr.Character.Head

    earWeld.C0 = functions[](constants[],-constants[],constants[])
    hairWeld.C0 = functions[](constants[],-constants[],constants[])


 client.(method, hitPart)
     MaxDist, Target = functions[]
     aimAt = hitPart
     TheirPos, Dist
     method ==  
         _,V  functions[], functions[](Players) 
             V ~= localPlayer  
                 V.Team ~= localPlayer.Team  framework.flags[] 
                     V.Character 
                         functions[](V.Character, ) 
                             functions[](V.Character, )  functions[](V.Character, ) 
                                 Torso = functions[](V.Character, )  functions[](V.Character, )
                                 (functions[](V.Character, )  functions[](V.Character, ).Health > constants[]  framework.flags[])    framework.flags[]  
                                     (Torso.Transparency ~= constants[]  framework.flags[])    framework.flags[]  
                                         ( functions[](V.Character, )  framework.flags[])   framework.flags[]  
                                             aimAt ==  
                                                 mousePoint = functions[](UserInputService)
                                                 headPoint = client.().(client.(),V.Character.Head.Position)
                                                 torsoPoint = client.().(client.(), Torso.Position)
                                                 headMag = (functions[](headPoint.X, headPoint.Y) - functions[](mousePoint.X, mousePoint.Y)).Magnitude
                                                 torsoMag = (functions[](torsoPoint.X, torsoPoint.Y) - functions[](mousePoint.X, mousePoint.Y)).Magnitude
                                                aimAt = headMag < torsoMag    functions[](Torso)
                                            
                                             aimAt ==  
                                                 functions[](Torso) ==  
                                                    aimAt = 
                                                
                                            

                                             Pos, Vis = client.().(client.(), V.Character[aimAt].Position)
                                             Vis 
                                                TheirPos = functions[](Pos.X, Pos.Y)
                                                Dist = (TheirPos - fovCircle.Position).Magnitude
                                                 (Dist < framework.flags[]   framework.flags[]  framework.flags[])  (Dist > framework.flags[]  framework.flags[]   framework.flags[]) 
                                                      localPlayer.Character 
                                                        
                                                    
                                                      functions[](localPlayer.Character, ) 
                                                        
                                                    
                                                     Params = functions[]({FilterDescendantsInstances = {client.(), localPlayer.Character}, FilterType = .RaycastFilterType.Blacklist, IgnoreWater = constants[]})
                                                     Result = Workspace.(Workspace, localPlayer.Character.Head.Position,(V.Character[aimAt].Position - localPlayer.Character.Head.Position).unit*constants[], Params)
                                                     (Result  Result.Instance  functions[](Result.Instance, V.Character)  framework.flags[])   framework.flags[]  
                                                         Dist < MaxDist 
                                                            MaxDist = Dist
                                                            Target = V
                                                        
                                                    
                                                
                                            
                                        
                                         framework.flags[]  framework.flags[][constants[]]  (( client.(.UserInputType.MouseButton2)  framework.flags[])   framework.flags[]) 
                                            client.target = Target
                                            client.targetHitPart = aimAt
                                        
                                            client.target = constants[]
                                            client.targetHitPart = constants[]
                                        
                                    
                                
                            
                        
                    
                
            
        
    
     method ==  
         _,V  functions[], functions[](Players) 
             V ~= localPlayer  
                 V.Team ~= localPlayer.Team  framework.flags[] 
                     V.Character 
                         functions[](V.Character, ) 
                             functions[](V.Character, )  functions[](V.Character, ) 
                                 Torso = functions[](V.Character, )  functions[](V.Character, )
                                 (functions[](V.Character, )  functions[](V.Character, ).Health > constants[]  framework.flags[])    framework.flags[]  
                                     (Torso.Transparency ~= constants[]  framework.flags[])    framework.flags[]  
                                         ( functions[](V.Character, )  framework.flags[])   framework.flags[]  
                                             aimAt ==  
                                                 mousePoint = functions[](UserInputService)
                                                 headPoint = client.().(client.(),V.Character.Head.Position)
                                                 torsoPoint = client.().(client.(), Torso.Position)
                                                 headMag = (functions[](headPoint.X, headPoint.Y) - functions[](mousePoint.X, mousePoint.Y)).Magnitude
                                                 torsoMag = (functions[](torsoPoint.X, torsoPoint.Y) - functions[](mousePoint.X, mousePoint.Y)).Magnitude
                                                aimAt = headMag < torsoMag    functions[](Torso)
                                            
                                             aimAt ==  
                                                 functions[](Torso) ==  
                                                    aimAt = 
                                                
                                            

                                             Pos, Vis = client.().(client.(), V.Character[aimAt].Position)
                                             Vis 
                                                TheirPos = functions[](Pos.X, Pos.Y)
                                                Dist = localPlayer.(localPlayer, V.Character[aimAt].Position)
                                                 Mag = (TheirPos - fovCircle.Position).Magnitude
                                                 (Mag < framework.flags[]   framework.flags[]  framework.flags[])  (Mag > framework.flags[]  framework.flags[]   framework.flags[]) 
                                                      localPlayer.Character 
                                                        
                                                    
                                                      functions[](localPlayer.Character, ) 
                                                        
                                                    
                                                     Params = functions[]({FilterDescendantsInstances = {client.(), localPlayer.Character}, FilterType = .RaycastFilterType.Blacklist, IgnoreWater = constants[]})
                                                     Result = Workspace.(Workspace, localPlayer.Character.Head.Position,(V.Character[aimAt].Position - localPlayer.Character.Head.Position).unit*constants[], Params)
                                                     (Result  Result.Instance  functions[](Result.Instance, V.Character)  framework.flags[])   framework.flags[]  
                                                         Dist < MaxDist 
                                                            MaxDist = Dist
                                                            Target = V
                                                        
                                                    
                                                
                                            
                                        
                                         framework.flags[]  framework.flags[][constants[]]  (( client.(.UserInputType.MouseButton2)  framework.flags[])   framework.flags[]) 
                                            client.target = Target
                                            client.targetHitPart = aimAt
                                        
                                            client.target = constants[]
                                            client.targetHitPart = constants[]
                                        
                                    
                                
                            
                        
                    
                
            
        
    
     method ==  
         _,V  functions[], functions[](Players) 
             V ~= localPlayer  
                 V.Team ~= localPlayer.Team  framework.flags[] 
                     V.Character 
                         functions[](V.Character, ) 
                             functions[](V.Character, )  functions[](V.Character, ) 
                                 Torso = functions[](V.Character, )  functions[](V.Character, )
                                 (functions[](V.Character, )  functions[](V.Character, ).Health > constants[]  framework.flags[])    framework.flags[]  
                                     (Torso.Transparency ~= constants[]  framework.flags[])    framework.flags[]  
                                         ( functions[](V.Character, )  framework.flags[])   framework.flags[]  
                                             aimAt ==  
                                                 mousePoint = functions[](UserInputService)
                                                 headPoint = client.().(client.(),V.Character.Head.Position)
                                                 torsoPoint = client.().(client.(), Torso.Position)
                                                 headMag = (functions[](headPoint.X, headPoint.Y) - functions[](mousePoint.X, mousePoint.Y)).Magnitude
                                                 torsoMag = (functions[](torsoPoint.X, torsoPoint.Y) - functions[](mousePoint.X, mousePoint.Y)).Magnitude
                                                aimAt = headMag < torsoMag    functions[](Torso)
                                            
                                             aimAt ==  
                                                 functions[](Torso) ==  
                                                    aimAt = 
                                                
                                            

                                             Pos, Vis = client.().(client.(), V.Character[aimAt].Position)
                                             Vis 
                                                TheirPos = functions[](Pos.X, Pos.Y)
                                                Dist = functions[](V.Character, ).Health
                                                 Mag = (TheirPos - fovCircle.Position).Magnitude
                                                 (Mag < framework.flags[]   framework.flags[]  framework.flags[])  (Mag > framework.flags[]  framework.flags[]   framework.flags[]) 
                                                      localPlayer.Character 
                                                        
                                                    
                                                      functions[](localPlayer.Character, ) 
                                                        
                                                    
                                                     Params = functions[]({FilterDescendantsInstances = {client.(), localPlayer.Character}, FilterType = .RaycastFilterType.Blacklist, IgnoreWater = constants[]})
                                                     Result = Workspace.(Workspace, localPlayer.Character.Head.Position,(V.Character[aimAt].Position - localPlayer.Character.Head.Position).unit*constants[], Params)
                                                     (Result  Result.Instance  functions[](Result.Instance, V.Character)  framework.flags[])   framework.flags[]  
                                                         Dist < MaxDist 
                                                            MaxDist = Dist
                                                            Target = V
                                                        
                                                    
                                                
                                            
                                        
                                         framework.flags[]  framework.flags[][constants[]]  (( client.(.UserInputType.MouseButton2)  framework.flags[])   framework.flags[]) 
                                            client.target = Target
                                            client.targetHitPart = aimAt
                                        
                                            client.target = constants[]
                                            client.targetHitPart = constants[]
                                        
                                    
                                
                            
                        
                    
                
            
        
    


 client.(Point, Radius)
     Circle = {}

     points = {}
     lines = {}

     Circle.()
        Circle.Stepped:()
         i,v  functions[](lines) 
             functions[](v, ) 
                v:()
            
        
         i,v  functions[](points) 
            points[i] = constants[]
        
    

     ixAxis = Point.X
     iyAxis = Point.Y
     izAxis = Point.Z

     i = constants[], constants[], constants[] 
         xOffset = ixAxis + Radius * functions[](functions[](i))
         zOffset = izAxis + Radius * functions[](functions[](i))
         Result = functions[](xOffset, iyAxis, zOffset)

        functions[](points, Result)
    

     _,v  functions[](points) 
         line = (, {hidden = constants[], class = , properties = {
            Visible = constants[],
            Transparency = constants[],
            Color = functions[](constants[],constants[],constants[]),
            Thickness = constants[],
        }})
        functions[](lines, line)
    

    Circle.Stepped = RunService.RenderStepped:(()
         xAxis = Point.X
         yAxis = Point.Y
         zAxis = Point.Z

         i,v  functions[](points) 
            points[i] = constants[]
        

         i = constants[], constants[], constants[] 
             xOffset = xAxis + Radius * functions[](functions[](i))
             zOffset = zAxis + Radius * functions[](functions[](i))
             Result = functions[](xOffset, yAxis, zOffset)
    
            functions[](points, Result)
        

         i,v  functions[](lines) 
             nextPoint = points[i+constants["1"]]
            if nextPoint ~= constants["nil"] then
                local currentPointPosition,isCurrentVisible = client.returnCamera().WorldToViewportPoint(client.returnCamera(),points[i])
                local nextPointPosition,isNextVisible = client.returnCamera().WorldToViewportPoint(client.returnCamera(),nextPoint)
                if not isCurrentVisible and not isNextVisible then
                    if functions["rawget"](v, "__OBJECT_EXISTS") then
                        v.Visible = constants["false"]
                    end
                else
                    if functions["rawget"](v, "__OBJECT_EXISTS") then
                        v.Visible = constants["true"]
                        v.From = functions["nVector2"](currentPointPosition.X,currentPointPosition.Y)
                        v.To = functions["nVector2"](nextPointPosition.X,nextPointPosition.Y)
                    end
                end
            end
        end
    end)
    return Circle
end

function client.isMouseButtonDown(inputType)
	for _,button in pairs(UserInputService:GetMouseButtonsPressed()) do
		if button.UserInputType == inputType then
			return constants["true"]
		end
	end
	return constants["false"]
end

function client.drawPlayerESP(requestedPlayer)
    local ESP = {name = requestedPlayer.Name, drawings = {}}

    ESP.drawings.inline = framework("draw", {hidden = constants["true"], class = "Square", properties = {
        Transparency = constants["1"],
        Thickness = constants["1"],
        Color = functions["nRGB"](constants["0"], constants["0"], constants["0"]),
    }})
    
    ESP.drawings.box = framework("draw", {hidden = constants["true"], class = "Square", properties = {
        Transparency = constants["1"],
        Thickness = constants["1"],
        Color = functions["nRGB"](constants["255"], constants["255"], constants["255"]),
    }})

    ESP.drawings.outline = framework("draw", {hidden = constants["true"], class = "Square", properties = {
        Transparency = constants["1"],
        Thickness = constants["1"],
        Color = functions["nRGB"](constants["0"], constants["0"], constants["0"]),
    }})

    ESP.drawings.healthBar = framework("draw", {hidden = constants["true"], class = "Square", properties = {
        Transparency = constants["1"],
        Thickness = constants["1"],
        Filled = constants["true"],
        Color = functions["nRGB"](constants["0"], constants["0"], constants["0"]),
    }})

    ESP.drawings.healthBarColor = framework("draw", {hidden = constants["true"], class = "Square", properties = {
        Transparency = constants["1"],
        Thickness = constants["1"],
        Filled = constants["true"],
        Color = functions["nRGB"](constants["0"], constants["255"], constants["0"]),
    }})

    ESP.drawings.nameShadow = framework("draw", {hidden = constants["true"], class = "Text", properties = {
        Transparency = constants["1"],
        Color = functions["nColor3"](constants["0"],constants["0"],constants["0"]),
        Text = ESP.name,
        Center = constants["true"],
        Font = framework.theme.font,
        Size = framework.theme.fontSize,
    }})

    ESP.drawings.name = framework("draw", {hidden = constants["true"], class = "Text", properties = {
        Transparency = constants["1"],
        Color = functions["nColor3"](constants["255"],constants["255"],constants["255"]),
        Text = ESP.name,
        Center = constants["true"],
        Font = framework.theme.font,
        Size = framework.theme.fontSize,
    }})

    ESP.drawings.healthTextShadow = framework("draw", {hidden = constants["true"], class = "Text", properties = {
        Transparency = constants["1"],
        Color = functions["nColor3"](constants["0"],constants["0"],constants["0"]),
        Text = ESP.name,
        Center = constants["true"],
        Font = framework.theme.font,
        Size = framework.theme.fontSize,
    }})

    ESP.drawings.healthText = framework("draw", {hidden = constants["true"], class = "Text", properties = {
        Transparency = constants["1"],
        Color = functions["nColor3"](constants["255"],constants["255"],constants["255"]),
        Text = ESP.name,
        Center = constants["true"],
        Font = framework.theme.font,
        Size = framework.theme.fontSize,
    }})

    function ESP.Destroy()
        ESP.Stepped:Disconnect()
        for i,v in functions["next"], ESP.drawings do
            if functions["type"](v) == 'table' and functions["rawget"](v, '__OBJECT_EXISTS') then
                v.Remove()
            end
        end
    end

    ESP.Stepped = RunService.RenderStepped:Connect(function()
        if not requestedPlayer then
            ESP.Destroy()
            return
        end

        if not (requestedPlayer.Character and functions["FindFirstChildOfClass"](requestedPlayer.Character, "Humanoid") and functions["FindFirstChildOfClass"](requestedPlayer.Character, "Humanoid").Health > constants["0"]) then  
            for i,v in functions["next"], ESP.drawings do
                if functions["rawget"](v, "__OBJECT_EXISTS") then
                    v.Visible = constants["false"]
                end
            end
            return
        end

        local pos, size = client.returnBoundingBox(requestedPlayer.Character)
        if pos then
            local boxvis = size.x+size.y > constants["8"]
            if functions["rawget"](ESP.drawings.name, '__OBJECT_EXISTS') and functions["rawget"](ESP.drawings.nameShadow, '__OBJECT_EXISTS') and functions["rawget"](ESP.drawings.box, '__OBJECT_EXISTS') and functions["rawget"](ESP.drawings.outline, '__OBJECT_EXISTS') and functions["rawget"](ESP.drawings.healthBar, '__OBJECT_EXISTS') and functions["rawget"](ESP.drawings.healthBarColor, '__OBJECT_EXISTS') and functions["rawget"](ESP.drawings.healthTextShadow, '__OBJECT_EXISTS') and functions["rawget"](ESP.drawings.healthText, '__OBJECT_EXISTS') then
                ESP.drawings.name.Visible = (framework.flags["masterESP"] and framework.flags["nameESP"]) and (framework.flags["teamESP"] and requestedPlayer.Team ~= localPlayer.Team or not framework.flags["teamESP"])
                ESP.drawings.nameShadow.Visible = (framework.flags["masterESP"] and framework.flags["nameESP"]) and (framework.flags["teamESP"] and requestedPlayer.Team ~= localPlayer.Team or not framework.flags["teamESP"])
                ESP.drawings.box.Visible = boxvis and (framework.flags["masterESP"] and framework.flags["boxESP"]) and (framework.flags["teamESP"] and requestedPlayer.Team ~= localPlayer.Team or not framework.flags["teamESP"])
                ESP.drawings.outline.Visible = boxvis and (framework.flags["masterESP"] and framework.flags["boxESP"]) and (framework.flags["teamESP"] and requestedPlayer.Team ~= localPlayer.Team or not framework.flags["teamESP"])
                ESP.drawings.inline.Visible = boxvis and (framework.flags["masterESP"] and framework.flags["boxESP"]) and (framework.flags["teamESP"] and requestedPlayer.Team ~= localPlayer.Team or not framework.flags["teamESP"])
                ESP.drawings.healthBar.Visible = boxvis and (framework.flags["masterESP"] and framework.flags["healthESP"]) and (framework.flags["teamESP"] and requestedPlayer.Team ~= localPlayer.Team or not framework.flags["teamESP"])
                ESP.drawings.healthBarColor.Visible = boxvis and (framework.flags["masterESP"] and framework.flags["healthESP"]) and (framework.flags["teamESP"] and requestedPlayer.Team ~= localPlayer.Team or not framework.flags["teamESP"])
                ESP.drawings.healthTextShadow.Visible = boxvis and functions["FindFirstChildOfClass"](requestedPlayer.Character, "Humanoid").Health < functions["FindFirstChildOfClass"](requestedPlayer.Character, "Humanoid").MaxHealth and (framework.flags["masterESP"] and framework.flags["healthESP"]) and (framework.flags["teamESP"] and requestedPlayer.Team ~= localPlayer.Team or not framework.flags["teamESP"])
                ESP.drawings.healthText.Visible = boxvis and functions["FindFirstChildOfClass"](requestedPlayer.Character, "Humanoid").Health < functions["FindFirstChildOfClass"](requestedPlayer.Character, "Humanoid").MaxHealth and (framework.flags["masterESP"] and framework.flags["healthESP"]) and (framework.flags["teamESP"] and requestedPlayer.Team ~= localPlayer.Team or not framework.flags["teamESP"])

                ESP.drawings.box.Size = size
                ESP.drawings.box.Position = pos
                ESP.drawings.outline.Size = size+functions["nVector2"](constants["2"],constants["2"])
                ESP.drawings.outline.Position = pos-functions["nVector2"](constants["1"], constants["1"])
                ESP.drawings.inline.Size = size-functions["nVector2"](constants["2"],constants["2"])
                ESP.drawings.inline.Position = pos+functions["nVector2"](constants["1"], constants["1"])
                ESP.drawings.name.Position = pos+functions["nVector2"](size.x/constants["2"], -constants["20"])
                ESP.drawings.nameShadow.Position = ESP.drawings.name.Position + functions["nVector2"](constants["1"],constants["1"])

                ESP.drawings.box.Color = client.target == requestedPlayer and functions["nRGB"](constants["255"],constants["0"],constants["0"]) or functions["nRGB"](constants["255"],constants["255"],constants["255"])
                ESP.drawings.name.Color = client.target == requestedPlayer and functions["nRGB"](constants["255"],constants["0"],constants["0"]) or functions["nRGB"](constants["255"],constants["255"],constants["255"])
                ESP.drawings.healthText.Color = client.target == requestedPlayer and functions["nRGB"](constants["255"],constants["0"],constants["0"]) or functions["nRGB"](constants["255"],constants["255"],constants["255"])

                ESP.drawings.healthBar.Size = functions["nVector2"](constants["4"], size.y+constants["2"])
                ESP.drawings.healthBar.Position = functions["nVector2"](ESP.drawings.box.Position.x-constants["6"], ESP.drawings.outline.Position.y)
                ESP.drawings.healthBarColor.Size = functions["nVector2"](ESP.drawings.healthBar.Size.x-constants["2"], (ESP.drawings.healthBar.Size.y-constants["2"])*(requestedPlayer.Character:FindFirstChildOfClass("Humanoid").Health/requestedPlayer.Character:FindFirstChildOfClass("Humanoid").MaxHealth))
                ESP.drawings.healthBarColor.Position = (ESP.drawings.healthBar.Position+functions["nVector2"](constants["1"], ESP.drawings.healthBar.Size.y-constants["1"]))-functions["nVector2"](constants["0"], ESP.drawings.healthBarColor.Size.y)
                if ESP.drawings.healthText.Visible then
                    ESP.drawings.healthText.Position = ESP.drawings.healthBarColor.Position-functions["nVector2"](constants["0"], ESP.drawings.healthText.Size/constants["2"])
                    ESP.drawings.healthText.Text = functions["tostring"](functions["floor"](functions["FindFirstChildOfClass"](requestedPlayer.Character, "Humanoid").Health))
                    ESP.drawings.healthTextShadow.Position = ESP.drawings.healthText.Position + functions["nVector2"](constants["1"],constants["1"])
                    ESP.drawings.healthTextShadow.Text = functions["tostring"](functions["floor"](functions["FindFirstChildOfClass"](requestedPlayer.Character, "Humanoid").Health))
                end
            end
        else
            for i,v in functions["next"], ESP.drawings do
                if functions["rawget"](v, "__OBJECT_EXISTS") then
                    v.Visible = constants["false"]
                end
            end
        end
    end)

    framework.esp[ESP.name] = ESP
end

local window = framework:createWindow({name = ""})

local aimbotToggle = window:createToggle({text = "Aimbot", flag = "masterAimbot"})
local aimKey = window:createKeybind({text = "AimKey", defaultKey = Enum.UserInputType.MouseButton1, trackType = "Hold", flag = "aimKey", callback = function(tbl)
    if tbl.state then
        if framework.flags["aimbotSticky"] then
            repeat 
                client.calculateTarget(framework.flags["aimbotMethod"], framework.flags["hitPart"])
                RunService.Heartbeat:Wait()
            until client.target
        end
    else
        client.target = constants["nil"]
        client.targetHitPart = constants["nil"]
    end
end})
local fovSlider = window:createInt({text = "FOV", default = constants["100"], offset = constants["10"], flag = "fovRadius"})
local sensitivitySlider = window:createInt({text = "Sensitivity", default = constants["1"], offset = constants[".1"], flag = "aimbotSensitivity"})
local smoothnessSlider = window:createInt({text = "Smoothness", default = constants["1"], offset = constants["1"], flag = "aimbotSmoothness"})
local fovToggle = window:createToggle({text = "Show FOV", default = constants["true"], flag = "showFOV"})
local deadzoneToggle = window:createToggle({text = "Dead Zone", flag = "deadZone"})
local deadzonefovSlider = window:createInt({text = "Dead Zone FOV", default = constants["20"], offset = constants["10"], flag = "deadZoneFOV"})
local deadzonefovToggle = window:createToggle({text = "Show Dead Zone", default = constants["true"], flag = "showDeadZone"})
local hitPartList = window:createList({text = "Hitbox", default = "Head", list = {"Head", "Torso", "Closest"}, flag = "hitPart"})
local deadToggle = window:createToggle({text = "Dead Check", default = constants["true"], flag = "aimbotDead"})
local teamkillToggle = window:createToggle({text = "Teamkill", flag = "aimbotTeamkill"})
local forcefieldToggle = window:createToggle({text = "ForceField Check", flag = "aimbotForcefield"})
local InvisToggle = window:createToggle({text = "Invisible Check", default = constants["false"], flag = "aimbotInvisible"})
local visibleToggle = window:createToggle({text = "Visible Check", flag = "aimbotVisible"})
local nonStickyToggle = window:createToggle({text = "Non-Sticky Aim", flag = "aimbotSticky"})
local ignoreFOVToggle = window:createToggle({text = "Ignore FOV", flag = "aimbotIgnoreFOV"})
local methodList = window:createList({text = "Method", default = "Mouse", list = {"Mouse", "Distance", "Health"}, flag = "aimbotMethod"})
local dontLockToggle = window:createToggle({text = "Don't Lock when Right Click", flag = "aimbotNoLock"})
local cursorCalibrationKey = window:createKeybind({text = "Cursor Calibration Key", defaultKey = Enum.KeyCode.F1, flag = "cursorCalibrationKey", callback = function(tbl)
    if not tbl.state then
        local mousePosition = functions["GetMouseLocation"](UserInputService)
        if functions["type"](client.offsetVisualizer) == 'table' and functions["rawget"](client.offsetVisualizer, '__OBJECT_EXISTS') then
            client.offsetVisualizer:Remove()
            client.offsetVisualizer = constants["nil"]
        end
        client.cursorOffset = functions["nVector2"](screenCenter.X-mousePosition.X,screenCenter.Y-mousePosition.Y)
    else
        client.offsetVisualizer = framework("draw", {class = "Circle", hidden = constants["true"], properties = {
            Transparency = constants[".5"],
            Radius = constants["10"],
            Color = functions["nRGB"](constants["255"], constants["0"], constants["0"]),
            Filled = constants["true"],
            Visible = constants["true"],
            Position = screenCenter
        }})
    end
end})

local triggerbotToggle = window:createToggle({text = "Triggerbot", flag = "masterTriggerbot"})
local delaySlider = window:createInt({text = "Delay", offset = constants["10"], flag = "triggerbotDelay"})
local durationSlider = window:createInt({text = "Duration", offset = constants["10"], flag = "triggerbotDuration"})
local triggerTeamKillToggle = window:createToggle({text = "Teamkill", flag = "triggerbotTeamkill"})
local triggerDeadCheckToggle = window:createToggle({text = "Dead Check", flag = "triggerbotDead"})
local triggerDeadCheckToggle = window:createToggle({text = "Forcefield Check", flag = "triggerbotForcefield"})
local triggerInvisToggle = window:createToggle({text = "Invisible Check", default = constants["true"], flag = "triggerbotInvisible"})
local triggerKey = window:createKeybind({text = "TriggerKey", defaultKey = Enum.KeyCode.LeftAlt, trackType = "Hold", flag = "triggerKey"})

local espToggle = window:createToggle({text = "ESP", flag = "masterESP"})
local boxToggle = window:createToggle({text = "Boxes", flag = "boxESP"})
local healthToggle = window:createToggle({text = "Health", flag = "healthESP"})
local nameToggle = window:createToggle({text = "Name", flag = "nameESP"})
local hideTeamToggle = window:createToggle({text = "Hide Team", flag = "teamESP"})

local catBoyKey = window:createKeybind({text = "Catboy", defaultKey = Enum.KeyCode.F2, flag = "catBoyKey", callback = function()
    for _,v in functions["next"], functions["GetPlayers"](Players) do
        if v.Character and functions["FindFirstChild"](v.Character, "HumanoidRootPart") then
            if not functions["FindFirstChild"](v.Character, "catboyed") then
                client.catBoy(v)
            end
        end
    end
end})
local packetChokeOnKey = window:createKeybind({text = "Packet Choke", defaultKey = Enum.KeyCode.LeftControl, flag = "packetChokeKey", callback = function(tbl) -- Exploits
    if tbl.state then
        if localPlayer.Character and functions["FindFirstChild"](localPlayer.Character, "HumanoidRootPart") then
            NetworkClient:SetOutgoingKBPSLimit(constants["1"])
            client.packetVisualizer = client.renderCircle(functions["FindFirstChild"](localPlayer.Character, "HumanoidRootPart").Position, constants["5"])
        end
    else
        if client.packetVisualizer then
            NetworkClient:SetOutgoingKBPSLimit(constants["9e9"])
            client.packetVisualizer.Destroy()
            client.packetVisualizer = constants["nil"]
        end 
    end
end})
local clickTpOnKey = window:createKeybind({text = "Click Tp", defaultKey = Enum.KeyCode.F3, flag = "tpKey", callback = function(tbl) -- Exploits
    if localPlayer.Character and localPlayer.Character:FindFirstChild("HumanoidRootPart") and mouse.Hit then
        localPlayer.Character.HumanoidRootPart.CFrame = functions["nCFrame"](mouse.Hit.p.X, mouse.Hit.p.Y, mouse.Hit.p.Z)
    end
end})
local flyToggle = window:createToggle({text = "Fly", flag = "Fly"})
local flySlider = window:createInt({text = "Speed", default = constants["70"], offset = constants["10"], flag = "flySpeed"})
local spinbotToggle = window:createToggle({text = "Spinbot", flag = "Spinbot"})

framework("createConnection", {name = "aimbotStepped", connection = RunService.Heartbeat, callback = function()
    local mousePosition = functions["GetMouseLocation"](UserInputService)
    fovCircle.Radius = framework.flags["fovRadius"]
    fovCircle.Visible = framework.flags["showFOV"]
    fovCircle.Position = mousePosition + client.cursorOffset
    deadZoneCircle.Radius = framework.flags["deadZoneFOV"]
    deadZoneCircle.Visible = framework.flags["showDeadZone"] and framework.flags["deadZone"]
    deadZoneCircle.Position = mousePosition + client.cursorOffset
    if framework.flags["aimbotSticky"] and client.target and client.targetHitPart and client.target.Character then
        if client.target == localPlayer then 
            return 
        end
        if client.target.TeamColor == localPlayer.TeamColor and not framework.flags["aimbotTeamkill"] then
            return
        end
        if not functions["FindFirstChild"](client.target.Character, "Head") then
            return 
        end
        if not functions["FindFirstChild"](client.target.Character, "Torso") and not functions["FindFirstChild"](client.target.Character, "UpperTorso") then
            return 
        end
        local Torso = functions["FindFirstChild"](client.target.Character, "Torso") or functions["FindFirstChild"](client.target.Character, "UpperTorso")
        if Torso.Transparency == constants["1"] and framework.flags["aimbotInvisible"] then 
            return 
        end
        if functions["FindFirstChildOfClass"](client.target.Character, "Humanoid") and functions["FindFirstChildOfClass"](client.target.Character, "Humanoid").Health <= constants["0"] and framework.flags["aimbotDead"] then 
            return 
        end
        if functions["FindFirstChildOfClass"](client.target.Character, "ForceField") and framework.flags["aimbotForcefield"] then 
            return 
        end
        local Pos, Vis = client.returnCamera().WorldToViewportPoint(client.returnCamera(), client.target.Character[client.targetHitPart].Position)
        if not Vis then
            return
        end
        if not localPlayer.Character then
            return
        end
        if not functions["FindFirstChild"](localPlayer.Character, "Head") then
            return
        end
        if client.isMouseButtonDown(Enum.UserInputType.MouseButton2) and framework.flags["aimbotNoLock"] then
            return
        end
        local Params = functions["nRayParams"]({FilterDescendantsInstances = {client.returnCamera(), localPlayer.Character}, FilterType = Enum.RaycastFilterType.Blacklist, IgnoreWater = constants["true"]})
        local Result = Workspace.Raycast(Workspace, localPlayer.Character.Head.Position, (client.target.Character[client.targetHitPart].Position - localPlayer.Character.Head.Position).unit*constants["5000"], Params)
        if (not Result.Instance or not functions["IsDescendantOf"](Result.Instance, client.target.Character)) and framework.flags["aimbotVisible"] then
            return
        end
        local TheirPos = functions["nVector2"](Pos.X, Pos.Y)
        local Mag = (TheirPos - fovCircle.Position).Magnitude
        if (Mag <= framework.flags["fovRadius"] and not framework.flags["aimbotIgnoreFOV"] or framework.flags["aimbotIgnoreFOV"]) then
            if (Mag >= framework.flags["deadZoneFOV"] and framework.flags["deadZone"] or not framework.flags["deadZone"]) then
                mousemoverel(((Pos.X - fovCircle.Position.X)*framework.flags["aimbotSensitivity"])/framework.flags["aimbotSmoothness"], ((Pos.Y - fovCircle.Position.Y)*framework.flags["aimbotSensitivity"])/framework.flags["aimbotSmoothness"])
            end
        end
    else
        client.calculateTarget(framework.flags["aimbotMethod"], framework.flags["hitPart"])
        if client.target then
            local Pos, Vis = client.returnCamera().WorldToViewportPoint(client.returnCamera(), client.target.Character[client.targetHitPart].Position)
            mousemoverel(((Pos.X - fovCircle.Position.X)* framework.flags["aimbotSensitivity"])/framework.flags["aimbotSmoothness"], ((Pos.Y - fovCircle.Position.Y)*framework.flags["aimbotSensitivity"])/framework.flags["aimbotSmoothness"])
        end
    end
end})

framework("createConnection", {name = "triggerbotStepped", connection = RunService.Heartbeat, callback = function()
    if framework.flags["masterTriggerbot"] and framework.flags["triggerKey"][constants["2"]] then
        local unitRay = client.returnCamera().ViewportPointToRay(client.returnCamera(), fovCircle.Position.X, fovCircle.Position.Y)
        local Params = functions["nRayParams"]({FilterDescendantsInstances = {client.returnCamera(), localPlayer.Character}, FilterType = Enum.RaycastFilterType.Blacklist, IgnoreWater = constants["true"]})
        local Result = Workspace.Raycast(Workspace, unitRay.Origin, unitRay.Direction * constants["5000"], Params)
        if Result then
            for _,V in functions["next"], functions["GetPlayers"](Players) do
                if V == localPlayer then 
                    continue 
                end
                if V.Team == localPlayer.Team and not framework.flags["triggerbotTeamkill"] then
                    continue
                end
                if not V.Character then 
                    continue 
                end
                if functions["FindFirstChildOfClass"](V.Character, "Humanoid") and functions["FindFirstChildOfClass"](V.Character, "Humanoid").Health <= constants["0"] and framework.flags["triggerbotDead"] then 
                    continue 
                end
                if not functions["FindFirstChild"](V.Character, "Torso") and not functions["FindFirstChild"](V.Character, "UpperTorso") then
                    continue 
                end
                local Torso = functions["FindFirstChild"](V.Character, "Torso") or functions["FindFirstChild"](V.Character, "UpperTorso")
                if Torso.Transparency == constants["1"] and framework.flags["triggerbotInvisible"] then 
                    continue 
                end
                if functions["FindFirstChildOfClass"](V.Character, "ForceField") and framework.flags["triggerbotForcefield"] then 
                    continue 
                end
                if functions["IsDescendantOf"](Result.Instance, V.Character) then
                    if framework.flags["triggerbotDelay"] > constants["0"] then 
                        functions["wait"](framework.flags["triggerbotDelay"]/constants["1000"]) 
                    end
                     mouse1press()
                     wait(framework.flags["triggerbotDuration"])
                     mouse1release()
                 end
            end
        end
    end
end})

framework("createConnection", {name = "movementStepped", connection = RunService.Heartbeat, callback = function()
    if localPlayer.Character and functions["FindFirstChild"](localPlayer.Character, "HumanoidRootPart") and functions["FindFirstChildOfClass"](localPlayer.Character, "Humanoid") then
        local camCFrame = client.returnCamera().CFrame
        local humanoid = functions["FindFirstChildOfClass"](localPlayer.Character, "Humanoid")
        local rootPart = functions["FindFirstChild"](localPlayer.Character, "HumanoidRootPart")
        if framework.flags["Fly"] then
            if not functions["GetFocusedTextBox"](UserInputService) then
                local eVector = functions["nVector3"]()
                local rVector, lVector, uVector = camCFrame.RightVector, camCFrame.LookVector, camCFrame.UpVector
                if functions["IsKeyDown"](UserInputService, "W") then
                    eVector = eVector + lVector
                end
                if functions["IsKeyDown"](UserInputService, "S") then
                    eVector = eVector - lVector
                end
                if functions["IsKeyDown"](UserInputService, "D") then
                    eVector = eVector + rVector
                end
                if functions["IsKeyDown"](UserInputService, "A") then
                    eVector = eVector - rVector
                end
                if functions["IsKeyDown"](UserInputService, "Space") then
                    eVector = eVector + uVector
                end
                if functions["IsKeyDown"](UserInputService, "LeftShift") then
                    eVector = eVector - uVector
                end
                if eVector.Unit.X == eVector.Unit.X then
                    rootPart.AssemblyLinearVelocity  = eVector.Unit * framework.flags["flySpeed"]
                end
                rootPart.Anchored = eVector == functions["nVector3"]()
            end
        else
            rootPart.Anchored = constants["false"]
        end
        if framework.flags["Spinbot"] then
            client.Spin = functions["clamp"](client.Spin + constants["10"], constants["0"], constants["360"])
            if client.Spin == constants["360"] then 
                client.Spin = constants["0"]
            end
            humanoid.AutoRotate = constants["false"]
            local Angle = constants["0"]
            Angle = Angle + functions["rad"](client.Spin)
            local CFramePos = functions["nCFrame"](rootPart.Position) * functions["nAngles"](constants["0"], Angle, constants["0"])
            rootPart.CFrame = client.rotateYaw(CFramePos)
        else
            humanoid.AutoRotate = constants["true"]
        end
    end
end})

for _,v in functions["next"], functions["GetPlayers"](Players) do
    if v ~= constants["nil"] and v ~= localPlayer then
        client.drawPlayerESP(v)
    end
end

framework("createConnection", {name = "ConfigPlayerAdded", connection = Players.PlayerAdded, callback = function(Player)
    if Player ~= constants["nil"] and Player ~= localPlayer then
        client.drawPlayerESP(Player)
    end
end})