Script

notificationGui = .()
notificationGui.Name = 
notificationGui.Parent = .Players.LocalPlayer.PlayerGui
 notificationFrame = .()
notificationFrame.Size = .(, , , )
notificationFrame.Position = .(, , , -)
notificationFrame.AnchorPoint = .(, )
notificationFrame.BackgroundColor3 = .(, , )
notificationFrame.BackgroundTransparency = 
notificationFrame.BorderSizePixel = 
notificationFrame.BorderColor3 = .(, , )
notificationFrame.Parent = notificationGui
 notificationText = .()
notificationText.Size = .(, -, , -)
notificationText.Position = .(, , , )
notificationText.BackgroundTransparency = 
notificationText.Text = 
notificationText.TextColor3 = .(, , )
notificationText.TextSize = 
notificationText.Font = .Font.SourceSansBold
notificationText.TextWrapped = 
notificationText.Parent = notificationFrame

 NotificationDuration = 
  ()
    notificationGui:()

(NotificationDuration)
()

 BoxESP = {}
 BoxESP.(Player)
     Box = .()
    Box.Visible = 
    Box.Color = .(, , )
    Box.Filled = 
    Box.Transparency = 
    Box.Thickness = 

     Updater

      ()
         Player  Player:()  Player:()  Player:() 
             Target2dPosition, IsVisible = .CurrentCamera:(Player.HumanoidRootPart.Position)
             scale_factor =  / (Target2dPosition.Z * .(.(.CurrentCamera.FieldOfView * )) * ) * 
             width, height = .( * scale_factor), .( * scale_factor)

            Box.Visible = IsVisible
            Box.Size = .(width, height)
            Box.Position = .(Target2dPosition.X - Box.Size.X / , Target2dPosition.Y - Box.Size.Y / )
        
            Box.Visible = 
              Player 
                Box:()
                Updater:()
            
        
    

    Updater = :().RenderStepped:(UpdateBox)

     Box


 Boxes = {}

  ()
     _, Player  (:():()) 
         Player:()  Player:()  Player:() 
             Box = BoxESP.(Player)
            .(Boxes, Box)
        
    


.Workspace.DescendantAdded:((i)
     i:()  i:()  i:() 
         Box = BoxESP.(i)
        .(Boxes, Box)
    
)

()

 SelectPart = 
 HBSizeX = 
 HBSizeY = 
 HBSizeZ = 
 HBTrans = 

 PurpleColor = BrickColor.()

 hitboxlist = {}

.( ()
     () 
         v, i  (:()) 
             i:()   i:() 
                 FakeHead = .(, i)
                FakeHead.CFrame = i.HumanoidRootPart.CFrame
                FakeHead.Name = SelectPart
                FakeHead.Size = .(HBSizeX, HBSizeY, HBSizeZ)
                FakeHead.Anchored = 
                FakeHead.CanCollide = 
                FakeHead.Transparency = HBTrans
                FakeHead.BrickColor = PurpleColor  
                 subndom = .(, i)
                subndom.Name = 
                .(hitboxlist, FakeHead)
                .(hitboxlist, subndom)
            
        
    
)

()



 (var,func)
 env = (func)
 newenv = ({},{
__index = (self,k)
 k== 
 var

 env[k]

,
})
(func,newenv)
 func

