FORTBLOX

 ( :()) 
    .Loaded:();


 UILibrary = (:())();

 PlaceId = .PlaceId

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

 CurrentCamera = Workspace.CurrentCamera
 WorldToViewportPoint = CurrentCamera.WorldToViewportPoint
 GetPartsObscuringTarget = CurrentCamera.GetPartsObscuringTarget

 Inset = :():().Y

 FindFirstChild = .FindFirstChild
 FindFirstChildWhichIsA = .FindFirstChildWhichIsA
 IsA = .IsA
 Vector2new = .new
 Vector3new = .new
 CFramenew = .new
 Color3new = .new

 Tfind = .find
 create = .create
 format = .format
 floor = .floor
 gsub = .gsub
 sub = .sub
 lower = .lower
 upper = .upper
 random = .random

 DefaultSettings = {
    Esp = {
        NamesEnabled = ,
        DisplayNamesEnabled = ,
        DistanceEnabled = ,
        HealthEnabled = ,
        TracersEnabled = ,
        BoxEsp = ,
        TeamColors = ,
        Thickness = ,
        TracerThickness = ,
        Transparency = ,
        TracerTrancparency = ,
        Size = ,
        RenderDistance = ,
        Color = .(, , ),
        OutlineColor = (),
        TracerTo = ,
        BlacklistedTeams = {}
    },
    Aimbot = {
        Enabled = ,
        SilentAim = ,
        Wallbang = ,
        ShowFov = ,
        Snaplines = ,
        ThirdPerson = ,
        FirstPerson = ,
        ClosestCharacter = ,
        ClosestCursor = ,
        Smoothness = ,
        SilentAimHitChance = ,
        FovThickness = ,
        FovTransparency = ,
        FovSize = ,
        FovColor = (, , ),
        Aimlock = ,
        SilentAimRedirect = ,
        BlacklistedTeams = {}
    },
    WindowPosition = .(, -, , -);

    Version = 
}

 EncodeConfig, DecodeConfig;

     deepsearchset;
    deepsearchset = (tbl, ret, value)
         ((tbl) == ) 
             new = {}
             i, v  , tbl 
                new[i] = v
                 ((v) == ) 
                    new[i] = (v, ret, value);
                
                 ((i, v)) 
                    new[i] = (i, v);
                
            
             new
        
    

    DecodeConfig = (Config)
         DecodedConfig = (Config, (Index, Value)
             (Value) ==   (Value.HSVColor  Value.Position);
        , (Index, Value)
             Color = Value.HSVColor
             Position = Value.Position
             (Color) 
                 .(Color.H, Color.S, Color.V);
            
             (Position  Position.Y  Position.X) 
                 .(.(Position.X.Scale, Position.X.Offset), .(Position.Y.Scale, Position.Y.Offset));
            
                 DefaultSettings.WindowPosition;
            
        );
         DecodedConfig
    

    EncodeConfig = (Config)
         ToHSV = ().ToHSV
         EncodedConfig = (Config, (Index, Value)
             (Value) ==   (Value) == 
        , (Index, Value)
             Color = (Value) == 
             Position = (Value) == 
             (Color) 
                 H, S, V = (Value);
                 { HSVColor = { H = H, S = S, V = V } };
            
             (Position) 
                 { Position = {
                    X = { Scale = Value.X.Scale, Offset = Value.X.Offset };
                    Y = { Scale = Value.Y.Scale, Offset = Value.Y.Offset }
                } };
            
        )
         EncodedConfig
    


 GetConfig = ()
     read, data = (readfile, );
     canDecode, config = (HttpService.JSONDecode, HttpService, data);
     (read  canDecode) 
         Decoded = (config);
         (Decoded.Version ~= DefaultSettings.Version) 
             Encoded = HttpService:((DefaultSettings));
            (, Encoded);
             DefaultSettings;
        
         Decoded;
    
         Encoded = HttpService:((DefaultSettings));
        (, Encoded);
         DefaultSettings
    


 Settings = ();

 LocalPlayer = Players.LocalPlayer
 Mouse = LocalPlayer:();
 MouseVector = (Mouse.X, Mouse.Y);
 Characters = {}

 CustomGet = {
    [] = ()
         {}
    
}

 Get;
 (CustomGet[PlaceId]) 
    Get = CustomGet[PlaceId]();


 GetCharacter = (Player)
     (Get) 
         Get.(Player);
    
     Player.Character

 CharacterAdded = (Player, Callback)
     (Get) 
        
    
    Player.CharacterAdded:(Callback);

 CharacterRemoving = (Player, Callback)
     (Get) 
        
    
    Player.CharacterRemoving:(Callback);


 GetTeam = (Player)
     (Get) 
         Get.(Player);
    
     Player.Team


 Drawings = {}

 AimbotSettings = Settings.Aimbot
 EspSettings = Settings.Esp

 FOV = .();
