local Players = game:GetService("Players")
local RunService = game:GetService("RunService")

local player = Players.LocalPlayer
local char = player.Character or player.CharacterAdded:Wait()
local rootPart = char:WaitForChild("HumanoidRootPart")

-- Find F3X SyncAPI
local tool

for _, v in player:GetDescendants() do
	if v.Name == "SyncAPI" then
		tool = v.Parent
	end
end

for _, v in game.ReplicatedStorage:GetDescendants() do
	if v.Name == "SyncAPI" then
		tool = v.Parent
	end
end

local remote = tool
	and tool:FindFirstChild("SyncAPI")
	and tool.SyncAPI:FindFirstChild("ServerEndpoint")

local function remoteExecute(args)
	if remote then
		remote:InvokeServer(unpack(args))
	end
end

local function SetCollision(part, boolean)
	remoteExecute({
		"SyncCollision",
		{
			{
				Part = part,
				CanCollide = boolean
			}
		}
	})
end

local function CreatePart(cf, parent)
	remoteExecute({
		"CreatePart",
		"Normal",
		cf,
		parent
	})
end

local function Resize(part, size, cf)
	remoteExecute({
		"SyncResize",
		{
			{
				Part = part,
				CFrame = cf,
				Size = size
			}
		}
	})
end

local function AddMesh(part)
	remoteExecute({
		"CreateMeshes",
		{
			{
				Part = part
			}
		}
	})
end

local function SetMesh(part, meshid)
	remoteExecute({
		"SyncMesh",
		{
			{
				Part = part,
				MeshId = "rbxassetid://" .. meshid
			}
		}
	})
end

local function SetName(part, name)
	remoteExecute({
		"SetName",
		{ part },
		name
	})
end

local function SetLocked(part, boolean)
	remoteExecute({
		"SetLocked",
		{ part },
		boolean
	})
end

local function SetTrans(part, transparency)
	remoteExecute({
		"SyncMaterial",
		{
			{
				Part = part,
				Transparency = transparency
			}
		}
	})
end

local function Color(part, color)
	remoteExecute({
		"SyncColor",
		{
			{
				Part = part,
				Color = color,
				UnionColoring = false
			}
		}
	})
end

-- Hide the original character
if char:FindFirstChild("Torso") then
	pcall(function()
		SetTrans(char["Right Arm"], 1)
		SetTrans(char["Left Arm"], 1)
		SetTrans(char["Torso"], 1)
		SetTrans(char["Left Leg"], 1)
		SetTrans(char["Right Leg"], 1)
		SetTrans(char["Head"], 1)
	end)

	-- Create reanimation parts
	local partNames = {
		"Right Arm FE",
		"Left Arm FE",
		"Right Leg FE",
		"Left Leg FE",
		"Head FE",
		"Torso FE"
	}

	for _, name in ipairs(partNames) do
		CreatePart(
			rootPart.CFrame * CFrame.new(0, 3, 0),
			char.Torso
		)

		local newPart = char.Torso:WaitForChild("Part", 2)

		if newPart then
			SetCollision(newPart, false)

			Resize(
				newPart,
				Vector3.new(0.9, 1.9, 0.9),
				rootPart.CFrame * CFrame.new(0, 3, 0)
			)

			SetName(newPart, name)
		end
	end

	-- Apply character meshes
	pcall(function()
		local head = char.Torso:WaitForChild("Head FE")
		local torso = char.Torso:WaitForChild("Torso FE")

		AddMesh(head)
		SetMesh(head, "6571349341")

		AddMesh(torso)
		SetMesh(torso, "12800536037")

		for _, limbName in ipairs({
			"Left Leg FE",
			"Right Leg FE",
			"Right Arm FE",
			"Left Arm FE"
		}) do
			local limb = char.Torso:WaitForChild(limbName)

			AddMesh(limb)
			SetMesh(limb, "127739625807358")
		end

		-- Colors
		Color(head, Color3.fromRGB(255, 255, 255))
		Color(torso, Color3.fromRGB(180, 210, 228))

		Color(
			char.Torso:WaitForChild("Right Arm FE"),
			Color3.fromRGB(255, 255, 255)
		)

		Color(
			char.Torso:WaitForChild("Left Arm FE"),
			Color3.fromRGB(255, 255, 255)
		)

		Color(
			char.Torso:WaitForChild("Right Leg FE"),
			Color3.fromRGB(20, 20, 20)
		)

		Color(
			char.Torso:WaitForChild("Left Leg FE"),
			Color3.fromRGB(20, 20, 20)
		)

		-- Lock reanimation parts
		for _, name in ipairs(partNames) do
			local part = char.Torso:FindFirstChild(name)

			if part then
				SetLocked(part, true)
			end
		end
	end)

	-- Reanimation follow
	local animTick = 0

	RunService.RenderStepped:Connect(function(dt)
		pcall(function()
			local rightArmFE = char.Torso:FindFirstChild("Right Arm FE")
			local leftArmFE = char.Torso:FindFirstChild("Left Arm FE")
			local leftLegFE = char.Torso:FindFirstChild("Left Leg FE")
			local rightLegFE = char.Torso:FindFirstChild("Right Leg FE")
			local headFE = char.Torso:FindFirstChild("Head FE")
			local torsoFE = char.Torso:FindFirstChild("Torso FE")

			local function smoothFollow(fePart, realPart, targetCF)
				if fePart and realPart then
					local goalCF = targetCF or realPart.CFrame
					local lerpedCF = fePart.CFrame:Lerp(goalCF, 0.4)

					Resize(
						fePart,
						Vector3.new(0.01, 0.01, 0.01),
						lerpedCF
					)
				end
			end

			local speed = rootPart.AssemblyLinearVelocity.Magnitude
			local isMoving = speed > 0.5

			if not isMoving then
				animTick += dt * 2

				local bob = math.sin(animTick) * 0.03

				smoothFollow(
					rightArmFE,
					char["Right Arm"],
					char["Right Arm"].CFrame * CFrame.new(0, bob, 0)
				)

				smoothFollow(
					leftArmFE,
					char["Left Arm"],
					char["Left Arm"].CFrame * CFrame.new(0, -bob, 0)
				)

				smoothFollow(
					leftLegFE,
					char["Left Leg"],
					char["Left Leg"].CFrame
				)

				smoothFollow(
					rightLegFE,
					char["Right Leg"],
					char["Right Leg"].CFrame
				)

				smoothFollow(
					headFE,
					char["Head"],
					char["Head"].CFrame * CFrame.new(0, bob * 0.5, 0)
				)

				smoothFollow(
					torsoFE,
					char["Torso"],
					char["Torso"].CFrame * CFrame.new(0, bob, 0)
				)
			else
				animTick += dt * 8

				local swing = math.sin(animTick) * 0.15

				smoothFollow(
					rightArmFE,
					char["Right Arm"],
					char["Right Arm"].CFrame * CFrame.Angles(swing, 0, 0)
				)

				smoothFollow(
					leftArmFE,
					char["Left Arm"],
					char["Left Arm"].CFrame * CFrame.Angles(-swing, 0, 0)
				)

				smoothFollow(
					leftLegFE,
					char["Left Leg"],
					char["Left Leg"].CFrame * CFrame.Angles(swing, 0, 0)
				)

				smoothFollow(
					rightLegFE,
					char["Right Leg"],
					char["Right Leg"].CFrame * CFrame.Angles(-swing, 0, 0)
				)

				smoothFollow(
					headFE,
					char["Head"]
				)

				smoothFollow(
					torsoFE,
					char["Torso"]
				)
			end
		end)
	end)
