Nebula.vip Beta Build v0.0.1

if NEBULA_EXECUTED then
  return warn("Nebula.vip Is Already Open Please Rejoin Inorder To ReExecute")
end

local Aimbot = loadstring(game:HttpGet("https://raw.githubusercontent.com/Exunys/Aimbot-V3/main/src/Aimbot.lua"))()

loadstring(game:HttpGet('https://raw.githubusercontent.com/drillygzzly/Roblox-UI-Libs/main/Yun%20V2%20Lib/Yun%20V2%20Lib%20Source.lua'))()

local Library = initLibrary()
local Window = Library:Load({name = "Nebula.vip", sizeX = 512, sizeY = 420, color = Color3.fromRGB(25, 255, 255)})

local Tab = Window:Tab("Main")
local Tab2 = Window:Tab("Visuals")
local Tab3 = Window:Tab("Misc")
local Tab4 = Window:Tab("Config")

local Mainsec1 = Tab:Section{name = "Aimbot", column = 1}
local Mainsec2 = Tab:Section{name = "Other Aim settings", column = 2}
local Visualssec1 = Tab2:Section{name = "Wall Hacks", column = 1}

if game.PlaceId == 17625359962 then
   Mainsec2:Toggle {
    Name = "Enabled",
    flag = "ooolol",
    callback = function(bool)
    for _, weapon in pairs(game:GetService("ReplicatedStorage").Weapons:GetChildren()) do
    if weapon:FindFirstChild("Spread") then
        for _, v in pairs(weapon:FindFirstChild("Spread"):GetChildren()) do
            v.Value = 0.5
        end
    end
end
    end
}
end

Mainsec1:Toggle {
    Name = "Enable Aimbot",
    flag = "ooolol",
    callback = function(bool)
    Aimbot.Settings.Enabled = bool
    end
}

Mainsec1:dropdown {
    name = "Hitbox Select",
    content = {"Head", "Torso", "HumanoidRootPart", "Right Arm", "Left Arm"},
    multichoice = false,
    callback = function(bool)
    Aimbot.Settings.LockPart = bool
    end
    }

Mainsec1:Toggle {
    Name = "Team Check",
    flag = "ooolol",
    callback = function(bool)
    Aimbot.Settings.TeamCheck = bool
    end
}

Mainsec1:Toggle {
    Name = "Alive Check",
    flag = "ooolol",
    callback = function(bool)
    Aimbot.Settings.AliveCheck = bool
    end
}

