N0IR op1 script

 Players           = :()
 StarterGui        = :()
 RunService        = :()
 UserInputService  = :()
 Workspace         = :()
 CoreGui           = :()
 ReplicatedStorage = :()
 notification      = :()

 LocalPlayer = Players.LocalPlayer
 Camera      = Workspace.CurrentCamera



 Rayfield = (:())()

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

.(()
    (()
         sg
         _ = ,  
            sg = CoreGui:()
             sg   
            .()
        
          sg   

         OFFWHITE = .(, , )
         BLACK    = .(, , )

          (c)
             (c.R *  + c.G *  + c.B * ) < 
        

         _, d  (sg:()) 
             d:()  d:() 
                 (d.BackgroundColor3)  d.BackgroundColor3 = OFFWHITE 
             d:()  d:()  d:() 
                  (d.TextColor3)  d.TextColor3 = BLACK 
                 d:()  (d.BackgroundColor3) 
                    d.BackgroundColor3 = OFFWHITE
                
             d:()  d:() 
                 (d.ImageColor3)  d.ImageColor3 = BLACK 
            
        
    )
)



 TabSilent   = Window:(,  )
 TabFirerate = Window:(,    )
 TabESP      = Window:(,         )
 TabChams    = Window:(,       )



  (src)
      getactors   run_on_actor 
        ()
         
    
     actors = ()
     actor  = actors  actors[]
      actor  ()   
     ok, err = (run_on_actor, actor, src)
      ok  ( .. (err)) 
     ok



  (instance)
      instance   instance:()    
     parent = instance.Parent

     isHard = instance:()
         (parent  parent:())

     isSoft = instance:()
         (parent  parent:())

    
     instance.Transparency >=    instance.CanCollide 
         
    

     isSoft      
     isHard  
        
         dims = { instance.Size.X, instance.Size.Y, instance.Size.Z }
        .(dims)
         dims[] >     
         
    

    
     dims = { instance.Size.X, instance.Size.Y, instance.Size.Z }
    .(dims)

     instance:() 
         dims[] <= 
    

     dims[] < 




  (origin, targetPos, ignoreList)
     direction = targetPos - origin
     params    = RaycastParams.()
    params.FilterType = .RaycastFilterType.Exclude
    params.FilterDescendantsInstances = ignoreList  {}

     remaining = direction
     pos       = origin

     _ = ,    
         result = Workspace:(pos, remaining, params)
          result      

          (result.Instance) 
               
        

        
        params:(result.Instance)
         traveled = result.Position - origin
        remaining = direction - traveled
        pos = result.Position + remaining.Unit * 

         remaining.Magnitude <     
    

     




  (m)
     m  m:()  m:() == 


 PlayerToVM = {}  

  (plr, char)
     plr == LocalPlayer   
    .(()
         torso = char:(, )
          torso   

         (torso.Parent) 
            PlayerToVM[plr] = torso.Parent
            
        

         conn
        conn = torso.AncestryChanged:(()
            conn:()
             vm = torso.Parent
             (vm) 
                PlayerToVM[plr] = vm
            
        )

        char.AncestryChanged:(()
              char:()  conn 
                conn:(); conn = 
            
        )
    )


  (plr)
     plr == LocalPlayer   
     plr.Character  (plr, plr.Character) 
    plr.CharacterAdded:((c) (plr, c) )
    plr.CharacterRemoving:(()
        PlayerToVM[plr] = 
    )


 _, p  (Players:())  (p) 
Players.PlayerAdded:(hookPlayer)
Players.PlayerRemoving:((p) PlayerToVM[p] =  )



 SA = {
    Enabled     = ,
    AutoShoot   = ,
    FOV         = ,
    TargetPart  = ,
    TeamCheck   = ,
    WallbangOnly = ,  
}


 fovCircle       = .()
fovCircle.Visible     = 
fovCircle.Thickness   = 
fovCircle.Color       = .(, , )
fovCircle.Filled      = 
fovCircle.NumSides    = 
fovCircle.Transparency = 