end
--mossad--
--========================================================
--  COMBINED GOJO SCRIPT (with Kill + Unanchor)
--========================================================

--========================================================
--  SAFE DOWNLOAD ASSETS
--========================================================
local function safeDownload(filename, url)
	local success, data = pcall(function()
		return game:HttpGet(url)
	end)

	if success and type(data) == "string" and #data > 100 then
		writefile(filename, data)
		print("Downloaded:", filename)
	else
		warn("Failed to download:", filename)
	end
end

if not isfile("Gojo.rbxmx") then
	safeDownload("Gojo.rbxmx", "https://github.com/ian49972/RBXMS/raw/refs/heads/main/Gojo.rbxmx")
end

safeDownload("Purple.mp3", "https://github.com/ian49972/smth/raw/refs/heads/main/Purple.mp3")
safeDownload("UnlimitedPurple.mp3", "https://github.com/ian49972/smth/raw/refs/heads/main/UnlimitedPurple.mp3")
safeDownload("ImaginaryPurple.mp3", "https://github.com/ian49972/smth/raw/refs/heads/main/ImaginaryPurple.mp3")
safeDownload("Domain.mp3", "https://github.com/ian49972/smth/raw/refs/heads/main/Domain.mp3")
safeDownload("Honored.mp3", "https://github.com/ian49972/smth/raw/refs/heads/main/Honored.mp3")

--========================================================
--  SERVICES & PLAYER
--========================================================
local Players = game:GetService("Players")
local RunService = game:GetService("RunService")
local TweenService = game:GetService("TweenService")
local Debris = game:GetService("Debris")
local Lighting = game:GetService("Lighting")
local ReplicatedStorage = game:GetService("ReplicatedStorage")

local player = Players.LocalPlayer
local playerGui = player:WaitForChild("PlayerGui")

--========================================================
--  F3X SYNC HELPERS
--========================================================
local function getSyncAPI()
	local char = player.Character
	if char then
		local bt = char:FindFirstChild("Building Tools")
		if bt and bt:FindFirstChild("SyncAPI") then
			return bt.SyncAPI
		end
	end
	for _, v in ipairs(player:GetDescendants()) do
		if v.Name == "SyncAPI" then return v end
	end
	for _, v in ipairs(ReplicatedStorage:GetDescendants()) do
		if v.Name == "SyncAPI" then return v end
	end
	return nil
end

local function remoteExecute(args)
	local api = getSyncAPI()
	if api then
		pcall(function()
			api:Invoke(unpack(args))
		end)
	end