FOV.Color = AimbotSettings.FovColor
FOV.Thickness = AimbotSettings.FovThickness
FOV.Transparency = AimbotSettings.FovTransparency
FOV.Filled = 
FOV.Radius = AimbotSettings.FovSize

 Snaplines = .();
Snaplines.Color = AimbotSettings.FovColor
Snaplines.Thickness = 
Snaplines.Transparency = 
Snaplines.Visible = AimbotSettings.Snaplines

.(Drawings, FOV);
.(Drawings, Snaplines);

 HandlePlayer = (Player)
     Character = (Player);
     (Character) 
        Characters[Player] = Character
    
    (Player, (Char)
        Characters[Player] = Char
    );
    (Player, (Char)
        Characters[Player] = 
         PlayerDrawings = Drawings[Player]
         (PlayerDrawings) 
            PlayerDrawings.Text.Visible = 
            PlayerDrawings.Box.Visible = 
            PlayerDrawings.Tracer.Visible = 
        
    );

     (Player == LocalPlayer)  ; 

     Text = .();
    Text.Color = EspSettings.Color
    Text.OutlineColor = EspSettings.OutlineColor
    Text.Size = EspSettings.Size
    Text.Transparency = EspSettings.Transparency
    Text.Center = 
    Text.Outline = 

     Tracer = .();
    Tracer.Color = EspSettings.Color
    Tracer.From = (CurrentCamera.ViewportSize.X / , CurrentCamera.ViewportSize.Y);
    Tracer.Thickness = EspSettings.TracerThickness
    Tracer.Transparency = EspSettings.TracerTrancparency

     Box = .();
    Box.Thickness = EspSettings.Thickness
    Box.Transparency = EspSettings.Transparency
    Box.Filled = 
    Box.Color = EspSettings.Color

    Drawings[Player] = { Text = Text, Tracer = Tracer, Box = Box }


 Index, Player  (Players:()) 
    (Player);

Players.PlayerAdded:((Player)
    (Player);
);