RunService.RenderStepped:(()
    Camera = Workspace.CurrentCamera
     center = Camera.ViewportSize / 
    fovCircle.Position = center
    fovCircle.Radius   = SA.FOV
    fovCircle.Visible  = SA.Enabled
)

 CUSTOM_PARTS = {
    ,,,,
    ,,,,,,
}

  (plr)
      SA.TeamCheck    
     a, b = LocalPlayer.Team, plr.Team
     a  b  a == b


  ()
     UserInputService:()


  (vm)
     parts = {}
     SA.TargetPart ==  
         h = vm:()
         h  parts[#parts+] = h 
    
         _, name  (CUSTOM_PARTS) 
             p = vm:(name)
             p  parts[#parts+] = p 
        
    
     parts


  ()
     mouse     = UserInputService:()
     cam       = Workspace.CurrentCamera
     best      = 
     bestDist2 = SA.FOV * SA.FOV

     vms = Workspace:()
      vms    

     _, vm  (vms:()) 
         vm.Name ==    
          vm:()   

         torso = vm:()
          torso  torso.Transparency >=    

         head = vm:()
          head   head:()   

         screenPos, onScreen = cam:(head.Position)
          onScreen  screenPos.Z <=    

         dx = screenPos.X - mouse.X
         dy = screenPos.Y - mouse.Y
         d2 = dx*dx + dy*dy

         d2 < bestDist2 
            bestDist2 = d2
            best      = head
        
    

     best



 SILENT_SRC = 



 silentLoaded = 

  ()
     silentLoaded   
    silentLoaded = 
    (()[], SILENT_SRC)


  ()
    silentLoaded = 
    
    (()[], )
    ()


 isHoldingM1 = 

  ()
     isHoldingM1   
    isHoldingM1 = 
    ()


  ()
      isHoldingM1   
    isHoldingM1 = 
    ()



RunService.Heartbeat:((dt)
      SA.Enabled 
        ()
        
    

    ()

      SA.AutoShoot 
        ()
        
    

     target = ()

      target 
        ()
        
    

     camPos    = Camera.CFrame.Position
     targetPos = target.Position

     ignore = {}
     LocalPlayer.Character 
         _, v  (LocalPlayer.Character:()) 
             v:()  ignore[#ignore+] = v 
        
    

    
     losParams = RaycastParams.()
    losParams.FilterType = .RaycastFilterType.Exclude
    losParams.FilterDescendantsInstances = ignore

     losResult = Workspace:(camPos, targetPos - camPos, losParams)
     shootable =  losResult  (camPos, targetPos, ignore)

     shootable 
        ()
    
        ()
    
)



 FIRERATE_SRC = 

 FR = { enabled = , mult =  }

  (mult)
     src = .(FIRERATE_SRC, , (mult))
    (src)




 ESPCfg = {
    Enabled       = ,
    TeamCheck     = ,
    MaxDist       = ,
    ShowDead      = ,

    EnemyFill     = .(, , ),
    EnemyOutline  = .(, , ),
    TeamFill      = .(, , ),
    TeamOutline   = .(, , ),
    FillTransp    = ,
    OutlineTransp = ,

    BoxEnabled    = ,
    BoxColor      = .(, , ),
    BoxThickness  = ,

    Names         = ,
    NameColor     = .(, , ),
    Distance      = ,
    DistColor     = .(, , ),
    HealthBar     = ,
    HPHigh        = .(, , ),
    HPMid         = .(, , ),
    HPLow         = .(, , ),

    
    TeamCheckFrames = ,
}

 ESPTrack = {}  
 frameCounter = 

  (pct)
     pct >    ESPCfg.HPHigh 
     pct >    ESPCfg.HPMid  
     ESPCfg.HPLow


  (plr)
      ESPCfg.TeamCheck    
     LocalPlayer.Team ~= 
         plr.Team ~= 
         LocalPlayer.Team == plr.Team



  ()
     lines = {}
     i = ,  
         l = .()
        l.Visible   = 
        l.Thickness = ESPCfg.BoxThickness
        l.Color     = ESPCfg.BoxColor
        l.Transparency = 
        lines[i] = l
    
     lines


  (lines)
      lines   
     _, l  (lines)  (() l:() ) 


  (lines)
      lines   
     _, l  (lines)  l.Visible =  


  (lines, vm)
      lines   vm   
     cam = Workspace.CurrentCamera
      cam   

     ok, cf, size = (()  vm:() )
      ok   cf   size  (lines)  

     half = size / 
     corners3D = {
        .(-half.X, -half.Y, -half.Z),
        .(-half.X, -half.Y,  half.Z),
        .(-half.X,  half.Y, -half.Z),
        .(-half.X,  half.Y,  half.Z),
        .( half.X, -half.Y, -half.Z),
        .( half.X, -half.Y,  half.Z),
        .( half.X,  half.Y, -half.Z),
        .( half.X,  half.Y,  half.Z),
    }

     minX, minY =  .huge,  .huge
     maxX, maxY = -.huge, -.huge
     anyVisible = 

     _, pt  (corners3D) 
         s = cam:(cf:(pt))
         s.Z >  
            anyVisible = 
             s.X < minX  minX = s.X 
             s.Y < minY  minY = s.Y 
             s.X > maxX  maxX = s.X 
             s.Y > maxY  maxY = s.Y 
        
    

      anyVisible  (maxX - minX) <   (maxY - minY) <  
        (lines) 
    

    
     tl = .(minX, minY)
     tr = .(maxX, minY)
     bl = .(minX, maxY)
     br = .(maxX, maxY)

    lines[].From = tl; lines[].To = tr; lines[].Visible =   
    lines[].From = bl; lines[].To = br; lines[].Visible =   
    lines[].From = tl; lines[].To = bl; lines[].Visible =   
    lines[].From = tr; lines[].To = br; lines[].Visible =   

     _, l  (lines) 
        l.Color     = ESPCfg.BoxColor
        l.Thickness = ESPCfg.BoxThickness
    



  (t)
     t  t.bb 
        (() t.bb:() )
        t.bb = 
    


  (plr)
     t = ESPTrack[plr]
      t   
    (t)

     char = plr.Character
     root = char  char:()
      root   

     bb = .()
    bb.Name           =  .. plr.UserId
    bb.Size           = .(, )
    bb.StudsOffset    = .(, , )
    bb.AlwaysOnTop    = 
    bb.ResetOnSpawn   = 
    bb.LightInfluence = 
    bb.Adornee        = root
    bb.Enabled        = 
    bb.Parent         = CoreGui

      (name, sz, yPos, font)
         l = .()
        l.Name                   = name
        l.Size                   = .(,,,sz)
        l.Position               = .(, yPos)
        l.BackgroundTransparency = 
        l.Font                   = font  .Font.GothamBold
        l.TextSize               = sz
        l.TextStrokeTransparency = 
        l.TextStrokeColor3       = .(,,)
        l.Text                   = 
        l.Parent                 = bb
         l
    

    (, , )
    (, , , .Font.Gotham)

     hpBg = .()
    hpBg.Name             = 
    hpBg.Size             = .(,,,)
    hpBg.Position         = .(, )
    hpBg.BackgroundColor3 = .(,,)
    hpBg.BorderSizePixel  = 
    hpBg.Parent           = bb
    .(, hpBg).CornerRadius = .(,)

     hpFg = .()
    hpFg.Name             = 
    hpFg.Size             = .(,)
    hpFg.BackgroundColor3 = ESPCfg.HPHigh
    hpFg.BorderSizePixel  = 
    hpFg.Parent           = hpBg
    .(, hpFg).CornerRadius = .(,)

    t.bb = bb


  (plr)
     t = ESPTrack[plr]
      t   
     t.vmConn   (() t.vmConn:() ) 
     t.bb       (() t.bb:() ) 
     t.hl       (() t.hl:() ) 
    (t.box)
    ESPTrack[plr] = 


  (plr, vm)
    (plr)

     team = (plr)
     hl   = .()
    hl.FillColor           = team  ESPCfg.TeamFill     ESPCfg.EnemyFill
    hl.OutlineColor        = team  ESPCfg.TeamOutline  ESPCfg.EnemyOutline
    hl.FillTransparency    = ESPCfg.FillTransp
    hl.OutlineTransparency = ESPCfg.OutlineTransp
    hl.DepthMode           = .HighlightDepthMode.AlwaysOnTop
    hl.Enabled             = 
    hl.Parent              = vm

    ESPTrack[plr] = {
        hl     = hl,
        bb     = ,
        box    = (),
        vmConn = ,
    }

    (plr)

     vmConn
    vmConn = vm.AncestryChanged:(()
          vm:(Workspace) 
            vmConn:()
             t = ESPTrack[plr]
             t  t.vmConn == vmConn 
                (t)
                (t.box)
                t.hl = 
            
        
    )

    ESPTrack[plr].vmConn = vmConn


  (plr, char)
     plr == LocalPlayer   
    .(()
         torso = char:(, )
          torso   

         (torso.Parent) 
            (plr, torso.Parent)
            
        

         conn
        conn = torso.AncestryChanged:(()
            conn:()
             vm = torso.Parent
             (vm) 
                (plr, vm)
            
        )

        char.AncestryChanged:(()
              char:()  conn 
                conn:(); conn = 
            
        )
    )


  (plr)
     plr == LocalPlayer   
     plr.Character  (plr, plr.Character) 
    plr.CharacterAdded:((c)
        .(, ()
             ESPTrack[plr]  (plr) 
        )
        (plr, c)
    )
    plr.CharacterRemoving:(()
         t = ESPTrack[plr]
         t  t.bb  t.bb.Enabled =  
        (t  t.box)
    )


 _, p  (Players:())  (p) 
Players.PlayerAdded:(hookESPPlayer)
Players.PlayerRemoving:(destroyESPEntry)


RunService.RenderStepped:(()
    frameCounter += 
     cam = Workspace.CurrentCamera

     plr, t  (ESPTrack) 
         hl  = t.hl
         bb  = t.bb
         box = t.box

          plr.Parent 
            (plr)
            
        

          hl   hl.Parent 
             hl  t.hl =  
             bb  bb.Enabled =  
            (box)
            
        

         char = plr.Character
         hum  = char  char:()
         root = char  char:()

        
         team = 
         frameCounter % ESPCfg.TeamCheckFrames ==  
            team = (plr)
        
            
            team = hl.FillColor == ESPCfg.TeamFill
        

         alive = hum  hum.Health > 
         show  = ESPCfg.Enabled
             (ESPCfg.ShowDead  alive)
             ( ESPCfg.TeamCheck   team)

         show  root  cam 
             d = (cam.CFrame.Position - root.Position).Magnitude
             d > ESPCfg.MaxDist  show =  
        

          show 
            hl.Enabled = 
             bb  bb.Enabled =  
            (box)
            
        

        
        hl.Enabled             = 
        hl.FillColor           = team  ESPCfg.TeamFill     ESPCfg.EnemyFill
        hl.OutlineColor        = team  ESPCfg.TeamOutline  ESPCfg.EnemyOutline
        hl.FillTransparency    = ESPCfg.FillTransp
        hl.OutlineTransparency = ESPCfg.OutlineTransp

        
         ESPCfg.BoxEnabled 
            (box, hl.Parent)
        
            (box)
        

        
         bb  root 
             bb.Adornee ~= root  bb.Adornee = root 
            bb.Enabled = 

             dist    = (cam.CFrame.Position - root.Position).Magnitude
             nameLbl = bb:()
             distLbl = bb:()
             hpBg    = bb:()

             nameLbl 
                nameLbl.Visible    = ESPCfg.Names
                nameLbl.Text       = plr.DisplayName
                nameLbl.TextColor3 = ESPCfg.NameColor
            
             distLbl 
                distLbl.Visible    = ESPCfg.Distance
                distLbl.Text       = .(, .(dist))
                distLbl.TextColor3 = ESPCfg.DistColor
            
             hpBg 
                hpBg.Visible = ESPCfg.HealthBar
                 ESPCfg.HealthBar  hum 
                     pct = .(hum.Health / .(hum.MaxHealth,), , )
                     fg  = hpBg:()
                     fg 
                        fg.Size             = .(pct, )
                        fg.BackgroundColor3 = (pct)
                    
                
            
        
    
)



 ChamsCfg = {
    Enabled      = ,
    Rainbow      = ,
    Metallic     = ,
    Pulse        = ,
    Color        = .(, , ),
    Transparency = ,
    RainbowSpeed = ,
}

 ChamsHL  = 
 ChamsVM  = 
 ChamsHue = 

  ()
     vms = Workspace:()
     vms  vms:()


  ()
     ChamsHL  (() ChamsHL:() ) 
    ChamsHL = ; ChamsVM = 


  ()
     vm = ()
      ChamsCfg.Enabled   vm  ()  
     ChamsHL  ChamsVM == vm   
    ()

     hl = .()
    hl.Name       = 
    hl.Adornee    = vm
    hl.DepthMode  = .HighlightDepthMode.AlwaysOnTop
    hl.Parent     = CoreGui
    ChamsHL = hl; ChamsVM = vm


RunService.RenderStepped:((dt)
    ()
      ChamsHL   

     ChamsCfg.Rainbow 
        ChamsHue = (ChamsHue + dt * ChamsCfg.RainbowSpeed * ) % 
         c = .(ChamsHue, , )
        ChamsHL.FillColor    = c
        ChamsHL.OutlineColor = c
    
        ChamsHL.FillColor    = ChamsCfg.Color
        ChamsHL.OutlineColor = ChamsCfg.Color
    

     ChamsCfg.Metallic 
        ChamsHL.FillColor = ChamsHL.FillColor:(.(,,), )
    

    ChamsHL.FillTransparency =
        ChamsCfg.Pulse
         .(.(.() * ))
         ChamsCfg.Transparency

    ChamsHL.OutlineTransparency = 
)



TabSilent:()

TabSilent:({
    Name         = ,
    CurrentValue = ,
    Flag         = ,
    Callback     = (v)
        SA.Enabled = v
        fovCircle.Visible = v
         v  () 
    ,
})

TabSilent:({
    Name         = ,
    CurrentValue = ,
    Flag         = ,
    Callback     = (v)
        SA.AutoShoot = v
          v  () 
    ,
})

TabSilent:({
    Name         = ,
    CurrentValue = ,
    Flag         = ,
    Callback     = (v)
        SA.WallbangOnly = v
    ,
})

TabSilent:({
    Name         = ,
    CurrentValue = ,
    Flag         = ,
    Callback     = (v)
        SA.TeamCheck = v
    ,
})

TabSilent:({
    Name         = ,
    Range        = {, },
    Increment    = ,
    Suffix       = ,
    CurrentValue = ,
    Flag         = ,
    Callback     = (v)
        SA.FOV = v
         SA.Enabled  () 
    ,
})

TabSilent:({
    Name          = ,
    Options       = {, },
    CurrentOption = {},
    Flag          = ,
    Callback      = (opt)
        SA.TargetPart = ((opt) == )  opt[]  opt
         SA.Enabled  () 
    ,
})

TabSilent:()



TabFirerate:()

TabFirerate:({
    Name         = ,
    CurrentValue = ,
    Flag         = ,
    Callback     = (v)
        FR.enabled = v
        (v  FR.mult  )
    ,
})

TabFirerate:({
    Name         = ,
    Range        = {, },
    Increment    = ,
    Suffix       = ,
    CurrentValue = ,
    Flag         = ,
    Callback     = (v)
        FR.mult = v
         FR.enabled  (v) 
    ,
})



TabESP:()

TabESP:({
    Name         = ,
    CurrentValue = ,
    Flag         = ,
    Callback     = (v) ESPCfg.Enabled = v ,
})

TabESP:({
    Name         = ,
    CurrentValue = ,
    Flag         = ,
    Callback     = (v) ESPCfg.TeamCheck = v ,
})

TabESP:({
    Name         = ,
    CurrentValue = ,
    Flag         = ,
    Callback     = (v) ESPCfg.ShowDead = v ,
})

TabESP:()

TabESP:({
    Name         = ,
    CurrentValue = ,
    Flag         = ,
    Callback     = (v) ESPCfg.BoxEnabled = v ,
})

TabESP:({
    Name     = ,
    Color    = .(, , ),
    Flag     = ,
    Callback = (c) ESPCfg.BoxColor = c ,
})

TabESP:()

TabESP:({
    Name         = ,
    CurrentValue = ,
    Flag         = ,
    Callback     = (v) ESPCfg.Names = v ,
})

TabESP:({
    Name         = ,
    CurrentValue = ,
    Flag         = ,
    Callback     = (v) ESPCfg.Distance = v ,
})

TabESP:({
    Name         = ,
    CurrentValue = ,
    Flag         = ,
    Callback     = (v) ESPCfg.HealthBar = v ,
})

TabESP:({
    Name         = ,
    Range        = {, },
    Increment    = ,
    Suffix       = ,
    CurrentValue = ,
    Flag         = ,
    Callback     = (v) ESPCfg.MaxDist = v ,
})


 TabChamsUI = TabChams

TabChamsUI:()

TabChamsUI:({
    Name         = ,
    CurrentValue = ,
    Flag         = ,
    Callback     = (v)
        ChamsCfg.Enabled = v
         v  ()  () 
    ,
})

TabChamsUI:({
    Name     = ,
    Color    = .(, , ),
    Flag     = ,
    Callback = (c) ChamsCfg.Color = c ,
})

TabChamsUI:({
    Name         = ,
    Range        = {, },
    Increment    = ,
    Suffix       = ,
    CurrentValue = ,
    Flag         = ,
    Callback     = (v) ChamsCfg.Transparency = v /  ,
})

TabChamsUI:()

TabChamsUI:({
    Name         = ,
    CurrentValue = ,
    Flag         = ,
    Callback     = (v) ChamsCfg.Rainbow = v ,
})

TabChamsUI:({
    Name         = ,
    CurrentValue = ,
    Flag         = ,
    Callback     = (v) ChamsCfg.Metallic = v ,
})

TabChamsUI:({
    Name         = ,
    CurrentValue = ,
    Flag         = ,
    Callback     = (v) ChamsCfg.Pulse = v ,
})

TabChamsUI:({
    Name         = ,
    Range        = {, },
    Increment    = ,
    Suffix       = ,
    CurrentValue = ,
    Flag         = ,
    Callback     = (v) ChamsCfg.RainbowSpeed = v ,
})

Rayfield:()

().Op1Config = { SA = SA, FR = FR, ESP = ESPCfg, Chams = ChamsCfg }


 COPY_LINK = 

  ()
    (()
        StarterGui:(, {
            Title    = ,
            Text     = ,
            Duration = ,
        })
    )


  ()
    (()
        StarterGui:(, {
            Title    = ,
            Text     = ,
            Duration = ,
            Button1  = ,
            Button2  = ,
            Callback = (btn)
                 isYes = (btn == )  (btn == )  (btn == )
                 isNo  = (btn == )  (btn == )   (btn == )

                 isYes 
                     setclipboard 
                        (setclipboard, COPY_LINK)
                     toclipboard 
                        (toclipboard, COPY_LINK)
                    
                        ()
                        
                    
                    ()
                 isNo 
                
            ,
        })
    )


()