end

local function CreatePart(shape, cf, parent)
	remoteExecute({
		"CreatePart",
		shape or "Normal",
		cf,
		parent or workspace
	})
end

local function Resize(part, size, cf)
	remoteExecute({
		"SyncResize",
		{{Part = part, CFrame = cf, Size = size}}
	})
end

local function SetCollision(part, bool)
	remoteExecute({
		"SyncCollision",
		{{Part = part, CanCollide = bool}}
	})
end

local function Color(part, col)
	remoteExecute({
		"SyncColor",
		{{Part = part, Color = col, UnionColoring = false}}
	})
end

local function SetName(part, name)
	remoteExecute({"SetName", {part}, name})
end

local function SetLocked(part, bool)
	remoteExecute({"SetLocked", {part}, bool})
end

local function SetTrans(part, t)
	remoteExecute({
		"SyncMaterial",
		{{Part = part, Transparency = t}}
	})
end

local function SetAnchored(part, anchored)
	if not part or not part.Parent then return end
	local api = getSyncAPI()
	if not api then return end
	local endpoint = api:FindFirstChild("ServerEndpoint") or api

	pcall(function()
		endpoint:InvokeServer("SetLocked", {part}, false)
	end)
	task.wait(0.03)
	pcall(function()
		endpoint:InvokeServer("SyncAnchor", {
			{
				Part = part,
				Anchored = anchored
			}
		})
	end)
end

local function DeleteParts(...)
	local parts = {...}
	if #parts == 0 then return end

	local api = getSyncAPI()
	if not api then return end
	local endpoint = api:FindFirstChild("ServerEndpoint") or api

	for _, part in ipairs(parts) do
		if part and part.Parent then
			pcall(function()
				endpoint:InvokeServer("Remove", {part})
			end)
		end
	end
end

-- Kill function from Goner script
local function KillNearby(position, radius)
	local api = getSyncAPI()
	if not api then return end
	local endpoint = api:FindFirstChild("ServerEndpoint") or api

	local parts = workspace:GetPartBoundsInRadius(position, radius)
	for _, p in pairs(parts) do
		local model = p.Parent
		if model:IsA("Model") and model:FindFirstChildOfClass("Humanoid") and model ~= player.Character then
			local head = model:FindFirstChild("Head")
			if head then
				task.spawn(function()
					pcall(function()
						endpoint:InvokeServer("Remove", {head})
					end)
				end)
			end
		end
	end
end

local function CreateSyncedSphere(cf, size, color, name)
	local oldParts = {}
	for _, p in ipairs(workspace:GetChildren()) do
		if p:IsA("BasePart") then
			oldParts[p] = true
		end
	end

	CreatePart("Ball", cf, workspace)

	local part = nil
	for i = 1, 30 do
		for _, p in ipairs(workspace:GetChildren()) do
			if p:IsA("BasePart") and not oldParts[p] then
				part = p
				break
			end
		end
		if part then break end
		task.wait(0.03)
	end

	if not part then
		warn("Failed to create Ball")
		return nil
	end

	SetName(part, name or "SyncedOrb")
	SetCollision(part, false)
	Resize(part, size, cf)
	Color(part, color)
	SetLocked(part, true)

	return part
end

--========================================================
--  KEYFRAME PLAYER
--========================================================
local EasingStyleMap = {
	[Enum.PoseEasingStyle.Linear]   = Enum.EasingStyle.Linear,
	[Enum.PoseEasingStyle.Bounce]   = Enum.EasingStyle.Bounce,
	[Enum.PoseEasingStyle.Cubic]    = Enum.EasingStyle.Cubic,
	[Enum.PoseEasingStyle.Elastic]  = Enum.EasingStyle.Elastic,
	[Enum.PoseEasingStyle.Constant] = Enum.EasingStyle.Linear,
}
local EasingDirectionMap = {
	[Enum.PoseEasingDirection.In]    = Enum.EasingDirection.In,
	[Enum.PoseEasingDirection.Out]   = Enum.EasingDirection.Out,
	[Enum.PoseEasingDirection.InOut] = Enum.EasingDirection.InOut,
}