Players.PlayerRemoving:((Player)
    Characters[Player] = 
     PlayerDrawings = Drawings[Player]
     Index,   (PlayerDrawings  {}) 
        .Visible = 
    
    Drawings[Player] = 
);

 SetProperties = (Properties)
     Player, PlayerDrawings  (Drawings) 
         ((Player) ~= ) 
             Property, Value  (Properties.Tracer  {}) 
                PlayerDrawings.Tracer[Property] = Value
            
             Property, Value  (Properties.Text  {}) 
                PlayerDrawings.Text[Property] = Value
            
             Property, Value  (Properties.Box  {}) 
                PlayerDrawings.Box[Property] = Value
            
        
    



 GetClosestPlayerAndRender = ()
    MouseVector = (Mouse.X, Mouse.Y + Inset);
     Closest = ();
     Vector2Distance = .huge
     Vector3DistanceOnScreen = .huge
     Vector3Distance = .huge

     (AimbotSettings.ShowFov) 
        FOV.Position = MouseVector
        FOV.Visible = 
        Snaplines.Visible = 
    
        FOV.Visible = 
    

     LocalRoot = Characters[LocalPlayer]  (Characters[LocalPlayer], );
     Player, Character  (Characters) 
         (Player == LocalPlayer)  ; 
         PlayerDrawings = Drawings[Player]
         PlayerRoot = (Character, );
         PlayerTeam = (Player);
         (PlayerRoot) 
             Redirect = (Character, AimbotSettings.Aimlock);
             ( Redirect) 
                PlayerDrawings.Text.Visible = 
                PlayerDrawings.Box.Visible = 
                PlayerDrawings.Tracer.Visible = 
                ;
            
             RedirectPos = Redirect.Position
             Tuple, Visible = (CurrentCamera, RedirectPos);
             CharacterVec2 = (Tuple.X, Tuple.Y);
             Vector2Magnitude = (MouseVector - CharacterVec2).Magnitude
             Vector3Magnitude = LocalRoot  (RedirectPos - LocalRoot.Position).Magnitude  .huge
             InRenderDistance = Vector3Magnitude <= EspSettings.RenderDistance

             ( (AimbotSettings.BlacklistedTeams, PlayerTeam)) 
                 InFovRadius = Vector2Magnitude <= FOV.Radius
                 (InFovRadius) 
                     (Visible  Vector2Magnitude <= Vector2Distance  AimbotSettings.ClosestCursor) 
                        Vector2Distance = Vector2Magnitude
                        Closest = {Character, CharacterVec2, Player, Redirect}
                         (AimbotSettings.Snaplines  AimbotSettings.ShowFov) 
                            Snaplines.Visible = 
                            Snaplines.From = MouseVector
                            Snaplines.To = CharacterVec2
                        
                            Snaplines.Visible = 
                        
                    

                     (Visible  Vector3Magnitude <= Vector3DistanceOnScreen  Settings.ClosestPlayer) 
                        Vector3DistanceOnScreen = Vector3Magnitude
                        Closest = {Character, CharacterVec2, Player, Redirect}
                    
                
            

             (InRenderDistance  Visible   (EspSettings.BlacklistedTeams, PlayerTeam)) 
                 CharacterHumanoid = (Character, )  { Health = , MaxHealth =  };
                PlayerDrawings.Text.Text = (,
                        EspSettings.NamesEnabled  Player.Name  ,
                        EspSettings.DistanceEnabled  (,
                            (Vector3Magnitude)
                        )  ,
                        EspSettings.HealthEnabled  (,
                            (CharacterHumanoid.Health),
                            (CharacterHumanoid.MaxHealth)
                        )   
                    );

                PlayerDrawings.Text.Position = (Tuple.X, Tuple.Y - );

                 (EspSettings.TracersEnabled) 
                    PlayerDrawings.Tracer.To = CharacterVec2
                

                 (EspSettings.BoxEsp) 
                     Parts = {}
                     Index, Part  (Character:()) 
                         ((Part, )) 
                             ViewportPos = (CurrentCamera, Part.Position);
                            Parts[Part] = (ViewportPos.X, ViewportPos.Y);
                        
                    

                     Top, Bottom, Left, Right
                     Distance = .huge
                     ClosestPart = 
                     i2, Pos  , Parts 
                         Mag = (Pos - (Tuple.X, )).Magnitude;
                         (Mag <= Distance) 
                            ClosestPart = Pos
                            Distance = Mag
                        
                    
                    Top = ClosestPart
                    ClosestPart = 
                    Distance = .huge
                     i2, Pos  , Parts 
                         Mag = (Pos - (Tuple.X, CurrentCamera.ViewportSize.Y)).Magnitude;
                         (Mag <= Distance) 
                            ClosestPart = Pos
                            Distance = Mag
                        
                    
                    Bottom = ClosestPart
                    ClosestPart = 
                    Distance = .huge
                     i2, Pos  , Parts 
                         Mag = (Pos - (, Tuple.Y)).Magnitude;
                         (Mag <= Distance) 
                            ClosestPart = Pos
                            Distance = Mag
                        
                    
                    Left = ClosestPart
                    ClosestPart = 
                    Distance = .huge
                     i2, Pos  , Parts 
                         Mag = (Pos - (CurrentCamera.ViewportSize.X, Tuple.Y)).Magnitude;
                         (Mag <= Distance) 
                            ClosestPart = Pos
                            Distance = Mag
                        
                    
                    Right = ClosestPart
                    ClosestPart = 
                    Distance = .huge

                    PlayerDrawings.Box.PointA = (Right.X, Top.Y);
                    PlayerDrawings.Box.PointB = (Left.X, Top.Y);
                    PlayerDrawings.Box.PointC = (Left.X, Bottom.Y);
                    PlayerDrawings.Box.PointD = (Right.X, Bottom.Y);
                

                 (EspSettings.TeamColors) 
                     TeamColor;
                     (PlayerTeam) 
                         BrickTeamColor = PlayerTeam.TeamColor
                        TeamColor = BrickTeamColor.Color
                    
                        TeamColor = (, , );
                    
                    PlayerDrawings.Text.Color = TeamColor
                    PlayerDrawings.Box.Color = TeamColor
                    PlayerDrawings.Tracer.Color = TeamColor
                

                PlayerDrawings.Text.Visible = 
                PlayerDrawings.Box.Visible = EspSettings.BoxEsp
                PlayerDrawings.Tracer.Visible = EspSettings.TracersEnabled
            
                PlayerDrawings.Text.Visible = 
                PlayerDrawings.Box.Visible = 
                PlayerDrawings.Tracer.Visible = 
            
        
            PlayerDrawings.Text.Visible = 
            PlayerDrawings.Box.Visible = 
            PlayerDrawings.Tracer.Visible = 
        
    

     (Closest);


 Locked, SwitchedCamera = , 