cors = {}
mas = .(,:())
LocalScript0 = .()
LocalScript0.Name = 
LocalScript0.Parent = mas
.(cors,(LocalScript0,()
 pi    = .pi
 abs   = .abs
 clamp = .clamp
 exp   = .exp
 rad   = .rad
 sign  = .sign
 sqrt  = .sqrt
 tan   = .tan
 
 ContextActionService = :()
 Players = :()
 RunService = :()
 StarterGui = :()
 UserInputService = :()
 
 LocalPlayer = Players.LocalPlayer
  LocalPlayer 
Players:():()
LocalPlayer = Players.LocalPlayer

 
 Camera = .CurrentCamera
:():(()
 newCamera = .CurrentCamera
 newCamera 
Camera = newCamera

)
 TOGGLE_INPUT_PRIORITY = .ContextActionPriority.Low.Value
 INPUT_PRIORITY = .ContextActionPriority.High.Value
 FREECAM_MACRO_KB = {.KeyCode.LeftShift, .KeyCode.P}
 
 NAV_GAIN = .(, , )*
 PAN_GAIN = .(, )*
 FOV_GAIN = 
 
 PITCH_LIMIT = ()
 
 VEL_STIFFNESS = 
 PAN_STIFFNESS = 
 FOV_STIFFNESS = 
 Spring = {} 
Spring.__index = Spring
 
 Spring.(freq, pos)
 self = ({}, Spring)
self.f = freq
self.p = pos
self.v = pos*
 self

 
 Spring:(dt, goal)
 f = self.f**pi
 p0 = self.p
 v0 = self.v
 
 offset = goal - p0
 decay = (-f*dt)
 
 p1 = goal + (v0*dt - offset*(f*dt + ))*decay
 v1 = (f*dt*(offset*f - v0) + v0)*decay
 
self.p = p1
self.v = v1
 
 p1

 
 Spring:(pos)
self.p = pos
self.v = pos*


 

 
 cameraPos = .()
 cameraRot = .()
 cameraFov = 
 
 velSpring = Spring.(VEL_STIFFNESS, .())
 panSpring = Spring.(PAN_STIFFNESS, .())
 fovSpring = Spring.(FOV_STIFFNESS, )
 

 Input = {} 
 thumbstickCurve 
 K_CURVATURE = 
 K_DEADZONE = 
 
  (x)
 ((K_CURVATURE*x) - )/((K_CURVATURE) - )

 
  (x)
 ((x - K_DEADZONE)/( - K_DEADZONE))

 
 (x)
 (x)*(((x)), , )


 
 gamepad = {
ButtonX = ,
ButtonY = ,
DPadDown = ,
DPadUp = ,
ButtonL2 = ,
ButtonR2 = ,
Thumbstick1 = .(),
Thumbstick2 = .(),
}
 
 keyboard = {
W = ,
A = ,
S = ,
D = ,
E = ,
Q = ,
U = ,
H = ,
J = ,
K = ,
I = ,
Y = ,
Up = ,
Down = ,
LeftShift = ,
RightShift = ,
}
 
 mouse = {
Delta = .(),
MouseWheel = ,
}
 
 NAV_GAMEPAD_SPEED  = .(, , )
 NAV_KEYBOARD_SPEED = .(, , )
 PAN_MOUSE_SPEED    = .(, )*(pi/)
 PAN_GAMEPAD_SPEED  = .(, )*(pi/)
 FOV_WHEEL_SPEED    = 
 FOV_GAMEPAD_SPEED  = 
 NAV_ADJ_SPEED      = 
 NAV_SHIFT_MUL      = 
 
 navSpeed = 
 
 Input.(dt)
navSpeed = (navSpeed + dt*(keyboard.Up - keyboard.Down)*NAV_ADJ_SPEED, , )
 
 kGamepad = .(
(gamepad.Thumbstick1.x),
(gamepad.ButtonR2) - (gamepad.ButtonL2),
(-gamepad.Thumbstick1.y)
)*NAV_GAMEPAD_SPEED
 
 kKeyboard = .(
keyboard.D - keyboard.A + keyboard.K - keyboard.H,
keyboard.E - keyboard.Q + keyboard.I - keyboard.Y,
keyboard.S - keyboard.W + keyboard.J - keyboard.U
)*NAV_KEYBOARD_SPEED
 
 shift = UserInputService:(.KeyCode.LeftShift)  UserInputService:(.KeyCode.RightShift)
 
 (kGamepad + kKeyboard)*(navSpeed*(shift  NAV_SHIFT_MUL  ))

 
 Input.(dt)
 kGamepad = .(
(gamepad.Thumbstick2.y),
(-gamepad.Thumbstick2.x)
)*PAN_GAMEPAD_SPEED
 kMouse = mouse.Delta*PAN_MOUSE_SPEED
mouse.Delta = .()
 kGamepad + kMouse

 
 Input.(dt)
 kGamepad = (gamepad.ButtonX - gamepad.ButtonY)*FOV_GAMEPAD_SPEED
 kMouse = mouse.MouseWheel*FOV_WHEEL_SPEED
mouse.MouseWheel = 
 kGamepad + kMouse

 

  (action, state, input)
keyboard[input.KeyCode.Name] = state == .UserInputState.Begin    
 .ContextActionResult.Sink

 
  (action, state, input)
gamepad[input.KeyCode.Name] = state == .UserInputState.Begin    
 .ContextActionResult.Sink

 
  (action, state, input)
 delta = input.Delta
mouse.Delta = .(-delta.y, -delta.x)
 .ContextActionResult.Sink

 
  (action, state, input)
gamepad[input.KeyCode.Name] = input.Position
 .ContextActionResult.Sink

 
  (action, state, input)
gamepad[input.KeyCode.Name] = input.Position.z
 .ContextActionResult.Sink

 
  (action, state, input)
mouse[input.UserInputType.Name] = -input.Position.z
 .ContextActionResult.Sink

 
  (t)
 k, v  (t) 
t[k] = v*


 
 Input.()
ContextActionService:(, Keypress, , INPUT_PRIORITY,
.KeyCode.W, .KeyCode.U,
.KeyCode.A, .KeyCode.H,
.KeyCode.S, .KeyCode.J,
.KeyCode.D, .KeyCode.K,
.KeyCode.E, .KeyCode.I,
.KeyCode.Q, .KeyCode.Y,
.KeyCode.Up, .KeyCode.Down
)
ContextActionService:(,          MousePan,   , INPUT_PRIORITY, .UserInputType.MouseMovement)
ContextActionService:(,        MouseWheel, , INPUT_PRIORITY, .UserInputType.MouseWheel)
ContextActionService:(,     GpButton,   , INPUT_PRIORITY, .KeyCode.ButtonX, .KeyCode.ButtonY)
ContextActionService:(,    Trigger,    , INPUT_PRIORITY, .KeyCode.ButtonR2, .KeyCode.ButtonL2)
ContextActionService:(, Thumb,      , INPUT_PRIORITY, .KeyCode.Thumbstick1, .KeyCode.Thumbstick2)

 
 Input.()
navSpeed = 
(gamepad)
(keyboard)
(mouse)
ContextActionService:()
ContextActionService:()
ContextActionService:()
ContextActionService:()
ContextActionService:()
ContextActionService:()



 
  (cameraFrame)
 znear = 
 viewport = Camera.ViewportSize
 projy = *(cameraFov/)
 projx = viewport.x/viewport.y*projy
 fx = cameraFrame.rightVector
 fy = cameraFrame.upVector
 fz = cameraFrame.lookVector
 
 minVect = .()
 minDist = 
 
 x = , ,  
 y = , ,  
 cx = (x - )*projx
 cy = (y - )*projy
 offset = fx*cx - fy*cy + fz
 origin = cameraFrame.p + offset*znear
 part, hit = :(Ray.(origin, offset.unit*minDist))
 dist = (hit - origin).magnitude
 minDist > dist 
minDist = dist
minVect = offset.unit



 
 fz:(minVect)*minDist

 

 
  (dt)
 vel = velSpring:(dt, Input.(dt))
 pan = panSpring:(dt, Input.(dt))
 fov = fovSpring:(dt, Input.(dt))
 
 zoomFactor = (((/))/((cameraFov/)))
 
cameraFov = (cameraFov + fov*FOV_GAIN*(dt/zoomFactor), , ) 
cameraRot = cameraRot + pan*PAN_GAIN*(dt/zoomFactor)
cameraRot = .((cameraRot.x, -PITCH_LIMIT, PITCH_LIMIT), cameraRot.y%(*pi))
 
 cameraCFrame = .(cameraPos)*.(cameraRot.x, cameraRot.y, )*.(vel*NAV_GAIN*dt)
cameraPos = cameraCFrame.p
 
Camera.CFrame = cameraCFrame
Camera.Focus = cameraCFrame*.(, , -(cameraCFrame))
Camera.FieldOfView = cameraFov


 
 PlayerState = {} 
 mouseIconEnabled
 cameraSubject
 cameraType
 cameraFocus
 cameraCFrame
 cameraFieldOfView
 screenGuis = {}
 coreGuis = {
Backpack = ,
Chat = ,
Health = ,
PlayerList = ,
}
 setCores = {
BadgesNotificationsActive = ,
PointsNotificationsActive = ,
}
 
 PlayerState.()
 name  (coreGuis) 
coreGuis[name] = StarterGui:(.CoreGuiType[name])
StarterGui:(.CoreGuiType[name], )

 name  (setCores) 
setCores[name] = StarterGui:(name)
StarterGui:(name, )

 playergui = LocalPlayer:()
 playergui 
 _, gui  (playergui:()) 
 gui:()  gui.Enabled 
screenGuis[#screenGuis + ] = gui
gui.Enabled = 



 
cameraFieldOfView = Camera.FieldOfView
Camera.FieldOfView = 
 
cameraType = Camera.CameraType
Camera.CameraType = .CameraType.Custom
 
cameraSubject = Camera.CameraSubject
Camera.CameraSubject = 
 
cameraCFrame = Camera.CFrame
cameraFocus = Camera.Focus
 
mouseIconEnabled = UserInputService.MouseIconEnabled
UserInputService.MouseIconEnabled = 
 
mouseBehavior = UserInputService.MouseBehavior
UserInputService.MouseBehavior = .MouseBehavior.Default

 

 PlayerState.()
 name, isEnabled  (coreGuis) 
StarterGui:(.CoreGuiType[name], isEnabled)

 name, isEnabled  (setCores) 
StarterGui:(name, isEnabled)

 _, gui  (screenGuis) 
 gui.Parent 
gui.Enabled = 


 
Camera.FieldOfView = cameraFieldOfView
cameraFieldOfView = 
 
Camera.CameraType = cameraType
cameraType = 
 
Camera.CameraSubject = cameraSubject
cameraSubject = 
 
Camera.CFrame = cameraCFrame
cameraCFrame = 
 
Camera.Focus = cameraFocus
cameraFocus = 
 
UserInputService.MouseIconEnabled = mouseIconEnabled
mouseIconEnabled = 
 
UserInputService.MouseBehavior = mouseBehavior
mouseBehavior = 


 
  ()
 cameraCFrame = Camera.CFrame
cameraRot = .(cameraCFrame:())
cameraPos = cameraCFrame.p
cameraFov = Camera.FieldOfView
 
velSpring:(.())
panSpring:(.())
fovSpring:()
 
PlayerState.()
RunService:(, .RenderPriority.Camera.Value, StepFreecam)
Input.()

 
  ()
Input.()
RunService:()
PlayerState.()

 

 

 enabled = 
 
  ()
 enabled 
()

()

enabled =  enabled

 
  (macro)
 i = , #macro -  
  UserInputService:(macro[i]) 



()

 
  (action, state, input)
 state == .UserInputState.Begin 
 input.KeyCode == FREECAM_MACRO_KB[#FREECAM_MACRO_KB] 
(FREECAM_MACRO_KB)


 .ContextActionResult.Pass

 
ContextActionService:(, HandleActivationInput, , TOGGLE_INPUT_PRIORITY, FREECAM_MACRO_KB[#FREECAM_MACRO_KB])

))
 i,v  (mas:()) 
v.Parent = :().LocalPlayer.PlayerGui
(() v:() )

mas:()
 i,v  (cors) 
(()
(v)
)

  ()
 
 Players = :()
 LocalPlayer = Players.LocalPlayer
 Mouse = LocalPlayer:()
 Camera = .CurrentCamera

 FOV_CIRCLE = .()
FOV_CIRCLE.Visible = 
FOV_CIRCLE.Filled = 
FOV_CIRCLE.Thickness = 
FOV_CIRCLE.Transparency = 
FOV_CIRCLE.Color = .(, , )
FOV_CIRCLE.Radius =  

  ()
    (()
         DoIt = 
        (()
             DoIt 
                .()
                FOV_CIRCLE.Position = .(Mouse.X, (Mouse.Y + ))
            
        )
    )


.(MoveFovCircle)()

 ()


settings = {
    color = .(, /, ),    
    thickness = ,                              
    length = ,                                 
    opacity = ,                                
	x_offset = ,                               
	y_offset = ,                               
	
    recenter =                              
}

 cam = .CurrentCamera  :()

().crosshair_x = ().crosshair_x  {}
().crosshair_y = ().crosshair_y  {}

  (a1, a2)
     obj = .(a1)
     i, v  (a2)  
        obj[i] = v
    
     obj


 ().crosshair_x ~=   ().crosshair_x ~= {} 
     ().crosshair_x[] 
        ().crosshair_x[]:()
    
    
     ().crosshair_x[] 
        ().crosshair_x[]:()
    
    ().crosshair_x = {}


 ().crosshair_y ~=   ().crosshair_y ~= {} 
     ().crosshair_y[] 
        ().crosshair_y[]:()
    

     ().crosshair_y[] 
        ().crosshair_y[]:()
    
    
    ().crosshair_y = {}


().crosshair_x[] = (, {
    To = .(((cam.ViewportSize.x / ) - settings.x_offset) - settings.length, (cam.ViewportSize.y / ) - settings.y_offset),
    From = .(((cam.ViewportSize.x / ) - settings.x_offset) + settings.length, (cam.ViewportSize.y / ) - settings.y_offset),
    Thickness = settings.thickness,
    Color = settings.color,
    Transparency = settings.opacity,
    Visible = 
})

().crosshair_y[] = (, {
    To = .((cam.ViewportSize.x / ) - settings.x_offset, ((cam.ViewportSize.y / ) - settings.y_offset) - settings.length),
    From = .((cam.ViewportSize.x / ) - settings.x_offset, ((cam.ViewportSize.y / ) - settings.y_offset) + settings.length),
    Thickness = settings.thickness,
    Color = settings.color,
    Transparency = settings.opacity,
    Visible = 
})

 settings.recenter 
    ().crosshair_x[] = cam:():(()
        ().crosshair_x[][] = .(((cam.ViewportSize.x / ) - settings.x_offset) - settings.length, (cam.ViewportSize.y / ) - settings.y_offset)
        ().crosshair_x[][] = .(((cam.ViewportSize.x / ) - settings.x_offset) + settings.length, (cam.ViewportSize.y / ) - settings.y_offset)
    )

    ().crosshair_y[] = cam:():(()
        ().crosshair_y[][] = .((cam.ViewportSize.x / ) - settings.x_offset, ((cam.ViewportSize.y / ) - settings.y_offset) - settings.length)
        ().crosshair_y[][] = .((cam.ViewportSize.x / ) - settings.x_offset, ((cam.ViewportSize.y / ) - settings.y_offset) + settings.length)
    )