Visualssec1:Toggle {
    Name = "Box ESP",
    flag = "ooolol",
    callback = function(bool)
    -- Preview: https://cdn.discordapp.com/attachments/796378086446333984/818089455897542687/unknown.png
-- Made by Blissful#4992
local Settings = {
    Box_Color = Color3.fromRGB(255, 0, 0),
    Box_Thickness = 1,
}
local Team_Check = {
    TeamCheck = true, -- if TeamColor is on this won't matter...
    Green = Color3.fromRGB(0, 255, 0),
    Red = Color3.fromRGB(255, 0, 0)
}
local TeamColor = false

--// SEPARATION
local player = game:GetService("Players").LocalPlayer
local camera = game:GetService("Workspace").CurrentCamera
local mouse = player:GetMouse()

local function NewQuad(thickness, color)
    local quad = Drawing.new("Quad")
    quad.Visible = false
    quad.PointA = Vector2.new(0,0)
    quad.PointB = Vector2.new(0,0)
    quad.PointC = Vector2.new(0,0)
    quad.PointD = Vector2.new(0,0)
    quad.Color = color
    quad.Filled = false
    quad.Thickness = thickness
    quad.Transparency = 1
    return quad
end

local function NewLine(thickness, color)
    local line = Drawing.new("Line")
    line.Visible = false
    line.From = Vector2.new(0, 0)
    line.To = Vector2.new(0, 0)
    line.Color = color
    line.Thickness = thickness
    line.Transparency = 1
    return line
end

local function Visibility(state, lib)
    for u, x in pairs(lib) do
        x.Visible = state
    end
end

local function ToColor3(col) --Function to convert, just cuz c;
    local r = col.r --Red value
    local g = col.g --Green value
    local b = col.b --Blue value
    return Color3.new(r,g,b); --Color3 datatype, made of the RGB inputs
end

local black = Color3.fromRGB(0, 0 ,0)
local function ESP(plr)
    local library = {
        --//Box and Black Box(black border)
        black = NewQuad(Settings.Box_Thickness*2, black),
        box = NewQuad(Settings.Box_Thickness, Settings.Box_Color),
        --//Bar and Green Health Bar (part that moves up/down)
        healthbar = NewLine(3, black),
        greenhealth = NewLine(1.5, black)
    }

    local function Colorize(color)
        for u, x in pairs(library) do
            if x ~= library.healthbar and x ~= library.greenhealth and x ~= library.black then
                x.Color = color
            end
        end
    end

    local function Updater()
        local connection
        connection = game:GetService("RunService").RenderStepped:Connect(function()
            if plr.Character ~= nil and plr.Character:FindFirstChild("Humanoid") ~= nil and plr.Character:FindFirstChild("HumanoidRootPart") ~= nil and plr.Character.Humanoid.Health > 0 and plr.Character:FindFirstChild("Head") ~= nil then
                local HumPos, OnScreen = camera:WorldToViewportPoint(plr.Character.HumanoidRootPart.Position)
                if OnScreen then
                    local head = camera:WorldToViewportPoint(plr.Character.Head.Position)
                    local DistanceY = math.clamp((Vector2.new(head.X, head.Y) - Vector2.new(HumPos.X, HumPos.Y)).magnitude, 2, math.huge)

                    local function Size(item)
                        item.PointA = Vector2.new(HumPos.X + DistanceY, HumPos.Y - DistanceY*2)
                        item.PointB = Vector2.new(HumPos.X - DistanceY, HumPos.Y - DistanceY*2)
                        item.PointC = Vector2.new(HumPos.X - DistanceY, HumPos.Y + DistanceY*2)
                        item.PointD = Vector2.new(HumPos.X + DistanceY, HumPos.Y + DistanceY*2)
                    end
                    Size(library.box)
                    Size(library.black)

                    --// Health Bar
                    local d = (Vector2.new(HumPos.X - DistanceY, HumPos.Y - DistanceY*2) - Vector2.new(HumPos.X - DistanceY, HumPos.Y + DistanceY*2)).magnitude
                    local healthoffset = plr.Character.Humanoid.Health/plr.Character.Humanoid.MaxHealth * d

                    library.greenhealth.From = Vector2.new(HumPos.X - DistanceY - 4, HumPos.Y + DistanceY*2)
                    library.greenhealth.To = Vector2.new(HumPos.X - DistanceY - 4, HumPos.Y + DistanceY*2 - healthoffset)

                    library.healthbar.From = Vector2.new(HumPos.X - DistanceY - 4, HumPos.Y + DistanceY*2)
                    library.healthbar.To = Vector2.new(HumPos.X - DistanceY - 4, HumPos.Y - DistanceY*2)

                    local green = Color3.fromRGB(0, 255, 0)
                    local red = Color3.fromRGB(255, 0, 0)

                    library.greenhealth.Color = red:lerp(green, plr.Character.Humanoid.Health/plr.Character.Humanoid.MaxHealth);

                    if Team_Check.TeamCheck then
                        if plr.TeamColor == player.TeamColor then
                            Colorize(Team_Check.Green)
                        else
                            Colorize(Team_Check.Red)
                        end
                    else
                        library.box.Color = Settings.Box_Color
                    end
                    if TeamColor == true then
                        Colorize(plr.TeamColor.Color)
                    end
                    Visibility(true, library)
                else
                    Visibility(false, library)
                end
            else
                Visibility(false, library)
                if game.Players:FindFirstChild(plr.Name) == nil then
                    connection:Disconnect()
                end
            end
        end)
    end
    coroutine.wrap(Updater)()
end

for i, v in pairs(game:GetService("Players"):GetPlayers()) do
    if v.Name ~= player.Name then
        coroutine.wrap(ESP)(v)
    end
end

game.Players.PlayerAdded:Connect(function(newplr)
    if newplr.Name ~= player.Name then
        coroutine.wrap(ESP)(newplr)
    end
end)
    end
}