UserInputService.InputBegan:((Inp)
     (AimbotSettings.Enabled  Inp.UserInputType == .UserInputType.MouseButton2) 
        Locked = 
         (AimbotSettings.FirstPerson  LocalPlayer.CameraMode ~= .CameraMode.LockFirstPerson) 
            LocalPlayer.CameraMode = .CameraMode.LockFirstPerson
            SwitchedCamera = 
        
    
);
UserInputService.InputEnded:((Inp)
     (AimbotSettings.Enabled  Inp.UserInputType == .UserInputType.MouseButton2) 
        Locked = 
         (SwitchedCamera) 
            LocalPlayer.CameraMode = .CameraMode.Classic
        
    
);

 ClosestCharacter, Vector, Player, Aimlock;
RunService.RenderStepped:(()
    ClosestCharacter, Vector, Player, Aimlock = ();
     (Locked  AimbotSettings.Enabled  ClosestCharacter) 
         (AimbotSettings.FirstPerson) 
             () 
                CurrentCamera.CoordinateFrame = (CurrentCamera.CoordinateFrame.p, Aimlock.Position);
            
                ((Vector.X - MouseVector.X) / AimbotSettings.Smoothness, (Vector.Y - MouseVector.Y) / AimbotSettings.Smoothness);
            
         (AimbotSettings.ThirdPerson) 
            (Vector.X, Vector.Y);
        
    
);

 Hooks = {
    HookedFunctions = {},
    OldMetaMethods = {},
    MetaMethodHooks = {},
    HookedSignals = {}
}

 OtherDeprecated = {
    children = 
}

 RealMethods = {}
 FakeMethods = {}

 HookedFunctions = Hooks.HookedFunctions
 MetaMethodHooks = Hooks.MetaMethodHooks
 OldMetaMethods = Hooks.OldMetaMethods

 randomised = (, );
 randomisedVector = ((, ), (, ), (, ));
Mouse.Move:(()
    randomised = (, );
    randomisedVector = ((, ), (, ), (, ));
);

 x = ({}, {
    __index = (...)
        (, ...);
    ,
    __add = (...)
        (, ...);
    ,
    __sub = (...)
        (, ...);
    ,
    __mul = (...)
        (, ...);
    
});

MetaMethodHooks.Index = (...)
     __Index = OldMetaMethods.__index

     (Player  Aimlock  ... == Mouse   ()) 
         CallingScript = ().script;
         (CallingScript.Name == ) 
             (...);
        

         _Mouse, Index = ...
         ((Index) == ) 
            Index = ((Index, , ), , );
        
         PassedChance = (, ) < AimbotSettings.SilentAimHitChance
         (PassedChance  AimbotSettings.SilentAim) 
             Parts = (CurrentCamera, {CurrentCamera.CFrame.Position, Aimlock.Position}, {LocalPlayer.Character, ClosestCharacter});

            Index = .(Index, , upper);
             Hit = #Parts ==   AimbotSettings.Wallbang
             ( Hit) 
                 (...);
            
             (Index == ) 
                 Aimlock
            
             (Index == ) 
                 hit = (...);
                 pos = Aimlock.Position + randomisedVector / 
                 (pos.X, pos.Y, pos.Z, ({hit:()}, ));
            
             (Index == ) 
                 Vector.X + randomised / 
            
             (Index == ) 
                 Vector.Y + randomised / 
            
        
    

     (...);