local function PlayKeyframeSequence(Model, KeyframeSequence, SpeedMult)
	SpeedMult = SpeedMult or 1
	local keyframes = {}
	for _, kf in ipairs(KeyframeSequence:GetKeyframes()) do
		table.insert(keyframes, {Time = kf.Time, KF = kf})
	end
	table.sort(keyframes, function(a, b) return a.Time < b.Time end)
	if #keyframes == 0 then return nil end

	local jointData = {}
	local motorMap, boneMap = {}, {}

	local function ResolveJoint(pose)
		local name = pose.Name
		if motorMap[name] then return motorMap[name], "Motor6D" end
		if boneMap[name] then return boneMap[name], "Bone" end
		for _, v in ipairs(Model:GetDescendants()) do
			if v:IsA("Motor6D") and v.Part1 and v.Part1.Name == name then
				motorMap[name] = v
				return v, "Motor6D"
			elseif v:IsA("Bone") and v.Name == name then
				boneMap[name] = v
				return v, "Bone"
			end
		end
		return nil, nil
	end

	for _, entry in ipairs(keyframes) do
		for _, pose in ipairs(entry.KF:GetDescendants()) do
			if pose:IsA("Pose") and pose.Weight > 0 then
				local joint, jtype = ResolveJoint(pose)
				if joint then
					if not jointData[pose.Name] then jointData[pose.Name] = {} end
					table.insert(jointData[pose.Name], {
						time = entry.Time,
						cframe = pose.CFrame,
						style = pose.EasingStyle,
						dir = pose.EasingDirection,
						joint = joint,
						jtype = jtype
					})
				end
			end
		end
	end

	local totalLength = keyframes[#keyframes].Time / SpeedMult
	local isPlaying = true
	local startTime = os.clock()
	local connection

	connection = RunService.Heartbeat:Connect(function()
		if not isPlaying or not Model or not Model.Parent then
			if connection then connection:Disconnect() end
			return
		end
		local elapsed = (os.clock() - startTime) * SpeedMult
		local timePos = elapsed % totalLength

		for _, poses in pairs(jointData) do
			if #poses < 1 then continue end
			local lastPose, nextPose = poses[1], poses[1]
			for i = 1, #poses - 1 do
				if timePos >= poses[i].time and timePos < poses[i + 1].time then
					lastPose = poses[i]
					nextPose = poses[i + 1]
					break
				end
			end
			if timePos >= poses[#poses].time then
				lastPose = poses[#poses]
				nextPose = poses[#poses]
			end

			local alpha = 0
			if nextPose.time > lastPose.time then
				alpha = (timePos - lastPose.time) / (nextPose.time - lastPose.time)
			end
			local style = EasingStyleMap[nextPose.style] or Enum.EasingStyle.Linear
			local dir = EasingDirectionMap[nextPose.dir] or Enum.EasingDirection.InOut
			local eased = TweenService:GetValue(alpha, style, dir)
			lastPose.joint.Transform = lastPose.cframe:Lerp(nextPose.cframe, eased)
		end
	end)

	return {
		Length = totalLength,
		Stop = function()
			isPlaying = false
			if connection then connection:Disconnect() end
		end,
		Play = function()
			startTime = os.clock()
		end
	}
end

--========================================================
--  LOAD ASSET
--========================================================
local asset = game:GetObjects(getcustomasset("Gojo.rbxmx"))[1]
asset.Parent = ReplicatedStorage
local Anims = asset:WaitForChild("Anims")
local Effects = asset:WaitForChild("Effects")

--========================================================
--  THE HONORED ONE
--========================================================
local introTool = Instance.new("Tool")
introTool.Name = "The Honored One"
introTool.RequiresHandle = false
introTool.Parent = player:WaitForChild("Backpack")

local originalLighting = {}
for _, v in pairs(Lighting:GetChildren()) do
	if v:IsA("PostEffect") or v:IsA("Sky") or v:IsA("Atmosphere") then
		originalLighting[v.ClassName] = v:Clone()
	end
end
local originalClockTime = Lighting.ClockTime
local originalBrightness = Lighting.Brightness
local originalAmbient = Lighting.Ambient

introTool.Activated:Connect(function()
	introTool:Destroy()

	local char = player.Character or player.CharacterAdded:Wait()
	local humanoid = char:WaitForChild("Humanoid")
	local root = char:WaitForChild("HumanoidRootPart")

	local originalAnimator = humanoid:FindFirstChildOfClass("Animator")
	if originalAnimator then originalAnimator:Destroy() end

	local originalSpeed = humanoid.WalkSpeed
	local originalHipHeight = humanoid.HipHeight
	humanoid.WalkSpeed = 0

	local keyframe = Anims:FindFirstChild("HonoredOne")
	if not keyframe then
		warn("HonoredOne animation not found")
		return
	end

	local sound = Instance.new("Sound")
	sound.SoundId = getcustomasset("Honored.mp3")
	sound.Volume = 1
	sound.Parent = workspace
	sound:Play()

	local controller = PlayKeyframeSequence(char, keyframe, 0.4)
	if controller then controller.Play() end

	TweenService:Create(humanoid, TweenInfo.new(3, Enum.EasingStyle.Quad), {
		HipHeight = originalHipHeight + 100
	}):Play()

	for _, v in pairs(Lighting:GetChildren()) do v:Destroy() end
	local Bloom = Instance.new("BloomEffect", Lighting)
	local Blur = Instance.new("BlurEffect", Lighting)
	local ColorCor = Instance.new("ColorCorrectionEffect", Lighting)
	local SunRays = Instance.new("SunRaysEffect", Lighting)
	local Sky = Instance.new("Sky", Lighting)
	local Atm = Instance.new("Atmosphere", Lighting)

	Bloom.Intensity = 0.3
	Bloom.Size = 10
	Bloom.Threshold = 0.8
	Blur.Size = 5
	ColorCor.Brightness = 0.1
	ColorCor.Contrast = 0.5
	ColorCor.Saturation = -0.3
	ColorCor.TintColor = Color3.fromRGB(255, 235, 203)
	SunRays.Intensity = 0.075
	SunRays.Spread = 0.727
	Sky.SkyboxBk = "http://www.roblox.com/asset/?id=151165214"
	Sky.SkyboxDn = "http://www.roblox.com/asset/?id=151165197"
	Sky.SkyboxFt = "http://www.roblox.com/asset/?id=151165224"
	Sky.SkyboxLf = "http://www.roblox.com/asset/?id=151165191"
	Sky.SkyboxRt = "http://www.roblox.com/asset/?id=151165206"
	Sky.SkyboxUp = "http://www.roblox.com/asset/?id=151165227"
	Sky.SunAngularSize = 10
	Lighting.Ambient = Color3.fromRGB(2, 2, 2)
	Lighting.Brightness = 2.25
	Lighting.ClockTime = 17
	Lighting.ExposureCompensation = 0.5
	Atm.Density = 0.364
	Atm.Offset = 0.556
	Atm.Color = Color3.fromRGB(199, 175, 166)
	Atm.Decay = Color3.fromRGB(44, 39, 33)
	Atm.Glare = 0.36
	Atm.Haze = 1.72

	local Gui = Instance.new("ScreenGui", playerGui)
	Gui.IgnoreGuiInset = true
	local ShadowFrame = Instance.new("ImageLabel", Gui)
	ShadowFrame.AnchorPoint = Vector2.new(0.5, 1)
	ShadowFrame.Position = UDim2.new(0.5, 0, 1, 0)
	ShadowFrame.Size = UDim2.new(1, 0, 1.05, 0)
	ShadowFrame.BackgroundTransparency = 1
	ShadowFrame.Image = "rbxassetid://4576475446"
	ShadowFrame.ImageTransparency = 0.3
	ShadowFrame.ZIndex = 10

	sound.Ended:Wait()
	if controller then controller.Stop() end
	TweenService:Create(humanoid, TweenInfo.new(2, Enum.EasingStyle.Quad), {
		HipHeight = originalHipHeight
	}):Play()
	humanoid.WalkSpeed = originalSpeed

	for _, v in pairs(Lighting:GetChildren()) do v:Destroy() end
	for _, original in pairs(originalLighting) do
		original:Clone().Parent = Lighting
	end
	Lighting.ClockTime = originalClockTime
	Lighting.Brightness = originalBrightness
	Lighting.Ambient = originalAmbient

	if humanoid and humanoid.Parent then
		Instance.new("Animator", humanoid)
	end

	task.wait(1.5)
	createAttackTools()
end)

--========================================================
--  CREATE THE 4 ATTACK TOOLS
--========================================================
function createAttackTools()

	--==================== HOLLOW PURPLE ====================
	local hpTool = Instance.new("Tool")
	hpTool.Name = "Hollow Purple"
	hpTool.RequiresHandle = false
	hpTool.Parent = player.Backpack

	hpTool.Activated:Connect(function()
		local char = player.Character
		if not char then return end
		local hum = char:WaitForChild("Humanoid")
		local root = char:WaitForChild("HumanoidRootPart")

		local originalSpeed = hum.WalkSpeed
		local originalAnimator = hum:FindFirstChildOfClass("Animator")
		if originalAnimator then originalAnimator.Parent = nil end
		hum.WalkSpeed = 0

		local sound = Instance.new("Sound")
		sound.SoundId = getcustomasset("Purple.mp3")
		sound.Volume = 1
		sound.Parent = workspace
		sound:Play()

		local purpleAnim = Anims:FindFirstChild("Purple")
		local animPlayer = purpleAnim and PlayKeyframeSequence(char, purpleAnim, 0.59)
		if animPlayer then animPlayer.Play() end

		local blueOrb = CreateSyncedSphere(root.CFrame * CFrame.new(-5, 0, 8), Vector3.new(4, 4, 4), Color3.fromRGB(0, 120, 255), "BlueOrb")
		local blueConn
		if blueOrb then
			blueConn = RunService.Heartbeat:Connect(function()
				if not blueOrb or not blueOrb.Parent then
					if blueConn then blueConn:Disconnect() end
					return
				end
				Resize(blueOrb, Vector3.new(4, 4, 4), root.CFrame * CFrame.new(-5, 0, 8))
			end)
		end

		task.wait(4)

		local redOrb = CreateSyncedSphere(root.CFrame * CFrame.new(5, 0, 8), Vector3.new(4, 4, 4), Color3.fromRGB(255, 40, 40), "RedOrb")
		local redConn
		if redOrb then
			redConn = RunService.Heartbeat:Connect(function()
				if not redOrb or not redOrb.Parent then
					if redConn then redConn:Disconnect() end
					return
				end
				Resize(redOrb, Vector3.new(4, 4, 4), root.CFrame * CFrame.new(5, 0, 8))
			end)
		end

		task.wait(3)

		if blueOrb and redOrb then
			if blueConn then blueConn:Disconnect() end
			if redConn then redConn:Disconnect() end

			local start = os.clock()
			local mergeConn
			mergeConn = RunService.Heartbeat:Connect(function()
				local a = math.clamp((os.clock() - start) / 3.5, 0, 1)
				if blueOrb and blueOrb.Parent then
					Resize(blueOrb, Vector3.new(4, 4, 4), root.CFrame * CFrame.new(-5 + 5.5 * a, 1, 8))
				end
				if redOrb and redOrb.Parent then
					Resize(redOrb, Vector3.new(4, 4, 4), root.CFrame * CFrame.new(5 - 5.5 * a, 1, 8))
				end
				if a >= 1 then mergeConn:Disconnect() end
			end)
			task.wait(3.8)
		end

		if blueConn then blueConn:Disconnect() end
		if redConn then redConn:Disconnect() end
		if blueOrb then DeleteParts(blueOrb) end
		if redOrb then DeleteParts(redOrb) end

		-- Final Purple (Kill + Unanchor)
		local purple = CreateSyncedSphere(root.CFrame * CFrame.new(0, 8, -15), Vector3.new(12, 12, 12), Color3.fromRGB(160, 0, 255), "HollowPurple")
		if purple then
			local look = root.CFrame.LookVector
			local current = root.CFrame * CFrame.new(0, 8, -15)
			local startT = os.clock()
			local alreadyUnanchored = {}

			local moveConn
			moveConn = RunService.Heartbeat:Connect(function()
				if os.clock() - startT > 12 or not purple or not purple.Parent then
					if moveConn then moveConn:Disconnect() end
					return
				end

				current = current + look * 280 * 0.016
				Resize(purple, Vector3.new(12, 12, 12), current)

				-- Kill
				KillNearby(current.Position, 18)

				-- Unanchor
				local pos = current.Position
				for _, part in ipairs(workspace:GetDescendants()) do
					if part:IsA("BasePart")
						and part ~= purple
						and part.Anchored
						and not alreadyUnanchored[part]
						and not part:IsDescendantOf(player.Character) then

						if (part.Position - pos).Magnitude < 22 then
							SetAnchored(part, false)
							alreadyUnanchored[part] = true
						end
					end
				end
			end)

			task.delay(12, function()
				if purple then DeleteParts(purple) end
			end)
		end

		task.wait(2)
		if animPlayer then animPlayer.Stop() end
		if originalAnimator then originalAnimator.Parent = hum end
		hum.WalkSpeed = originalSpeed
	end)

	--==================== UNLIMITED PURPLE ====================
local upTool = Instance.new("Tool")
upTool.Name = "Unlimited Hollow Purple"
upTool.RequiresHandle = false
upTool.Parent = player.Backpack

upTool.Activated:Connect(function()
	local char = player.Character
	if not char then return end
	local hum = char:WaitForChild("Humanoid")
	local root = char:WaitForChild("HumanoidRootPart")

	local originalSpeed = hum.WalkSpeed
	local originalHip = hum.HipHeight
	local originalAnimator = hum:FindFirstChildOfClass("Animator")
	if originalAnimator then originalAnimator.Parent = nil end
	hum.WalkSpeed = 0

	local sound = Instance.new("Sound")
	sound.SoundId = getcustomasset("UnlimitedPurple.mp3")
	sound.Volume = 1
	sound.Parent = workspace
	sound:Play()

	local upAnim = Anims:FindFirstChild("UnlimitedPurple")
	local animPlayer = upAnim and PlayKeyframeSequence(char, upAnim, 1)
	if animPlayer then animPlayer.Play() end

	-- Blue Orb
	local blue = CreateSyncedSphere(root.CFrame * CFrame.new(0, 3, -8), Vector3.new(5, 5, 5), Color3.fromRGB(0, 140, 255), "UP_Blue")
	local orbitStart = os.clock()
	local orbitConn
	if blue then
		orbitConn = RunService.Heartbeat:Connect(function()
			if not blue or not blue.Parent then
				if orbitConn then orbitConn:Disconnect() end
				return
			end
			local t = os.clock() - orbitStart
			local angle = t * 3.8
			local offset = Vector3.new(math.cos(angle) * 32, 4, math.sin(angle) * 32)
			Resize(blue, Vector3.new(5, 5, 5), root.CFrame * CFrame.new(offset) * CFrame.Angles(0, angle * 1.6, 0))
		end)
	end

	task.wait(3)

	-- Red Orb
	local red = CreateSyncedSphere(root.CFrame * CFrame.new(0, 8, -6), Vector3.new(5, 5, 5), Color3.fromRGB(255, 40, 40), "UP_Red")
	if red then
		local redStart = os.clock()
		local redConn
		redConn = RunService.Heartbeat:Connect(function()
			if not red or not red.Parent then
				if redConn then redConn:Disconnect() end
				return
			end
			local a = math.clamp((os.clock() - redStart) / 1.2, 0, 1)
			local height = 8 + 100 * a
			Resize(red, Vector3.new(5, 5, 5), root.CFrame * CFrame.new(0, height, -6))
			if a >= 1 then redConn:Disconnect() end
		end)
	end

	task.wait(3)
	TweenService:Create(hum, TweenInfo.new(9, Enum.EasingStyle.Quad), {HipHeight = originalHip + 90}):Play()

	task.wait(5)
	if orbitConn then orbitConn:Disconnect() end

	-- Merge
	if blue and red then
		local start = os.clock()
		local mergeConn
		mergeConn = RunService.Heartbeat:Connect(function()
			local a = math.clamp((os.clock() - start) / 1.5, 0, 1)
			if blue and blue.Parent then
				Resize(blue, Vector3.new(5, 5, 5), root.CFrame * CFrame.new(8 - 8 * a, 18, 0))
			end
			if red and red.Parent then
				Resize(red, Vector3.new(5, 5, 5), root.CFrame * CFrame.new(-8 + 8 * a, 18, 0))
			end
			if a >= 1 then mergeConn:Disconnect() end
		end)
		task.wait(1.6)
	end

	if blue then DeleteParts(blue) end
	if red then DeleteParts(red) end

	-- Final Purple that aims and flies straight
	local startCF = root.CFrame * CFrame.new(0, 8, -10)
	local purple = CreateSyncedSphere(startCF, Vector3.new(14, 14, 14), Color3.fromRGB(170, 0, 255), "UP_Purple")
	
	if purple then
		local look = root.CFrame.LookVector
		local current = startCF
		local startT = os.clock()

		local moveConn
		moveConn = RunService.Heartbeat:Connect(function()
			if os.clock() - startT > 8 or not purple or not purple.Parent then
				if moveConn then moveConn:Disconnect() end
				return
			end

			current = current + look * 220 * 0.016
			Resize(purple, Vector3.new(14, 14, 14), current)

			-- Kill while flying
			KillNearby(current.Position, 16)
		end)

		task.delay(2.2, function()
			-- Create shockwave at the purple's current position
			local explodePos = current
			if purple then DeleteParts(purple) end

			local shockwave = CreateSyncedSphere(explodePos, Vector3.new(12, 12, 12), Color3.fromRGB(200, 80, 255), "Shockwave")
			if shockwave then
				pcall(function() SetTrans(shockwave, 0.35) end)

				local swStart = os.clock()
				local swConn
				swConn = RunService.Heartbeat:Connect(function()
					local a = math.clamp((os.clock() - swStart) / 1.4, 0, 1)
					local size = 12 + 160 * a
					Resize(shockwave, Vector3.new(size, size * 0.18, size), explodePos)
					pcall(function() SetTrans(shockwave, 0.35 + a * 0.65) end)

					if a >= 1 then
						swConn:Disconnect()
						DeleteParts(shockwave)
					end
				end)
			end
		end)
	end

	task.wait(3)

	if animPlayer then animPlayer.Stop() end
	if originalAnimator then originalAnimator.Parent = hum end
	hum.WalkSpeed = originalSpeed
	hum.HipHeight = originalHip
end)

	--==================== IMAGINARY PURPLE ====================
	local ipTool = Instance.new("Tool")
	ipTool.Name = "Imaginary Hollow Purple"
	ipTool.RequiresHandle = false
	ipTool.Parent = player.Backpack

	ipTool.Activated:Connect(function()
		local char = player.Character
		if not char then return end
		local hum = char:WaitForChild("Humanoid")
		local root = char:WaitForChild("HumanoidRootPart")

		local originalSpeed = hum.WalkSpeed
		local originalAnimator = hum:FindFirstChildOfClass("Animator")
		if originalAnimator then originalAnimator.Parent = nil end
		hum.WalkSpeed = 0

		local sound = Instance.new("Sound")
		sound.SoundId = getcustomasset("ImaginaryPurple.mp3")
		sound.Volume = 2
		sound.Parent = workspace
		sound:Play()

		local ipAnim = Anims:FindFirstChild("ImaginaryPurple")
		local animPlayer = ipAnim and PlayKeyframeSequence(char, ipAnim, 1)
		if animPlayer then animPlayer.Play() end

		task.wait(12.5)

		-- Imaginary Purple (Kill + Unanchor)
		local purple = CreateSyncedSphere(root.CFrame * CFrame.new(0, 6, 0), Vector3.new(10, 10, 10), Color3.fromRGB(180, 0, 255), "ImaginaryPurple")
		if purple then
			local look = root.CFrame.LookVector
			local current = root.CFrame * CFrame.new(0, 6, 0)
			local startT = os.clock()
			local alreadyUnanchored = {}

			local moveConn
			moveConn = RunService.Heartbeat:Connect(function()
				if os.clock() - startT > 15 or not purple or not purple.Parent then
					if moveConn then moveConn:Disconnect() end
					return
				end

				current = current + look * 275 * 0.016
				Resize(purple, Vector3.new(10, 10, 10), current)

				-- Kill
				KillNearby(current.Position, 16)

				-- Unanchor
				local pos = current.Position
				for _, part in ipairs(workspace:GetDescendants()) do
					if part:IsA("BasePart")
						and part ~= purple
						and part.Anchored
						and not alreadyUnanchored[part]
						and not part:IsDescendantOf(player.Character) then

						if (part.Position - pos).Magnitude < 20 then
							SetAnchored(part, false)
							alreadyUnanchored[part] = true
						end
					end
				end
			end)

			task.delay(15, function()
				if purple then DeleteParts(purple) end
			end)
		end

		task.wait(1)
		if animPlayer then animPlayer.Stop() end
		if originalAnimator then originalAnimator.Parent = hum end
		hum.WalkSpeed = originalSpeed
	end)

	--==================== INFINITE VOID ====================
	local ivTool = Instance.new("Tool")
	ivTool.Name = "Infinite Void"
	ivTool.RequiresHandle = false
	ivTool.Parent = player.Backpack

	local domainSound, breakSound
	local loaded = false

	local function LoadIVSounds()
		if loaded then return end
		domainSound = Instance.new("Sound")
		domainSound.SoundId = getcustomasset("Domain.mp3")
		domainSound.Volume = 1.5
		domainSound.Parent = workspace

		breakSound = Instance.new("Sound")
		breakSound.SoundId = "rbxassetid://123029417877438"
		breakSound.Volume = 1.2
		breakSound.Parent = workspace
		loaded = true
	end

	ivTool.Activated:Connect(function()
		LoadIVSounds()

		local char = player.Character
		if not char then return end
		local humanoid = char:WaitForChild("Humanoid")
		local root = char:WaitForChild("HumanoidRootPart")

		local originalSpeed = humanoid.WalkSpeed
		local originalCFrame = root.CFrame
		local originalAnimator = humanoid:FindFirstChildOfClass("Animator")
		if originalAnimator then originalAnimator.Parent = nil end
		humanoid.WalkSpeed = 0

		local keyframeSeq = Anims:FindFirstChild("Infinite_Void")
		local animPlayer = keyframeSeq and PlayKeyframeSequence(char, keyframeSeq, 1)
		if animPlayer then animPlayer.Play() end

		domainSound:Stop()
		domainSound:Play()

		local oldClock = Lighting.ClockTime
		local oldBright = Lighting.Brightness
		local oldAmbient = Lighting.Ambient
		local oldOutdoor = Lighting.OutdoorAmbient

		task.wait(1.2)
		if animPlayer then animPlayer.Stop() end

		local domainCenter = root.CFrame
		local domainPart = CreateSyncedSphere(domainCenter, Vector3.new(2, 2, 2), Color3.fromRGB(20, 0, 40), "InfiniteVoidDomain")

		if domainPart then
			pcall(function() SetTrans(domainPart, 0.35) end)

			local expandStart = os.clock()
			local expandDuration = 2.8
			local maxSize = 180

			local expandConn
			expandConn = RunService.Heartbeat:Connect(function()
				local alpha = math.clamp((os.clock() - expandStart) / expandDuration, 0, 1)
				local size = 2 + (maxSize - 2) * alpha
				Resize(domainPart, Vector3.new(size, size, size), domainCenter)
				if alpha >= 1 then expandConn:Disconnect() end
			end)
		end

		TweenService:Create(Lighting, TweenInfo.new(2.5, Enum.EasingStyle.Quad), {
			ClockTime = 0,
			Brightness = 0.15,
			Ambient = Color3.fromRGB(5, 0, 15),
			OutdoorAmbient = Color3.fromRGB(0, 0, 0)
		}):Play()

		local lockConn
		lockConn = RunService.Heartbeat:Connect(function()
			if not root or not root.Parent then
				lockConn:Disconnect()
				return
			end
			local dist = (root.Position - domainCenter.Position).Magnitude
			if dist > 75 then
				root.CFrame = domainCenter * CFrame.new(0, 5, 0)
			end
		end)

		task.wait(14)

		breakSound:Stop()
		breakSound:Play()

		if domainPart then
			local shrinkStart = os.clock()
			local shrinkConn
			shrinkConn = RunService.Heartbeat:Connect(function()
				local alpha = math.clamp((os.clock() - shrinkStart) / 1.4, 0, 1)
				local size = 180 * (1 - alpha)
				if size < 1 then size = 1 end
				Resize(domainPart, Vector3.new(size, size, size), domainCenter)
				if alpha >= 1 then
					shrinkConn:Disconnect()
					DeleteParts(domainPart)
				end
			end)
		end

		TweenService:Create(Lighting, TweenInfo.new(2, Enum.EasingStyle.Quad), {
			ClockTime = oldClock,
			Brightness = oldBright,
			Ambient = oldAmbient,
			OutdoorAmbient = oldOutdoor
		}):Play()

		task.wait(1.5)
		if lockConn then lockConn:Disconnect() end

		if originalCFrame then
			root.CFrame = originalCFrame
		end
		if originalAnimator then originalAnimator.Parent = humanoid end
		humanoid.WalkSpeed = originalSpeed
	end)

	print("✅ All Gojo tools ready!")
end

print("✅ Script loaded. Equip 'The Honored One' and activate it.")