Visualssec1:Toggle {
    Name = "OOF Arrows",
    flag = "ooolol",
    callback = function(bool)
    local DistFromCenter = 120
local TriangleHeight = 16
local TriangleWidth = 16
local TriangleFilled = true
local TriangleTransparency = 0
local TriangleThickness = 1
local TriangleColor = Color3.fromRGB(255, 255, 255)
local AntiAliasing = false

----------------------------------------------------------------

local Players = game:service("Players")
local Player = Players.LocalPlayer
local Camera = workspace.CurrentCamera
local RS = game:service("RunService")

local V3 = Vector3.new
local V2 = Vector2.new
local CF = CFrame.new
local COS = math.cos
local SIN = math.sin
local RAD = math.rad
local DRAWING = Drawing.new
local CWRAP = coroutine.wrap
local ROUND = math.round

local function GetRelative(pos, char)
    if not char then return V2(0,0) end

    local rootP = char.PrimaryPart.Position
    local camP = Camera.CFrame.Position
    local relative = CF(V3(rootP.X, camP.Y, rootP.Z), camP):PointToObjectSpace(pos)

    return V2(relative.X, relative.Z)
end

local function RelativeToCenter(v)
    return Camera.ViewportSize/2 - v
end

local function RotateVect(v, a)
    a = RAD(a)
    local x = v.x * COS(a) - v.y * SIN(a)
    local y = v.x * SIN(a) + v.y * COS(a)

    return V2(x, y)
end

local function DrawTriangle(color)
    local l = DRAWING("Triangle")
    l.Visible = false
    l.Color = color
    l.Filled = TriangleFilled
    l.Thickness = TriangleThickness
    l.Transparency = 1-TriangleTransparency
    return l
end

local function AntiA(v)
    if (not AntiAliasing) then return v end
    return V2(ROUND(v.x), ROUND(v.y))
end

local function ShowArrow(PLAYER)
    local Arrow = DrawTriangle(TriangleColor)

    local function Update()
        local c ; c = RS.RenderStepped:Connect(function()
            if PLAYER and PLAYER.Character then
                local CHAR = PLAYER.Character
                local HUM = CHAR:FindFirstChildOfClass("Humanoid")

                if HUM and CHAR.PrimaryPart ~= nil and HUM.Health > 0 then
                    local _,vis = Camera:WorldToViewportPoint(CHAR.PrimaryPart.Position)
                    if vis == false then
                        local rel = GetRelative(CHAR.PrimaryPart.Position, Player.Character)
                        local direction = rel.unit

                        local base  = direction * DistFromCenter
                        local sideLength = TriangleWidth/2
                        local baseL = base + RotateVect(direction, 90) * sideLength
                        local baseR = base + RotateVect(direction, -90) * sideLength

                        local tip = direction * (DistFromCenter + TriangleHeight)

                        Arrow.PointA = AntiA(RelativeToCenter(baseL))
                        Arrow.PointB = AntiA(RelativeToCenter(baseR))

                        Arrow.PointC = AntiA(RelativeToCenter(tip))

                        Arrow.Visible = true

                    else Arrow.Visible = false end
                else Arrow.Visible = false end
            else
                Arrow.Visible = false

                if not PLAYER or not PLAYER.Parent then
                    Arrow:Remove()
                    c:Disconnect()
                end
            end
        end)
    end

    CWRAP(Update)()
end

for _,v in pairs(Players:GetChildren()) do
    if v.Name ~= Player.Name then
        ShowArrow(v)
    end
end

Players.PlayerAdded:Connect(function(v)
    if v.Name ~= Player.Name then
        ShowArrow(v)
    end
end)
    end
}

Mainsec1:Toggle {
    Name = "Wall Check",
    flag = "ooolol",
    callback = function(bool)
    Aimbot.Settings.WallCheck = bool
    end
}

Mainsec1:Toggle {
    Name = "Aimbot FOV",
    flag = "ooolol",
    callback = function(bool)
    Aimbot.FOVSettings.Enabled = bool
    end
}

Mainsec1:Slider {
    Name = "Aimbot FOV",
    Default = 1,
    Min = 0,
    Max = 360,
    Decimals = 1,
    Flag = "MOOOOOO",
    callback = function(Value)
    Aimbot.FOVSettings.Radius = Value
    end
    }

Mainsec1:Toggle {
    Name = "Rainbow FOV",
    flag = "ooolol",
    callback = function(bool)
    Aimbot.FOVSettings.RainbowOutlineColor = bool
    end
}

Mainsec1:Slider {
    Name = "Smoothing",
    Default = 0.5,
    Min = 1,
    Max = 30,
    Decimals = 1,
    Flag = "moooooo",
    callback = function(Value)
    Aimbot.Settings.Sensitivity2 = Value
    end
    }

  Aimbot.Settings = {
    Enabled = true,

    TeamCheck = true,
    AliveCheck = true,
    WallCheck = true,

    OffsetToMoveDirection = false, -- Prediction
    OffsetIncrement = 15, -- Min: 1; Max: 30 -- Amplitude

    Sensitivity = 0, -- Animation length (in seconds) before fully locking onto target / CFrame Sensitivity
    Sensitivity2 = 3.5, -- mousemoverel Sensitivity

    LockMode = 2, -- 1 = CFrame; 2 = mousemoverel
    LockPart = "Head, Torso, HumanoidRootPart, Right Arm, Left Arm", -- Body part to lock on

    TriggerKey = Enum.UserInputType.MouseButton2,
    Toggle = false
}

Aimbot.FOVSettings = {
    Enabled = true,
    Visible = true,

    Radius = 90,
    NumSides = 60,

    Thickness = 1,
    Transparency = 1,
    Filled = false,

    RainbowColor = false,
    RainbowOutlineColor = false,
    Color = Color3.fromRGB(255, 255, 255),
    OutlineColor = Color3.fromRGB(0, 0, 0),
    LockedColor = Color3.fromRGB(255, 150, 150)
}

  Aimbot.Load()

    getgenv().NEBULA_EXECUTED = true