MetaMethodHooks.Namecall = (...)
     __Namecall = OldMetaMethods.__namecall
     self = ...
     Method = (()  , , upper);
     Hooked = HookedFunctions[Method]
     (Hooked  self == Hooked[]) 
         Hooked[](...);
    

     (...);




HookedFunctions.FindPartOnRay = {Workspace, Workspace.FindPartOnRay, (...)
     OldFindPartOnRay = HookedFunctions.FindPartOnRay[]
     (AimbotSettings.SilentAim  Player  Aimlock   ()) 
         PassedChance = (, ) < AimbotSettings.SilentAimHitChance
         (ClosestCharacter  PassedChance) 
             Parts = (CurrentCamera, {CurrentCamera.CFrame.Position, Aimlock.Position}, {LocalPlayer.Character, ClosestCharacter});
             (#Parts ==   AimbotSettings.Wallbang) 
                 Aimlock, Aimlock.Position + (((, ), (, ), (, )) / ), (, , ), Aimlock.Material
            
        
    
     (...);
};

HookedFunctions.FindPartOnRayWithIgnoreList = {Workspace, Workspace.FindPartOnRayWithIgnoreList, (...)
     OldFindPartOnRayWithIgnoreList = HookedFunctions.FindPartOnRayWithIgnoreList[]
     (Player  Aimlock   ()) 
         CallingScript = ();
         PassedChance = (, ) < AimbotSettings.SilentAimHitChance
         (CallingScript.Name ~=   ClosestCharacter  PassedChance) 
             Parts = (CurrentCamera, {CurrentCamera.CFrame.Position, Aimlock.Position}, {LocalPlayer.Character, ClosestCharacter});
             (#Parts ==   AimbotSettings.Wallbang) 
                 Aimlock, Aimlock.Position + (((, ), (, ), (, )) / ), (, , ), Aimlock.Material
            
        
    
     (...);
};

 Index, Function  (HookedFunctions) 
    Function[] = (Function[], Function[]);


 MainUI = UILibrary.(.(, , ));
 Window = MainUI:(, .(, ));
 ESP = Window.();
 Aimbot = Window.();
 EspSettingsUI = ESP.();
 TracerSettingsUI = ESP.();
 SilentAim = Aimbot.();
 Aimbot = Aimbot.();

EspSettingsUI.(, EspSettings.NamesEnabled, (Callback)
    EspSettings.NamesEnabled = Callback
);
EspSettingsUI.(, EspSettings.HealthEnabled, (Callback)
    EspSettings.HealthEnabled = Callback
);
EspSettingsUI.(, EspSettings.DistanceEnabled, (Callback)
    EspSettings.DistanceEnabled = Callback
);
EspSettingsUI.(, EspSettings.BoxEsp, (Callback)
    EspSettings.BoxEsp = Callback
    ({ Box = { Visible = Callback } });
);
EspSettingsUI.(, { Min = , Max = , Default = .(EspSettings.RenderDistance, , ), Step =  }, (Callback)
    EspSettings.RenderDistance = Callback
);
EspSettingsUI.(, { Min = , Max = , Default = EspSettings.Size, Step = }, (Callback)
    EspSettings.Size = Callback
    ({ Text = { Size = Callback } });
);
EspSettingsUI.(, EspSettings.Color, (Callback)
    EspSettings.TeamColors = 
    EspSettings.Color = Callback
    ({ Box = { Color = Callback }, Text = { Color = Callback }, Tracer = { Color = Callback } });
);
EspSettingsUI.(, EspSettings.TeamColors, (Callback)
    EspSettings.TeamColors = Callback
     ( Callback) 
        ({ Tracer = { Color = EspSettings.Color }; Box = { Color = EspSettings.Color }; Text = { Color = EspSettings.Color }  })
    
);
EspSettingsUI.(, {, , }, (Callback)
    .(EspSettings.BlacklistedTeams);
     (Callback == ) 
        .(EspSettings.BlacklistedTeams, LocalPlayer.Team);
    
     (Callback == ) 
         AllTeams = Teams:();
        .(AllTeams, .(AllTeams, LocalPlayer.Team));
        EspSettings.BlacklistedTeams = AllTeams
    
);
TracerSettingsUI.(, EspSettings.TracersEnabled, (Callback)
    EspSettings.TracersEnabled = Callback
    ({ Tracer = { Visible = Callback } });
);
TracerSettingsUI.(, {, }, (Callback)
    AimbotSettings.Aimlock = Callback ==     Callback
);
TracerSettingsUI.(, {, , , }, (Callback)
     ViewportSize = CurrentCamera.ViewportSize
     From = Callback ==   (ViewportSize.X / , ViewportSize.Y - ViewportSize.Y)  Callback ==   (ViewportSize.X / , ViewportSize.Y)  Callback ==   (ViewportSize.X - ViewportSize.X, ViewportSize.Y / )  Callback ==   (ViewportSize.X, ViewportSize.Y / );
    EspSettings.TracerFrom = From
    ({ Tracer = { From = From } });
);
TracerSettingsUI.(, {Min = , Max = , Default = EspSettings.TracerTrancparency, Step = }, (Callback)
    EspSettings.TracerTrancparency = Callback
    ({ Tracer = { Transparency = Callback } });
);
TracerSettingsUI.(, {Min = , Max = , Default = EspSettings.TracerThickness, Step = }, (Callback)
    EspSettings.TracerThickness = Callback
    ({ Tracer = { Thickness = Callback } });
);

SilentAim.(, AimbotSettings.SilentAim, (Callback)
    AimbotSettings.SilentAim = Callback
);
SilentAim.(, AimbotSettings.Wallbang, (Callback)
    AimbotSettings.Wallbang = Callback
);
SilentAim.(, {, }, (Callback)
    AimbotSettings.SilentAimRedirect = Callback
);
SilentAim.(, {Min = , Max = , Default = AimbotSettings.SilentAimHitChance, Step = }, (Callback)
    AimbotSettings.SilentAimHitChance = Callback
);

SilentAim.(, {, }, (Callback)
     (Callback == ) 
        AimbotSettings.ClosestCharacter = 
        AimbotSettings.ClosestCursor = 
    
        AimbotSettings.ClosestCharacter = 
        AimbotSettings.ClosestCursor = 
    
);

Aimbot.(, AimbotSettings.Enabled, (Callback)
    AimbotSettings.Enabled = Callback
     ( AimbotSettings.FirstPerson   AimbotSettings.ThirdPerson) 
        AimbotSettings.FirstPerson = 
    
);
Aimbot.(, {Min = , Max = , Default = AimbotSettings.Smoothness, Step = }, (Callback)
    AimbotSettings.Smoothness = Callback
);
 sortTeams = (Callback)
    .(AimbotSettings.BlacklistedTeams);
     (Callback == ) 
        .(AimbotSettings.BlacklistedTeams, LocalPlayer.Team);
    
     (Callback == ) 
         AllTeams = Teams:();
        .(AllTeams, .(AllTeams, LocalPlayer.Team));
        AimbotSettings.BlacklistedTeams = AllTeams
    

Aimbot.(, {, , }, sortTeams);
();
Aimbot.(, {, }, (callback)
     (callback == ) 
        AimbotSettings.ThirdPerson = 
        AimbotSettings.FirstPerson = 
    
        AimbotSettings.ThirdPerson = 
        AimbotSettings.FirstPerson = 
    
);

Aimbot.(, AimbotSettings.ShowFov, (Callback)
    AimbotSettings.ShowFov = Callback
    FOV.Visible = Callback
);
Aimbot.(, AimbotSettings.FovColor, (Callback)
    AimbotSettings.FovColor = Callback
    FOV.Color = Callback
    Snaplines.Color = Callback
);
Aimbot.(, {Min = , Max = , Default = AimbotSettings.FovSize, Step = }, (Callback)
    AimbotSettings.FovSize = Callback
    FOV.Radius = Callback
);
Aimbot.(, AimbotSettings.Snaplines, (Callback)
    AimbotSettings.Snaplines = Callback
);
Window.(Settings.WindowPosition);

 (gethui) 
    MainUI.UI.Parent = ();

     protect_gui = (  ()).protect_gui
     (protect_gui) 
        (MainUI.UI);
    
    MainUI.UI.Parent = :();


 () 
    Settings.WindowPosition = Window.();
     Encoded = HttpService:((Settings));
    (, Encoded);