1084 lines
39 KiB
Plaintext
1084 lines
39 KiB
Plaintext
--[[
|
|
JustShare Hub
|
|
Version: 2.1
|
|
Description:
|
|
- This script combines advanced features including Auto Farm, Auto Sell, Auto Rebirth,
|
|
X-Ray, ESP for players and chests (with additional ESP Lines), Tool Destroyer, Anti-AFK,
|
|
God Mode, Invisible Mode, NoClip, and several troll/utility tools.
|
|
- Each tab is divided into two sections (Left and Right) to separate core functionality
|
|
from extra settings.
|
|
- Parameters such as Farming Speed, Walk Speed, Fly Speed, and Boost Multiplier are adjustable.
|
|
- Additional features include:
|
|
• Anti-AFK implementations
|
|
• ESP Lines
|
|
• NoClip (pass through walls)
|
|
• Extensive Troll features (Kill All, Explode All, Teleport, Gravity, Dance, etc.)
|
|
- Note: Enjoy😘
|
|
--]]
|
|
|
|
---------- [ Libraries & Services ]----------
|
|
local Library = loadstring(game:HttpGet("https://pastebin.com/raw/b5QLVFiM"))()
|
|
|
|
local Players = game:GetService("Players")
|
|
local StarterGui = game:GetService("StarterGui")
|
|
local TweenService = game:GetService("TweenService")
|
|
local UserInputService = game:GetService("UserInputService")
|
|
local ReplicatedStorage = game:GetService("ReplicatedStorage")
|
|
local PathfindingService = game:GetService("PathfindingService")
|
|
local VirtualInputManager= game:GetService("VirtualInputManager")
|
|
local RunService = game:GetService("RunService")
|
|
|
|
local player = Players.LocalPlayer
|
|
local character = player.Character or player.CharacterAdded:Wait()
|
|
local humanoid = character:WaitForChild("Humanoid")
|
|
local rootPart = character:WaitForChild("HumanoidRootPart")
|
|
local backpack = player:WaitForChild("Backpack")
|
|
local playerGui = player:WaitForChild("PlayerGui")
|
|
local mouse = player:GetMouse()
|
|
|
|
---------- [ Global Variables & Settings ]----------
|
|
local Farm = false
|
|
local Rebirth = false
|
|
local IsSelling = false
|
|
local AutoFarmAI = false
|
|
local ESPEnabled = false
|
|
local FarmPaused = false
|
|
local XRayEnabled = false
|
|
local AutoSellEnabled = false
|
|
local ESPPlayerEnabled = false
|
|
local VisualEffectsEnabled = true
|
|
local ToolDestroyerEnabled = false
|
|
|
|
local GodModeEnabled = false
|
|
local InvisibleEnabled = false
|
|
local NoclipEnabled = false -- New: NoClip
|
|
|
|
local CurrentChest = nil
|
|
local FarmingSpeed = 0.001
|
|
local XRayTransparency = 0.2
|
|
|
|
local PlayerHighlights = {} -- Stores ESP info for players
|
|
local ChestHighlights = {} -- Stores ESP info for chests
|
|
local ESPLineObjects = {} -- Stores ESP lines for players (new feature)
|
|
|
|
-- Additional Tools (in Tools tab)
|
|
local InfiniteJumpEnabled = false
|
|
local FlyEnabled = false
|
|
local FlySpeed = 50 -- Default Fly Speed
|
|
local SpeedBoostEnabled = false
|
|
local SpeedBoostMultiplier = 2 -- Default Boost Multiplier
|
|
local BaseWalkSpeed = humanoid.WalkSpeed -- Save initial walk speed
|
|
|
|
---------- [ Helper Functions ]----------
|
|
-- Sends a notification to the player
|
|
local function notify(title, text)
|
|
StarterGui:SetCore("SendNotification", {
|
|
Title = title,
|
|
Text = text,
|
|
Duration = 5,
|
|
})
|
|
end
|
|
|
|
-- Disable all Anti-AFK connections (method 1)
|
|
local function disableAFK()
|
|
for _, con in ipairs(getconnections(player.Idled)) do
|
|
con:Disable()
|
|
end
|
|
end
|
|
|
|
-- Alternate Anti-AFK using simulated input (method 2)
|
|
local function antiAFKLoop()
|
|
while AntiAFKEnabled do
|
|
task.wait(50)
|
|
pcall(function()
|
|
VirtualInputManager:SendKeyEvent(true, "LeftShift", false, nil)
|
|
VirtualInputManager:SendKeyEvent(false, "LeftShift", false, nil)
|
|
end)
|
|
end
|
|
end
|
|
|
|
-- God Mode: Constantly sets health to maximum
|
|
local function enableGodMode()
|
|
spawn(function()
|
|
while GodModeEnabled do
|
|
if humanoid and humanoid.Health < humanoid.MaxHealth then
|
|
humanoid.Health = humanoid.MaxHealth
|
|
end
|
|
task.wait(0.1)
|
|
end
|
|
end)
|
|
end
|
|
|
|
-- Set character invisibility by toggling transparency
|
|
local function setInvisible(state)
|
|
if character then
|
|
for _, part in ipairs(character:GetDescendants()) do
|
|
if part:IsA("BasePart") then
|
|
part.Transparency = state and 1 or 0
|
|
end
|
|
end
|
|
end
|
|
end
|
|
|
|
-- Teleport the local player near a random other player
|
|
local function teleportToRandomPlayer()
|
|
local playersList = Players:GetPlayers()
|
|
local candidates = {}
|
|
for _, p in ipairs(playersList) do
|
|
if p ~= player and p.Character and p.Character:FindFirstChild("HumanoidRootPart") then
|
|
table.insert(candidates, p)
|
|
end
|
|
end
|
|
if #candidates > 0 then
|
|
local target = candidates[math.random(1, #candidates)]
|
|
if target and target.Character and target.Character:FindFirstChild("HumanoidRootPart") then
|
|
rootPart.CFrame = target.Character.HumanoidRootPart.CFrame * CFrame.new(5, 0, 0)
|
|
notify("Teleport", "Teleported to " .. target.Name)
|
|
end
|
|
end
|
|
end
|
|
|
|
-- Randomize positions of all players around the local player
|
|
local function randomizePlayerPositions()
|
|
local localChar = player.Character
|
|
if not (localChar and localChar:FindFirstChild("HumanoidRootPart")) then return end
|
|
local rootPos = localChar.HumanoidRootPart.CFrame
|
|
for _, p in ipairs(Players:GetPlayers()) do
|
|
if p ~= player and p.Character and p.Character:FindFirstChild("HumanoidRootPart") then
|
|
pcall(function()
|
|
p.Character.HumanoidRootPart.CFrame = rootPos * CFrame.new(math.random(-10,10), 0, math.random(-10,10))
|
|
end)
|
|
end
|
|
end
|
|
notify("Troll", "Player positions randomized.")
|
|
end
|
|
|
|
local function teleportToRandomLocation()
|
|
local randomOffset = Vector3.new(math.random(-50,50), 0, math.random(-50,50))
|
|
rootPart.CFrame = CFrame.new(rootPart.Position + randomOffset)
|
|
notify("Teleport", "Teleported to a random location.")
|
|
end
|
|
|
|
local function updateESPLine(targetPlayer)
|
|
if targetPlayer.Character and targetPlayer.Character:FindFirstChild("HumanoidRootPart") then
|
|
local startPos = rootPart.Position
|
|
local targetPos = targetPlayer.Character.HumanoidRootPart.Position
|
|
|
|
if not ESPLineObjects[targetPlayer] then
|
|
local attachment0 = Instance.new("Attachment")
|
|
attachment0.WorldPosition = startPos
|
|
attachment0.Parent = rootPart
|
|
|
|
local attachment1 = Instance.new("Attachment")
|
|
attachment1.WorldPosition = targetPos
|
|
attachment1.Parent = targetPlayer.Character.HumanoidRootPart
|
|
|
|
local beam = Instance.new("Beam")
|
|
beam.Attachment0 = attachment0
|
|
beam.Attachment1 = attachment1
|
|
beam.Color = ColorSequence.new(Color3.new(0, 1, 0))
|
|
beam.Width0 = 0.1
|
|
beam.Width1 = 0.1
|
|
beam.FaceCamera = true
|
|
beam.Parent = rootPart
|
|
|
|
ESPLineObjects[targetPlayer] = {beam = beam, attachment0 = attachment0, attachment1 = attachment1}
|
|
else
|
|
local objs = ESPLineObjects[targetPlayer]
|
|
objs.attachment0.WorldPosition = startPos
|
|
objs.attachment1.WorldPosition = targetPos
|
|
end
|
|
end
|
|
end
|
|
|
|
-- Clean up ESP line for a player
|
|
local function removeESPLine(targetPlayer)
|
|
if ESPLineObjects[targetPlayer] then
|
|
local objs = ESPLineObjects[targetPlayer]
|
|
if objs.beam then objs.beam:Destroy() end
|
|
if objs.attachment0 then objs.attachment0:Destroy() end
|
|
if objs.attachment1 then objs.attachment1:Destroy() end
|
|
ESPLineObjects[targetPlayer] = nil
|
|
end
|
|
end
|
|
|
|
---------- [ Window & Tabs Setup ]----------
|
|
local Window = Library:CreateWindow('JustShare - Hub Advanced Pro')
|
|
|
|
local Tabs = {
|
|
Home = Window:addTab('•Home + Settings'),
|
|
ESP = Window:addTab('•ESP'),
|
|
Troll = Window:addTab('•Troll'),
|
|
Tools = Window:addTab('•Tools'),
|
|
}
|
|
|
|
---------- [ SECTION: HOME TAB ]----------
|
|
local Home_Left = Tabs.Home:addSection() -- Primary Settings Section
|
|
local Home_Right = Tabs.Home:addSection() -- Advanced Settings Section
|
|
|
|
local Main_Home = Home_Left:addMenu("#Home")
|
|
|
|
---------- [ HOME TAB FUNCTIONS ]----------
|
|
local function DestroyTools()
|
|
while ToolDestroyerEnabled do
|
|
if character then
|
|
for _, tool in ipairs(character:GetChildren()) do
|
|
if tool:IsA("Tool") then
|
|
pcall(function() tool:Destroy() end)
|
|
end
|
|
end
|
|
end
|
|
if backpack then
|
|
for _, tool in ipairs(backpack:GetChildren()) do
|
|
if tool:IsA("Tool") then
|
|
pcall(function() tool:Destroy() end)
|
|
end
|
|
end
|
|
end
|
|
task.wait(0.1)
|
|
end
|
|
end
|
|
|
|
local function Sell()
|
|
if IsSelling then return end
|
|
IsSelling = true
|
|
|
|
local localChar = player.Character
|
|
if localChar and localChar:FindFirstChild("HumanoidRootPart") then
|
|
local oldPos = localChar.HumanoidRootPart.CFrame
|
|
localChar.HumanoidRootPart.CFrame = CFrame.new(3, 10, -160)
|
|
task.wait(0.1)
|
|
pcall(function() ReplicatedStorage.Events.AreaSell:FireServer() end)
|
|
task.wait(0.1)
|
|
localChar.HumanoidRootPart.CFrame = oldPos
|
|
end
|
|
|
|
IsSelling = false
|
|
end
|
|
|
|
local function AutoFarmLoop()
|
|
while Farm do
|
|
if FarmPaused then
|
|
task.wait(0.3)
|
|
else
|
|
local localChar = player.Character
|
|
if not localChar then continue end
|
|
|
|
local tool = localChar:FindFirstChildOfClass("Tool") or backpack:FindFirstChildOfClass("Tool")
|
|
if not tool then
|
|
notify("Error!", "No tool found! Disabling Auto Farm.")
|
|
Farm = false
|
|
return
|
|
elseif not localChar:FindFirstChildOfClass("Tool") then
|
|
pcall(function() localChar.Humanoid:EquipTool(tool) end)
|
|
task.wait(0.1)
|
|
end
|
|
|
|
if CurrentChest and CurrentChest.Parent then
|
|
local targetPosition = CurrentChest.Position
|
|
if (rootPart.Position - targetPosition).Magnitude > 0.5 then
|
|
rootPart.CFrame = CFrame.new(targetPosition)
|
|
end
|
|
|
|
if tool:FindFirstChild("RemoteClick") then
|
|
pcall(function() tool.RemoteClick:FireServer(CurrentChest) end)
|
|
end
|
|
task.wait(FarmingSpeed)
|
|
|
|
if AutoSellEnabled and playerGui.Gui and playerGui.Gui.Popups and
|
|
playerGui.Gui.Popups.BackpackFull and playerGui.Gui.Popups.BackpackFull.Visible then
|
|
FarmPaused = true
|
|
Sell()
|
|
FarmPaused = false
|
|
end
|
|
else
|
|
CurrentChest = nil
|
|
for _, v in ipairs(workspace.SandBlocks:GetChildren()) do
|
|
if not Farm then break end
|
|
if v:FindFirstChild("Chest") then
|
|
CurrentChest = v
|
|
v.CanCollide = false
|
|
if localChar then
|
|
local targetPosition = v.Position
|
|
if (rootPart.Position - targetPosition).Magnitude > 0.5 then
|
|
rootPart.CFrame = CFrame.new(targetPosition)
|
|
end
|
|
if tool:FindFirstChild("RemoteClick") then
|
|
pcall(function() tool.RemoteClick:FireServer(v) end)
|
|
end
|
|
task.wait(0.05)
|
|
end
|
|
break
|
|
end
|
|
end
|
|
end
|
|
end
|
|
task.wait(0.05)
|
|
end
|
|
end
|
|
|
|
Main_Home:addToggle('Auto Farm', false, function(state)
|
|
Farm = state
|
|
if state then
|
|
local localChar = player.Character
|
|
local tool = localChar and localChar:FindFirstChildOfClass("Tool") or backpack:FindFirstChildOfClass("Tool")
|
|
if not tool then
|
|
notify("Error!", "No tool found! Auto Farm disabled.")
|
|
Farm = false
|
|
return
|
|
end
|
|
if localChar and not localChar:FindFirstChildOfClass("Tool") then
|
|
pcall(function() localChar.Humanoid:EquipTool(tool) end)
|
|
task.wait(0.1)
|
|
end
|
|
notify("Success!", "Auto Farm enabled.")
|
|
task.spawn(AutoFarmLoop)
|
|
else
|
|
notify("Info", "Auto Farm disabled.")
|
|
end
|
|
end)
|
|
|
|
Main_Home:addToggle('Auto Farm With AI', false, function(state)
|
|
AutoFarmAI = state
|
|
if AutoFarmAI then
|
|
notify("Auto Farm AI Enabled", "Auto Farm AI is now active.")
|
|
task.spawn(function()
|
|
while AutoFarmAI do
|
|
task.wait(1)
|
|
end
|
|
end)
|
|
else
|
|
notify("Auto Farm AI Disabled", "Auto Farm AI is now disabled.")
|
|
end
|
|
end)
|
|
|
|
Main_Home:addToggle('Auto Sell', false, function(state)
|
|
AutoSellEnabled = state
|
|
notify("Success!", "Auto Sell " .. (state and "enabled." or "disabled."))
|
|
end)
|
|
|
|
Main_Home:addToggle('Auto Rebirth', false, function(state)
|
|
Rebirth = state
|
|
if Rebirth then
|
|
notify("Auto Rebirth Enabled", "Auto Rebirth is now active.")
|
|
task.spawn(function()
|
|
while Rebirth do
|
|
task.wait(1)
|
|
local coinsText = playerGui.Gui.Buttons.Coins.Amount.Text:gsub(',', '')
|
|
local rebirthCostText = playerGui.Gui.Rebirth.Needed.Coins.Amount.Text:gsub(',', '')
|
|
local coins = tonumber(coinsText)
|
|
local cost = tonumber(rebirthCostText)
|
|
if coins and cost and coins > cost then
|
|
warn('Rebirth triggered!')
|
|
pcall(function() ReplicatedStorage.Events.Rebirth:FireServer() end)
|
|
if playerGui.ToolBox then
|
|
playerGui.ToolBox.Text = "Bucket"
|
|
end
|
|
repeat task.wait(0.1) until playerGui.Gui.Popups.GiveReward and playerGui.Gui.Popups.GiveReward.Visible == true
|
|
playerGui.Gui.Popups.GiveReward.Visible = false
|
|
task.wait()
|
|
end
|
|
end
|
|
end)
|
|
end
|
|
end)
|
|
|
|
Main_Home:addToggle('X-Ray', false, function(state)
|
|
XRayEnabled = state
|
|
if XRayEnabled then
|
|
for _, obj in ipairs(workspace:GetDescendants()) do
|
|
if obj:IsA("BasePart") and not obj:IsDescendantOf(player.Character) then
|
|
obj.Transparency = XRayTransparency
|
|
end
|
|
end
|
|
notify("X-Ray Enabled", "Objects are now transparent.")
|
|
else
|
|
for _, obj in ipairs(workspace:GetDescendants()) do
|
|
if obj:IsA("BasePart") then
|
|
obj.Transparency = 0
|
|
end
|
|
end
|
|
notify("X-Ray Disabled", "Objects are now back to normal.")
|
|
end
|
|
end)
|
|
|
|
local Home_Right_Menu = Home_Right:addMenu("#Settings")
|
|
Home_Right_Menu:addTextbox('Farming Speed', tostring(FarmingSpeed), function(value)
|
|
local newSpeed = tonumber(value)
|
|
if newSpeed and newSpeed > 0 then
|
|
FarmingSpeed = newSpeed
|
|
notify("Farming Speed Updated", "Farming speed set to: " .. tostring(newSpeed))
|
|
else
|
|
notify("Invalid Input", "Enter a valid positive number for Farming Speed.")
|
|
end
|
|
end)
|
|
Home_Right_Menu:addToggle("Anti-AFK", false, function(state)
|
|
AntiAFKEnabled = state
|
|
if AntiAFKEnabled then
|
|
disableAFK()
|
|
task.spawn(antiAFKLoop)
|
|
notify("Anti-AFK Enabled", "Idle kick prevention active.")
|
|
else
|
|
notify("Anti-AFK Disabled", "Idle kick prevention off.")
|
|
end
|
|
end)
|
|
|
|
---------- [ SECTION: ESP TAB ]----------
|
|
local ESP_Left = Tabs.ESP:addSection() -- ESP for Players
|
|
local ESP_Right = Tabs.ESP:addSection() -- ESP for Chests / Extras
|
|
|
|
local ESP_Left_Menu = ESP_Left:addMenu("#Player ESP")
|
|
local ESP_Right_Menu = ESP_Right:addMenu("#Chest ESP / Extras")
|
|
|
|
local espLinesToggle = nil
|
|
|
|
ESP_Left_Menu:addToggle('ESP Player', false, function(state)
|
|
ESPPlayerEnabled = state
|
|
|
|
local function AddPlayerESP(targetPlayer)
|
|
if targetPlayer.Character and targetPlayer.Character:FindFirstChild("HumanoidRootPart") then
|
|
local highlight = Instance.new("Highlight")
|
|
highlight.Parent = targetPlayer.Character
|
|
highlight.Adornee = targetPlayer.Character.HumanoidRootPart
|
|
highlight.FillColor = Color3.fromRGB(255, 0, 0)
|
|
highlight.FillTransparency = 0.5
|
|
highlight.OutlineColor = Color3.fromRGB(255, 255, 255)
|
|
highlight.OutlineTransparency = 0.5
|
|
|
|
local billboard = Instance.new("BillboardGui")
|
|
billboard.Parent = targetPlayer.Character
|
|
billboard.Adornee = targetPlayer.Character.HumanoidRootPart
|
|
billboard.Size = UDim2.new(0, 100, 0, 50)
|
|
billboard.StudsOffset = Vector3.new(0, 3, 0)
|
|
billboard.AlwaysOnTop = true
|
|
|
|
local nameLabel = Instance.new("TextLabel")
|
|
nameLabel.Parent = billboard
|
|
nameLabel.Size = UDim2.new(1, 0, 1, 0)
|
|
nameLabel.Text = targetPlayer.Name
|
|
nameLabel.TextColor3 = Color3.new(1,1,1)
|
|
nameLabel.BackgroundTransparency = 1
|
|
nameLabel.TextStrokeTransparency = 0.5
|
|
|
|
local distanceLabel = Instance.new("TextLabel")
|
|
distanceLabel.Parent = billboard
|
|
distanceLabel.Size = UDim2.new(1, 0, 0, 20)
|
|
distanceLabel.Position = UDim2.new(0, 0, 1, 0)
|
|
distanceLabel.TextColor3 = Color3.new(1,1,1)
|
|
distanceLabel.BackgroundTransparency = 1
|
|
distanceLabel.TextStrokeTransparency = 0.5
|
|
|
|
task.spawn(function()
|
|
while ESPPlayerEnabled and targetPlayer.Character and targetPlayer.Character:FindFirstChild("HumanoidRootPart") do
|
|
local dist = (targetPlayer.Character.HumanoidRootPart.Position - rootPart.Position).Magnitude
|
|
distanceLabel.Text = string.format("Distance: %.2f", dist)
|
|
if espLinesToggle and espLinesToggle.state then
|
|
updateESPLine(targetPlayer)
|
|
end
|
|
task.wait(1)
|
|
end
|
|
end)
|
|
table.insert(PlayerHighlights, {player = targetPlayer, highlight = highlight, billboard = billboard})
|
|
end
|
|
end
|
|
|
|
local function RemovePlayerESP(targetPlayer)
|
|
for i, esp in ipairs(PlayerHighlights) do
|
|
if esp.player == targetPlayer then
|
|
if esp.highlight then esp.highlight:Destroy() end
|
|
if esp.billboard then esp.billboard:Destroy() end
|
|
table.remove(PlayerHighlights, i)
|
|
removeESPLine(targetPlayer)
|
|
break
|
|
end
|
|
end
|
|
end
|
|
|
|
if ESPPlayerEnabled then
|
|
notify("ESP Player Enabled", "Player highlights and distances are now visible.")
|
|
for _, p in ipairs(Players:GetPlayers()) do
|
|
if p ~= player then
|
|
AddPlayerESP(p)
|
|
end
|
|
end
|
|
Players.PlayerAdded:Connect(function(p)
|
|
if p ~= player then AddPlayerESP(p) end
|
|
end)
|
|
Players.PlayerRemoving:Connect(function(p) RemovePlayerESP(p) end)
|
|
|
|
if not espLinesToggle then
|
|
espLinesToggle = ESP_Left_Menu:addToggle("ESP Lines", false, function(lineState)
|
|
for _, p in ipairs(Players:GetPlayers()) do
|
|
if p ~= player then
|
|
if lineState then
|
|
updateESPLine(p)
|
|
else
|
|
removeESPLine(p)
|
|
end
|
|
end
|
|
end
|
|
end)
|
|
end
|
|
else
|
|
notify("ESP Player Disabled", "Player highlights and distances are now hidden.")
|
|
for _, esp in ipairs(PlayerHighlights) do
|
|
if esp.highlight then esp.highlight:Destroy() end
|
|
if esp.billboard then esp.billboard:Destroy() end
|
|
end
|
|
PlayerHighlights = {}
|
|
for p, _ in pairs(ESPLineObjects) do
|
|
removeESPLine(p)
|
|
end
|
|
|
|
if espLinesToggle then
|
|
Library:DestroyGui(espLinesToggle)
|
|
espLinesToggle = nil
|
|
end
|
|
end
|
|
end)
|
|
|
|
ESP_Right_Menu:addToggle('ESP Chest', false, function(state)
|
|
ESPEnabled = state
|
|
if ESPEnabled then
|
|
for _, v in ipairs(workspace.SandBlocks:GetChildren()) do
|
|
if v:FindFirstChild("Chest") then
|
|
local highlight = Instance.new("Highlight")
|
|
highlight.Parent = v
|
|
highlight.Adornee = v
|
|
highlight.FillColor = Color3.fromRGB(255, 0, 0)
|
|
highlight.FillTransparency = 0.5
|
|
highlight.OutlineColor = Color3.fromRGB(255, 255, 255)
|
|
highlight.OutlineTransparency = 0.5
|
|
table.insert(ChestHighlights, highlight)
|
|
end
|
|
end
|
|
else
|
|
for _, h in ipairs(ChestHighlights) do
|
|
h:Destroy()
|
|
end
|
|
ChestHighlights = {}
|
|
end
|
|
end)
|
|
|
|
task.spawn(function()
|
|
while true do
|
|
if ESPEnabled then
|
|
for _, v in ipairs(workspace.SandBlocks:GetChildren()) do
|
|
if v:FindFirstChild("Chest") then
|
|
local exists = false
|
|
for _, h in ipairs(ChestHighlights) do
|
|
if h.Adornee == v then
|
|
exists = true
|
|
break
|
|
end
|
|
end
|
|
if not exists then
|
|
local highlight = Instance.new("Highlight")
|
|
highlight.Parent = v
|
|
highlight.Adornee = v
|
|
highlight.FillColor = Color3.fromRGB(255, 0, 0)
|
|
highlight.FillTransparency = 0.5
|
|
highlight.OutlineColor = Color3.fromRGB(255, 255, 255)
|
|
highlight.OutlineTransparency = 0.5
|
|
table.insert(ChestHighlights, highlight)
|
|
end
|
|
end
|
|
end
|
|
|
|
for i = #ChestHighlights, 1, -1 do
|
|
local h = ChestHighlights[i]
|
|
if not h.Adornee or not h.Adornee.Parent then
|
|
h:Destroy()
|
|
table.remove(ChestHighlights, i)
|
|
end
|
|
end
|
|
end
|
|
task.wait(1)
|
|
end
|
|
end)
|
|
|
|
---------- [ SECTION: TROLL TAB ]----------
|
|
local Troll_Left = Tabs.Troll:addSection() -- Troll Tools Section
|
|
local Troll_Right = Tabs.Troll:addSection() -- Troll Actions Section
|
|
|
|
local Troll_Left_Menu = Troll_Left:addMenu("#Troll")
|
|
local Troll_Right_Menu = Troll_Right:addMenu("#Actions")
|
|
|
|
-- Existing Troll Feature: Remove Tool
|
|
Troll_Left_Menu:addToggle('Remove Tool', false, function(state)
|
|
ToolDestroyerEnabled = state
|
|
if ToolDestroyerEnabled then
|
|
notify("Tool Destroyer Enabled", "All tools will be removed automatically.")
|
|
task.spawn(DestroyTools)
|
|
else
|
|
notify("Tool Destroyer Disabled", "Tool removal has been stopped.")
|
|
end
|
|
end)
|
|
|
|
local joinIslandEvent = ReplicatedStorage:FindFirstChild("Events") and ReplicatedStorage.Events:FindFirstChild("JoinIsland")
|
|
if not joinIslandEvent then
|
|
warn("JoinIsland Event not found! Ensure it exists in ReplicatedStorage.Events.")
|
|
end
|
|
|
|
Troll_Right_Menu:addToggle("Bring All Players (Instant)", _G.BringAllPlayers or false, function(value)
|
|
_G.BringAllPlayers = value
|
|
if _G.BringAllPlayers then
|
|
task.spawn(function()
|
|
local localChar = player.Character
|
|
if localChar and localChar:FindFirstChild("HumanoidRootPart") then
|
|
local rootPos = localChar.HumanoidRootPart.CFrame
|
|
for _, p in ipairs(Players:GetPlayers()) do
|
|
if p ~= player and p.Character and p.Character:FindFirstChild("HumanoidRootPart") then
|
|
pcall(function()
|
|
if joinIslandEvent then
|
|
joinIslandEvent:FireServer(p)
|
|
else
|
|
p.Character.HumanoidRootPart.CFrame = rootPos + Vector3.new(math.random(-5,5), 0, math.random(-5,5))
|
|
end
|
|
end)
|
|
end
|
|
end
|
|
end
|
|
end)
|
|
end
|
|
end)
|
|
|
|
Troll_Right_Menu:addButton("Teleport to Random Player", function()
|
|
teleportToRandomPlayer()
|
|
end)
|
|
|
|
Troll_Right_Menu:addButton("Randomize Player Positions", function()
|
|
randomizePlayerPositions()
|
|
end)
|
|
|
|
Troll_Right_Menu:addButton("Kill All", function()
|
|
for _, p in ipairs(Players:GetPlayers()) do
|
|
if p ~= player and p.Character and p.Character:FindFirstChild("Humanoid") then
|
|
pcall(function() p.Character:BreakJoints() end)
|
|
end
|
|
end
|
|
notify("Troll", "Kill All executed!")
|
|
end)
|
|
|
|
Troll_Right_Menu:addButton("Explode All", function()
|
|
for _, p in ipairs(Players:GetPlayers()) do
|
|
if p ~= player and p.Character and p.Character:FindFirstChild("HumanoidRootPart") then
|
|
local explosion = Instance.new("Explosion")
|
|
explosion.BlastRadius = 10
|
|
explosion.BlastPressure = 50000
|
|
explosion.Position = p.Character.HumanoidRootPart.Position
|
|
explosion.Parent = workspace
|
|
end
|
|
end
|
|
notify("Troll", "Explode All executed!")
|
|
end)
|
|
|
|
Troll_Right_Menu:addButton("Freeze All", function()
|
|
for _, p in ipairs(Players:GetPlayers()) do
|
|
if p ~= player and p.Character then
|
|
for _, part in ipairs(p.Character:GetDescendants()) do
|
|
if part:IsA("BasePart") then
|
|
part.Anchored = true
|
|
end
|
|
end
|
|
end
|
|
end
|
|
notify("Troll", "Freeze All executed!")
|
|
end)
|
|
|
|
Troll_Right_Menu:addButton("Unfreeze All", function()
|
|
for _, p in ipairs(Players:GetPlayers()) do
|
|
if p ~= player and p.Character then
|
|
for _, part in ipairs(p.Character:GetDescendants()) do
|
|
if part:IsA("BasePart") then
|
|
part.Anchored = false
|
|
end
|
|
end
|
|
end
|
|
end
|
|
notify("Troll", "Unfreeze All executed!")
|
|
end)
|
|
|
|
Troll_Right_Menu:addButton("Teleport All to Local", function()
|
|
for _, p in ipairs(Players:GetPlayers()) do
|
|
if p ~= player and p.Character and p.Character:FindFirstChild("HumanoidRootPart") then
|
|
p.Character.HumanoidRootPart.CFrame = rootPart.CFrame + Vector3.new(math.random(-3,3), 0, math.random(-3,3))
|
|
end
|
|
end
|
|
notify("Troll", "Teleport All to Local executed!")
|
|
end)
|
|
|
|
Troll_Right_Menu:addButton("Teleport All to Random", function()
|
|
for _, p in ipairs(Players:GetPlayers()) do
|
|
if p ~= player and p.Character and p.Character:FindFirstChild("HumanoidRootPart") then
|
|
p.Character.HumanoidRootPart.CFrame = CFrame.new(math.random(-500,500), 10, math.random(-500,500))
|
|
end
|
|
end
|
|
notify("Troll", "Teleport All to Random executed!")
|
|
end)
|
|
|
|
Troll_Right_Menu:addButton("Swap All Positions", function()
|
|
local positions = {}
|
|
for _, p in ipairs(Players:GetPlayers()) do
|
|
if p ~= player and p.Character and p.Character:FindFirstChild("HumanoidRootPart") then
|
|
table.insert(positions, p.Character.HumanoidRootPart.CFrame)
|
|
end
|
|
end
|
|
for i, p in ipairs(Players:GetPlayers()) do
|
|
if p ~= player and p.Character and p.Character:FindFirstChild("HumanoidRootPart") and positions[i] then
|
|
p.Character.HumanoidRootPart.CFrame = positions[i]
|
|
end
|
|
end
|
|
notify("Troll", "Swap All Positions executed!")
|
|
end)
|
|
|
|
Troll_Right_Menu:addButton("Set Gravity Low", function()
|
|
workspace.Gravity = 10
|
|
notify("Troll", "Gravity set to low!")
|
|
end)
|
|
|
|
Troll_Right_Menu:addButton("Set Gravity High", function()
|
|
workspace.Gravity = 300
|
|
notify("Troll", "Gravity set to high!")
|
|
end)
|
|
|
|
Troll_Right_Menu:addButton("Force Dance All", function()
|
|
for _, p in ipairs(Players:GetPlayers()) do
|
|
if p ~= player and p.Character and p.Character:FindFirstChild("HumanoidRootPart") then
|
|
spawn(function()
|
|
local duration = 5
|
|
local startTime = tick()
|
|
while tick() - startTime < duration do
|
|
p.Character.HumanoidRootPart.CFrame = p.Character.HumanoidRootPart.CFrame * CFrame.Angles(0, math.rad(20), 0)
|
|
task.wait(0.1)
|
|
end
|
|
end)
|
|
end
|
|
end
|
|
notify("Troll", "Force Dance All executed!")
|
|
end)
|
|
|
|
Troll_Right_Menu:addButton("Rename All Players", function()
|
|
for _, p in ipairs(Players:GetPlayers()) do
|
|
if p ~= player then
|
|
p.DisplayName = "Trolled!"
|
|
end
|
|
end
|
|
notify("Troll", "Rename All Players executed!")
|
|
end)
|
|
|
|
Troll_Right_Menu:addButton("Spawn Bricks Rain", function()
|
|
for _, p in ipairs(Players:GetPlayers()) do
|
|
if p ~= player and p.Character and p.Character:FindFirstChild("HumanoidRootPart") then
|
|
for i = 1, 5 do
|
|
local brick = Instance.new("Part")
|
|
brick.Size = Vector3.new(4,1,4)
|
|
brick.Position = p.Character.HumanoidRootPart.Position + Vector3.new(math.random(-3,3), 50, math.random(-3,3))
|
|
brick.Anchored = false
|
|
brick.Parent = workspace
|
|
game.Debris:AddItem(brick, 5)
|
|
end
|
|
end
|
|
end
|
|
notify("Troll", "Spawn Bricks Rain executed!")
|
|
end)
|
|
|
|
Troll_Right_Menu:addButton("Spin All Players", function()
|
|
for _, p in ipairs(Players:GetPlayers()) do
|
|
if p ~= player and p.Character and p.Character:FindFirstChild("HumanoidRootPart") then
|
|
spawn(function()
|
|
local duration = 5
|
|
local startTime = tick()
|
|
while tick() - startTime < duration do
|
|
p.Character.HumanoidRootPart.CFrame = p.Character.HumanoidRootPart.CFrame * CFrame.Angles(0, math.rad(30), 0)
|
|
task.wait(0.1)
|
|
end
|
|
end)
|
|
end
|
|
end
|
|
notify("Troll", "Spin All Players executed!")
|
|
end)
|
|
|
|
Troll_Right_Menu:addButton("Fake Server Crash", function()
|
|
spawn(function()
|
|
local duration = 3
|
|
local startTime = tick()
|
|
while tick() - startTime < duration do
|
|
local explosion = Instance.new("Explosion")
|
|
explosion.BlastRadius = 15
|
|
explosion.BlastPressure = 100000
|
|
explosion.Position = rootPart.Position + Vector3.new(math.random(-5,5), 0, math.random(-5,5))
|
|
explosion.Parent = workspace
|
|
task.wait(0.2)
|
|
end
|
|
end)
|
|
notify("Troll", "Fake Server Crash executed!")
|
|
end)
|
|
|
|
Troll_Right_Menu:addButton("Color All Players", function()
|
|
for _, p in ipairs(Players:GetPlayers()) do
|
|
if p ~= player and p.Character then
|
|
for _, part in ipairs(p.Character:GetDescendants()) do
|
|
if part:IsA("BasePart") then
|
|
part.BrickColor = BrickColor.Random()
|
|
end
|
|
end
|
|
end
|
|
end
|
|
notify("Troll", "Color All Players executed!")
|
|
end)
|
|
|
|
Troll_Right_Menu:addButton("Anchor All Players", function()
|
|
for _, p in ipairs(Players:GetPlayers()) do
|
|
if p ~= player and p.Character then
|
|
for _, part in ipairs(p.Character:GetDescendants()) do
|
|
if part:IsA("BasePart") then
|
|
part.Anchored = true
|
|
end
|
|
end
|
|
end
|
|
end
|
|
notify("Troll", "Anchor All Players executed!")
|
|
end)
|
|
|
|
Troll_Right_Menu:addButton("Explode Self", function()
|
|
if player.Character and player.Character:FindFirstChild("HumanoidRootPart") then
|
|
local explosion = Instance.new("Explosion")
|
|
explosion.BlastRadius = 10
|
|
explosion.BlastPressure = 50000
|
|
explosion.Position = player.Character.HumanoidRootPart.Position
|
|
explosion.Parent = workspace
|
|
notify("Troll", "Explode Self executed!")
|
|
end
|
|
end)
|
|
|
|
Troll_Right_Menu:addButton("Chain Lightning", function()
|
|
local function getNearestPlayer(fromPos)
|
|
local nearest, minDist = nil, math.huge
|
|
for _, p in ipairs(Players:GetPlayers()) do
|
|
if p ~= player and p.Character and p.Character:FindFirstChild("HumanoidRootPart") then
|
|
local dist = (p.Character.HumanoidRootPart.Position - fromPos).Magnitude
|
|
if dist < minDist then
|
|
minDist = dist
|
|
nearest = p
|
|
end
|
|
end
|
|
end
|
|
return nearest
|
|
end
|
|
|
|
local currentPos = rootPart.Position
|
|
for i = 1, 5 do
|
|
local target = getNearestPlayer(currentPos)
|
|
if target and target.Character and target.Character:FindFirstChild("HumanoidRootPart") then
|
|
local explosion = Instance.new("Explosion")
|
|
explosion.BlastRadius = 8
|
|
explosion.BlastPressure = 80000
|
|
explosion.Position = target.Character.HumanoidRootPart.Position
|
|
explosion.Parent = workspace
|
|
currentPos = target.Character.HumanoidRootPart.Position
|
|
task.wait(0.5)
|
|
else
|
|
break
|
|
end
|
|
end
|
|
notify("Troll", "Chain Lightning executed!")
|
|
end)
|
|
|
|
-- 19. Force Respawn All: Memaksa semua pemain (selain lokal) respawn
|
|
Troll_Right_Menu:addButton("Force Respawn All", function()
|
|
for _, p in ipairs(Players:GetPlayers()) do
|
|
if p ~= player and p.Character then
|
|
p.Character:BreakJoints()
|
|
end
|
|
end
|
|
notify("Troll", "Force Respawn All executed!")
|
|
end)
|
|
|
|
-- 20. Spin Self: Putar karakter pemain lokal selama 5 detik
|
|
Troll_Right_Menu:addButton("Spin Self", function()
|
|
if player.Character and player.Character:FindFirstChild("HumanoidRootPart") then
|
|
local duration = 5
|
|
local startTime = tick()
|
|
while tick() - startTime < duration do
|
|
player.Character.HumanoidRootPart.CFrame = player.Character.HumanoidRootPart.CFrame * CFrame.Angles(0, math.rad(30), 0)
|
|
task.wait(0.1)
|
|
end
|
|
notify("Troll", "Spin Self executed!")
|
|
end
|
|
end)
|
|
|
|
-- 21. Random Freeze All: Secara acak anchor sebagian bagian dari karakter pemain (selain lokal)
|
|
Troll_Right_Menu:addButton("Random Freeze All", function()
|
|
for _, p in ipairs(Players:GetPlayers()) do
|
|
if p ~= player and p.Character then
|
|
for _, part in ipairs(p.Character:GetDescendants()) do
|
|
if part:IsA("BasePart") then
|
|
part.Anchored = (math.random() < 0.5)
|
|
end
|
|
end
|
|
end
|
|
end
|
|
notify("Troll", "Random Freeze All executed!")
|
|
end)
|
|
|
|
---------- [ SECTION: TOOLS TAB ]----------
|
|
local Tools_Left = Tabs.Tools:addSection() -- Primary Tools Section
|
|
local Main_Tools = Tools_Left:addMenu("#Tools")
|
|
local Tools_Right = Tabs.Tools:addSection() -- Extra Tools Section
|
|
local Extra_Tools = Tools_Right:addMenu("#Extra Tools")
|
|
|
|
Main_Tools:addButton("Reset Character", function()
|
|
if player.Character then
|
|
player.Character:BreakJoints()
|
|
notify("Reset Character", "Character will respawn shortly.")
|
|
end
|
|
end)
|
|
|
|
Main_Tools:addButton("Teleport to Cursor", function()
|
|
if mouse and rootPart then
|
|
local targetPos = mouse.Hit.p
|
|
rootPart.CFrame = CFrame.new(targetPos)
|
|
notify("Teleport", "Teleported to cursor position.")
|
|
end
|
|
end)
|
|
|
|
Main_Tools:addButton("Teleport to Random Location", function()
|
|
teleportToRandomLocation()
|
|
end)
|
|
|
|
Extra_Tools:addTextbox("Set Walk Speed", tostring(BaseWalkSpeed), function(value)
|
|
local newSpeed = tonumber(value)
|
|
if newSpeed and newSpeed > 0 then
|
|
BaseWalkSpeed = newSpeed
|
|
if SpeedBoostEnabled then
|
|
humanoid.WalkSpeed = BaseWalkSpeed * SpeedBoostMultiplier
|
|
else
|
|
humanoid.WalkSpeed = BaseWalkSpeed
|
|
end
|
|
notify("Walk Speed", "Walk speed set to " .. tostring(newSpeed))
|
|
else
|
|
notify("Invalid Input", "Enter a valid positive number for Walk Speed.")
|
|
end
|
|
end)
|
|
|
|
Extra_Tools:addToggle("Infinite Jump", false, function(state)
|
|
InfiniteJumpEnabled = state
|
|
notify("Infinite Jump", state and "Infinite Jump enabled." or "Infinite Jump disabled.")
|
|
end)
|
|
UserInputService.JumpRequest:Connect(function()
|
|
if InfiniteJumpEnabled then
|
|
if humanoid then
|
|
humanoid:ChangeState(Enum.HumanoidStateType.Jumping)
|
|
end
|
|
end
|
|
end)
|
|
|
|
Extra_Tools:addToggle("Fly Mode", false, function(state)
|
|
FlyEnabled = state
|
|
if FlyEnabled then
|
|
notify("Fly Mode", "Fly mode enabled. Press [E] to ascend, [Q] to descend.")
|
|
else
|
|
notify("Fly Mode", "Fly mode disabled.")
|
|
end
|
|
end)
|
|
Extra_Tools:addTextbox("Set Fly Speed", tostring(FlySpeed), function(value)
|
|
local newFlySpeed = tonumber(value)
|
|
if newFlySpeed and newFlySpeed > 0 then
|
|
FlySpeed = newFlySpeed
|
|
notify("Fly Speed", "Fly speed set to " .. tostring(newFlySpeed))
|
|
else
|
|
notify("Invalid Input", "Enter a valid positive number for Fly Speed.")
|
|
end
|
|
end)
|
|
|
|
local flying = false
|
|
UserInputService.InputBegan:Connect(function(input, gameProcessed)
|
|
if gameProcessed then return end
|
|
if FlyEnabled then
|
|
if input.KeyCode == Enum.KeyCode.E then
|
|
flying = "ascend"
|
|
elseif input.KeyCode == Enum.KeyCode.Q then
|
|
flying = "descend"
|
|
end
|
|
end
|
|
end)
|
|
UserInputService.InputEnded:Connect(function(input, gameProcessed)
|
|
if gameProcessed then return end
|
|
if FlyEnabled and (input.KeyCode == Enum.KeyCode.E or input.KeyCode == Enum.KeyCode.Q) then
|
|
flying = false
|
|
end
|
|
end)
|
|
RunService.RenderStepped:Connect(function(delta)
|
|
if FlyEnabled and flying and rootPart then
|
|
local newPos = rootPart.Position
|
|
if flying == "ascend" then
|
|
newPos = newPos + Vector3.new(0, FlySpeed * delta, 0)
|
|
elseif flying == "descend" then
|
|
newPos = newPos - Vector3.new(0, FlySpeed * delta, 0)
|
|
end
|
|
rootPart.CFrame = CFrame.new(newPos)
|
|
end
|
|
end)
|
|
|
|
Extra_Tools:addToggle("Speed Boost", false, function(state)
|
|
SpeedBoostEnabled = state
|
|
if SpeedBoostEnabled then
|
|
humanoid.WalkSpeed = BaseWalkSpeed * SpeedBoostMultiplier
|
|
notify("Speed Boost", "Speed Boost enabled.")
|
|
else
|
|
humanoid.WalkSpeed = BaseWalkSpeed
|
|
notify("Speed Boost", "Speed Boost disabled.")
|
|
end
|
|
end)
|
|
Extra_Tools:addTextbox("Boost Multiplier", tostring(SpeedBoostMultiplier), function(value)
|
|
local newMultiplier = tonumber(value)
|
|
if newMultiplier and newMultiplier > 0 then
|
|
SpeedBoostMultiplier = newMultiplier
|
|
if SpeedBoostEnabled then
|
|
humanoid.WalkSpeed = BaseWalkSpeed * SpeedBoostMultiplier
|
|
end
|
|
notify("Boost Multiplier", "Boost multiplier set to " .. tostring(newMultiplier))
|
|
else
|
|
notify("Invalid Input", "Enter a valid positive number for Boost Multiplier.")
|
|
end
|
|
end)
|
|
|
|
Extra_Tools:addToggle("God Mode", false, function(state)
|
|
GodModeEnabled = state
|
|
if GodModeEnabled then
|
|
notify("God Mode", "God Mode enabled.")
|
|
enableGodMode()
|
|
else
|
|
notify("God Mode", "God Mode disabled.")
|
|
end
|
|
end)
|
|
|
|
Extra_Tools:addToggle("Invisible Mode", false, function(state)
|
|
InvisibleEnabled = state
|
|
setInvisible(InvisibleEnabled)
|
|
notify("Invisible Mode", state and "You are now invisible." or "You are now visible.")
|
|
end)
|
|
|
|
-- New Feature: NoClip
|
|
Extra_Tools:addToggle("NoClip", false, function(state)
|
|
NoclipEnabled = state
|
|
if NoclipEnabled then
|
|
notify("NoClip", "NoClip enabled. You can pass through walls.")
|
|
else
|
|
notify("NoClip", "NoClip disabled.")
|
|
end
|
|
end)
|
|
RunService.RenderStepped:Connect(function()
|
|
if NoclipEnabled and character then
|
|
for _, part in ipairs(character:GetDescendants()) do
|
|
if part:IsA("BasePart") then
|
|
part.CanCollide = false
|
|
end
|
|
end
|
|
end
|
|
end)
|
|
|
|
---------- [ End of Script ]----------
|
|
notify("Loaded", "JustShare Hub Advanced Pro loaded successfully. Enjoy!")
|