-- ============================================
-- TELEKINESIS SCRIPT - MEJORADO Y CORREGIDO
-- ============================================
-- Fecha: 2026-03-09

-- VARIABLES GLOBALES
local player = game.Players.LocalPlayer
local mouse = player:GetMouse()
local camera = workspace.CurrentCamera
local humanoidRootPart = player.Character and player.Character:FindFirstChild("HumanoidRootPart")

local holding, target, holdDistance, anchoredWhileHolding = false, nil, 10, false

local run, UIS = game:GetService("RunService"), game:GetService("UserInputService")

-- Fuerzas físicas
local vel = Instance.new("BodyVelocity")
vel.MaxForce = Vector3.new(1, 1, 1) * 1e5
vel.P = 12500

local gyro = Instance.new("BodyGyro")
gyro.MaxTorque = Vector3.new(1, 1, 1) * 1e6
gyro.P = 3000

local originalRotation = nil
local originalPhysicalProperties = {} -- Guardar propiedades originales

-- Sistema de Rotación
local rotationMode = false
local lastMouseX = 0
local lastMouseY = 0
local rotationSensitivity = 0.8 -- Reducido para más control
local fixedCameraPosition = nil
local fixedCameraRotation = nil
local fixedObjectPosition = nil
local positionLock = Instance.new("BodyVelocity") -- Para mantener posición fija
positionLock.MaxForce = Vector3.new(1, 1, 1) * 1e5
positionLock.P = 12500
positionLock.Velocity = Vector3.new(0, 0, 0)

-- Variables para personaje invisible
local originalCharacterVisibility = {}
local characterHidden = false

-- Highlights en lugar de SelectionBox
local highlightHolding = Instance.new("Highlight")
highlightHolding.OutlineColor = Color3.fromRGB(0, 255, 0) -- Verde
highlightHolding.FillColor = Color3.fromRGB(0, 255, 0)
highlightHolding.FillTransparency = 0.5
highlightHolding.OutlineTransparency = 0
highlightHolding.DepthMode = Enum.HighlightDepthMode.Occluded
highlightHolding.Parent = game:GetService("CoreGui")

local highlightLooking = Instance.new("Highlight")
highlightLooking.OutlineColor = Color3.fromRGB(0, 170, 255) -- Azul
highlightLooking.FillColor = Color3.fromRGB(0, 170, 255)
highlightLooking.FillTransparency = 0.6
highlightLooking.OutlineTransparency = 0
highlightLooking.DepthMode = Enum.HighlightDepthMode.Occluded
highlightLooking.Parent = game:GetService("CoreGui")

-- Imán
local imanActivo, radioIman, fuerzaIman = false, 30, 200
local objetosIman, gravityBackup = {}, {}
local fuerzaImanMin, fuerzaImanMax = 50, 2000

-- Lanzamiento normal
local fuerzaLanzamiento, fuerzaLanzamientoMin, fuerzaLanzamientoMax = 1000, 100, 4000

-- Círculo visual avanzado
local usingDrawing = Drawing and Drawing.new and typeof(Drawing.new)=="function"
local imancircle, circleGui, circleImg
local circleColor = Color3.fromRGB(0,170,255)
local surfacePos, surfaceNormal = Vector3.zero, Vector3.new(0,1,0)
local actualRadio = radioIman

if usingDrawing then
	imancircle = Drawing.new("Circle")
	imancircle.Visible, imancircle.Transparency, imancircle.Color, imancircle.Thickness, imancircle.Filled = false, 1, circleColor, 2, false
else
	circleGui = Instance.new("BillboardGui")
	circleGui.Name, circleGui.Size, circleGui.SizeOffset, circleGui.AlwaysOnTop = "ImanCircleGui", UDim2.new(2,0,2,0), Vector2.new(0,0), true
	circleGui.Parent = workspace
	circleImg = Instance.new("ImageLabel")
	circleImg.BackgroundTransparency, circleImg.Image, circleImg.ImageColor3 = 1, "rbxassetid://13523341990", circleColor
	circleImg.AnchorPoint, circleImg.Position, circleImg.Size = Vector2.new(0.5,0.5), UDim2.fromScale(0.5,0.5), UDim2.fromScale(1,1)
	circleImg.Parent, circleGui.Enabled = circleGui, false
end

-- GUI fuerza (se puede ocultar) - CON ESQUINAS REDONDEADAS
local fuerzaGui = Instance.new("ScreenGui")
fuerzaGui.Name = "FuerzaImanGui"
fuerzaGui.Parent = game:GetService("CoreGui")
fuerzaGui.Enabled = true

local fuerzaLabel = Instance.new("TextLabel")
fuerzaLabel.Name = "FuerzaImanLabel"
fuerzaLabel.BackgroundTransparency = 0.3
fuerzaLabel.BackgroundColor3 = Color3.fromRGB(30, 30, 30)
fuerzaLabel.Size = UDim2.new(0, 220, 0, 60)
fuerzaLabel.Position = UDim2.new(1, -230, 1, -70)
fuerzaLabel.TextScaled = true
fuerzaLabel.Font = Enum.Font.GothamBold
fuerzaLabel.TextColor3 = Color3.new(1,1,1)
fuerzaLabel.TextStrokeTransparency = 0.5
fuerzaLabel.Visible = true

-- Crear esquinas redondeadas
local corner = Instance.new("UICorner")
corner.CornerRadius = UDim.new(0, 12)
corner.Parent = fuerzaLabel

fuerzaLabel.Parent = fuerzaGui

-- GUI para modo rotación - MISMA POSICIÓN QUE LAS OTRAS
local rotationGui = Instance.new("ScreenGui")
rotationGui.Name = "RotationModeGui"
rotationGui.Parent = game:GetService("CoreGui")
rotationGui.Enabled = true

local rotationLabel = Instance.new("TextLabel")
rotationLabel.Name = "RotationLabel"
rotationLabel.BackgroundTransparency = 0.3
rotationLabel.BackgroundColor3 = Color3.fromRGB(30, 30, 30)
rotationLabel.Size = UDim2.new(0, 220, 0, 60)
rotationLabel.Position = UDim2.new(1, -230, 1, -70) -- MISMA POSICIÓN QUE FUERZA
rotationLabel.TextScaled = true
rotationLabel.Font = Enum.Font.GothamBold
rotationLabel.TextColor3 = Color3.new(1,1,1)
rotationLabel.TextStrokeTransparency = 0.5
rotationLabel.Visible = false
rotationLabel.Text = "🔄 ROTACIÓN\n▲▼◄►"

local rotationCorner = Instance.new("UICorner")
rotationCorner.CornerRadius = UDim.new(0, 12)
rotationCorner.Parent = rotationLabel

rotationLabel.Parent = rotationGui

local holdQ, holdE = false, false
local guiVisible = true
local scriptActive = true
local lastNotificationTime = 0
local notificationCooldown = 0.5 -- Cooldown de 0.5 segundos entre notificaciones

-- ============================================
-- FUNCIONES AUXILIARES
-- ============================================

local function esParteDePersonaje(obj)
	for _, plr in ipairs(game.Players:GetPlayers()) do
		if plr.Character and obj:IsDescendantOf(plr.Character) then return true end
	end
	return false
end

local function tieneSoldaduraNoAnclada(obj)
	for _, c in ipairs(obj:GetConnectedParts()) do
		if c ~= obj and not c.Anchored then return true end
	end
	return false
end

local function restaurarGravedad()
	for obj, oldGravity in pairs(gravityBackup) do
		if obj and obj:IsDescendantOf(workspace) then 
			obj.CustomPhysicalProperties = oldGravity
			gravityBackup[obj] = nil
		end
	end
	gravityBackup = {}
end

local function restaurarPropiedadesOriginales()
	for obj, props in pairs(originalPhysicalProperties) do
		if obj and obj:IsDescendantOf(workspace) then 
			obj.CustomPhysicalProperties = props
		end
	end
	originalPhysicalProperties = {}
end

local function lerpVec3(a, b, t) return a + (b - a) * t end

-- Función para enviar notificación con cooldown
local function enviarNotificacion(title, text, duration)
	if not scriptActive then return end
	local currentTime = tick()
	if currentTime - lastNotificationTime >= notificationCooldown then
		pcall(function()
			game.StarterGui:SetCore("SendNotification", {
				Title = title,
				Text = text,
				Duration = duration or 2
			})
		end)
		lastNotificationTime = currentTime
	end
end

-- Función para ocultar/mostrar el personaje
local function ocultarPersonaje()
	if not player.Character then return end
	characterHidden = true
	
	-- Ocultar todas las partes del personaje
	for _, part in ipairs(player.Character:GetDescendants()) do
		if part:IsA("BasePart") then
			originalCharacterVisibility[part] = part.Transparency
			part.Transparency = 1
		end
	end
	
	-- Ocultar accesorios
	local humanoid = player.Character:FindFirstChild("Humanoid")
	if humanoid then
		for _, accessory in ipairs(player.Character:FindFirstChild("Humanoid"):GetChildren()) do
			if accessory:IsA("Accessory") then
				local handle = accessory:FindFirstChild("Handle")
				if handle then
					originalCharacterVisibility[handle] = handle.Transparency
					handle.Transparency = 1
				end
			end
		end
	end
end

-- Función para mostrar el personaje
local function mostrarPersonaje()
	if not characterHidden then return end
	characterHidden = false
	
	for part, transparency in pairs(originalCharacterVisibility) do
		if part and part:IsDescendantOf(workspace) then
			part.Transparency = transparency
		end
	end
	originalCharacterVisibility = {}
end

-- Función para bloquear movimiento del personaje
local function bloquearMovimientoPersonaje()
	if humanoidRootPart then
		humanoidRootPart.Velocity = Vector3.new(0, 0, 0)
	end
end

-- Función para activar/desactivar modo rotación
local function alternarModoRotacion()
	if not holding or not target then
		enviarNotificacion(
			"❌ No disponible",
			"Debes agarrar un objeto primero",
			2
		)
		return
	end
	
	rotationMode = not rotationMode
	
	if rotationMode then
		-- Activar modo rotación
		-- Guardar posición y rotación de la cámara
		fixedCameraPosition = camera.CFrame.Position
		fixedCameraRotation = camera.CFrame - camera.CFrame.Position
		
		-- Guardar posición actual del objeto
		fixedObjectPosition = target.Position
		
		-- Detener movimiento del objeto y mantenerlo flotando
		vel.Parent = nil
		positionLock.Velocity = Vector3.new(0, 0, 0)
		positionLock.Parent = target
		
		-- Resetear variables de mouse
		lastMouseX = mouse.X
		lastMouseY = mouse.Y
		
		-- Ocultar personaje
		ocultarPersonaje()
		
		-- Mostrar solo label de rotación, ocultar el de fuerza
		rotationLabel.Visible = true
		fuerzaLabel.Visible = false
		
		enviarNotificacion(
			"🔄 MODO ROTACIÓN ACTIVADO",
			"Mueve el ratón para rotar | Presiona C para salir",
			2
		)
	else
		-- Desactivar modo rotación
		fixedCameraPosition = nil
		fixedCameraRotation = nil
		fixedObjectPosition = nil
		rotationLabel.Visible = false
		
		-- Remover lock de posición y reactivar movimiento
		positionLock.Parent = nil
		vel.Parent = target
		
		-- Mostrar personaje
		mostrarPersonaje()
		
		-- Restaurar visualización según estado
		if guiVisible and scriptActive then
			if imanActivo then
				fuerzaLabel.Text = "🧲 Fuerza: "..math.floor(fuerzaIman).."\n📏 Radio: "..math.floor(radioIman)
			else
				fuerzaLabel.Text = "🎯 Lanzamiento: "..math.floor(fuerzaLanzamiento)
			end
			fuerzaLabel.Visible = true
		end
		
		enviarNotificacion(
			"🔄 MODO ROTACIÓN DESACTIVADO",
			"Cámara y movimiento restaurados",
			2
		)
	end
end

-- ============================================
-- RENDER STEPPED - ACTUALIZACIONES VISUALES
-- ============================================

run.RenderStepped:Connect(function()
	if not scriptActive then return end
	
	-- Actualizar highlights
	if imanActivo and not holding then
		highlightHolding.Adornee = nil
		highlightLooking.Adornee = nil
	else
		if holding and target then
			highlightHolding.OutlineColor = Color3.fromRGB(0, 255, 0)
			highlightHolding.FillColor = Color3.fromRGB(0, 255, 0)
			highlightHolding.Adornee = target
			highlightLooking.Adornee = nil
		elseif not holding and mouse.Target then
			local parte = mouse.Target
			if parte:IsA("BasePart") and not parte.Anchored and not esParteDePersonaje(parte) then
				highlightLooking.OutlineColor = Color3.fromRGB(0, 170, 255)
				highlightLooking.FillColor = Color3.fromRGB(0, 170, 255)
				highlightLooking.Adornee = parte
				highlightHolding.Adornee = nil
			else
				highlightHolding.Adornee = nil
				highlightLooking.Adornee = nil
			end
		else
			highlightHolding.Adornee = nil
			highlightLooking.Adornee = nil
		end
	end

	if imanActivo and not rotationMode then
		local ray = camera:ScreenPointToRay(mouse.X, mouse.Y)
		local hit, pos, norm = workspace:FindPartOnRayWithIgnoreList(Ray.new(ray.Origin, ray.Direction * 1000), {player.Character})
		if hit then
			surfacePos, surfaceNormal = lerpVec3(surfacePos,pos,0.35), lerpVec3(surfaceNormal,norm,0.35)
		else
			local defPos = ray.Origin + ray.Direction * 15
			surfacePos, surfaceNormal = lerpVec3(surfacePos,defPos,0.15), lerpVec3(surfaceNormal,Vector3.new(0,1,0),0.15)
		end
		actualRadio = actualRadio + (radioIman - actualRadio) * 0.25

		-- Cambiar color del círculo según fuerzaIman
		local fuerzaPercent = (fuerzaIman-fuerzaImanMin)/(fuerzaImanMax-fuerzaImanMin)
		local colorEscala = Color3.fromHSV(0.58 + fuerzaPercent*0.3, 1, 1)
		if usingDrawing then
			imancircle.Visible = true
			imancircle.Position = Vector2.new(camera:WorldToViewportPoint(surfacePos).X, camera:WorldToViewportPoint(surfacePos).Y)
			imancircle.Radius = actualRadio
			imancircle.Color = colorEscala
		else
			circleGui.Enabled = true
			circleGui.Size = UDim2.new(0,actualRadio*2,0,actualRadio*2)
			circleGui.CFrame = CFrame.new(surfacePos, surfacePos + camera.CFrame.LookVector)
				* CFrame.fromMatrix(Vector3.zero,
					surfaceNormal:Cross(Vector3.new(0,1,0)).Magnitude>0.01 and surfaceNormal:Cross(Vector3.new(0,1,0)).Unit or Vector3.new(1,0,0), 
					surfaceNormal,
					-surfaceNormal:Cross(Vector3.new(1,0,0)).Unit)
			circleGui.Position = surfacePos
			circleImg.ImageColor3 = colorEscala
		end
		
		if guiVisible then
			fuerzaLabel.Visible = true
			fuerzaLabel.Text = "🧲 Fuerza: "..math.floor(fuerzaIman).."\n📏 Radio: "..math.floor(radioIman)
			fuerzaLabel.TextColor3 = colorEscala
		else
			fuerzaLabel.Visible = false
		end
	elseif not rotationMode then
		-- Modo normal: fuerza de lanzamiento
		local fuerzaPercent = (fuerzaLanzamiento-fuerzaLanzamientoMin)/(fuerzaLanzamientoMax-fuerzaLanzamientoMin)
		local colorEscala = Color3.fromHSV(0.58 + fuerzaPercent*0.3, 1, 1)
		if usingDrawing then imancircle.Visible = false
		elseif circleGui then circleGui.Enabled = false end
		
		if guiVisible then
			fuerzaLabel.Visible = true
			fuerzaLabel.Text = "🎯 Lanzamiento: "..math.floor(fuerzaLanzamiento)
			fuerzaLabel.TextColor3 = colorEscala
		else
			fuerzaLabel.Visible = false
		end
	else
		-- En modo rotación, no mostrar GUI de fuerza
		if usingDrawing then imancircle.Visible = false
		elseif circleGui then circleGui.Enabled = false end
		fuerzaLabel.Visible = false
	end

	-- MODO ROTACIÓN: Mantener cámara fija, objeto flotando y solo rotar
	if rotationMode and holding and target then
		-- Bloquear movimiento del personaje
		bloquearMovimientoPersonaje()
		
		-- Mantener cámara en posición fija
		if fixedCameraPosition and fixedCameraRotation then
			camera.CFrame = fixedCameraRotation + fixedCameraPosition
		end
		
		-- Mantener objeto en posición fija (flotando)
		if fixedObjectPosition then
			positionLock.Velocity = Vector3.new(0, 0, 0)
			target.Position = fixedObjectPosition
		end
		
		-- Calcular rotación basada en movimiento del ratón
		local currentMouseX = mouse.X
		local currentMouseY = mouse.Y
		local mouseDeltaX = currentMouseX - lastMouseX
		local mouseDeltaY = currentMouseY - lastMouseY
		lastMouseX = currentMouseX
		lastMouseY = currentMouseY
		
		-- Crear rotaciones basadas en delta del mouse con sensibilidad reducida
		if math.abs(mouseDeltaX) > 0 or math.abs(mouseDeltaY) > 0 then
			local rotationX = CFrame.fromAxisAngle(Vector3.new(0, 1, 0), math.rad(mouseDeltaX * rotationSensitivity))
			local rotationY = CFrame.fromAxisAngle(Vector3.new(1, 0, 0), math.rad(mouseDeltaY * rotationSensitivity))
			
			-- Aplicar rotación al objeto SIN acumulación excesiva
			if originalRotation then
				originalRotation = originalRotation * rotationX * rotationY
				gyro.CFrame = originalRotation + target.Position
			end
		end
	end
end)

-- ============================================
-- HEARTBEAT - FÍSICA Y LÓGICA PRINCIPAL
-- ============================================

run.Heartbeat:Connect(function()
	if not scriptActive then return end
	
	-- Telequinesis normal
	if holding and target then
		if not anchoredWhileHolding and not rotationMode then
			local ray = camera:ScreenPointToRay(mouse.X, mouse.Y)
			local grabPos = ray.Origin + ray.Direction.Unit * holdDistance
			vel.Velocity = (grabPos - target.Position) * 5
			if originalRotation then
				gyro.CFrame = originalRotation + target.Position
			end
		elseif rotationMode then
			-- En modo rotación: mantener posición fija
			vel.Velocity = Vector3.new(0, 0, 0)
		else
			vel.Velocity = Vector3.zero
		end
	end

	-- Bloque imán mejorado: atrae directamente al punto donde se apunta
	if imanActivo and not rotationMode then
		local centro, nuevosAtraidos = surfacePos, {}
		local fuerzaEscalada = fuerzaIman * (radioIman/30)^1.5 -- fuerza aumenta con radio
		local nearby = workspace:GetPartBoundsInBox(CFrame.new(centro), Vector3.new(radioIman*2, radioIman*2, radioIman*2))
		for _, obj in ipairs(nearby) do
			if obj:IsA("BasePart") and not obj.Anchored and not esParteDePersonaje(obj)
				and not tieneSoldaduraNoAnclada(obj) and obj.Transparency < 1 and obj.CanCollide and obj ~= target then
				local distancia = (obj.Position - centro).Magnitude
				if distancia <= radioIman then
					-- Atraer DIRECTAMENTE al punto donde se apunta (surfacePos)
					-- Sin considerar la superficie del objeto en sí
					local dirFinal = (centro - obj.Position)
					
					-- Aplicar la fuerza directamente
					local bv = obj:FindFirstChild("ImanBV") or Instance.new("BodyVelocity")
					bv.Name, bv.MaxForce, bv.P = "ImanBV", Vector3.new(1,1,1)*1e5, 15000
					bv.Velocity = dirFinal.Unit * fuerzaEscalada
					bv.Parent = obj
					
					-- Guardar propiedades originales si no están guardadas
					if not originalPhysicalProperties[obj] then
						originalPhysicalProperties[obj] = obj.CustomPhysicalProperties
					end
					
					-- No guardar en gravityBackup, usar originalPhysicalProperties en su lugar
					if not gravityBackup[obj] then
						gravityBackup[obj] = obj.CustomPhysicalProperties
					end
					
					-- Aplicar propiedades temporales ligeras
					obj.CustomPhysicalProperties = PhysicalProperties.new(0.1, 0.3, 0.5, 1, 1)
					nuevosAtraidos[obj] = true
				end
			end
		end
		for obj in pairs(objetosIman) do
			if not nuevosAtraidos[obj] then
				if obj and obj:FindFirstChild("ImanBV") then obj.ImanBV:Destroy() end
			end
		end
		objetosIman = nuevosAtraidos
	else
		-- Desactivar imán: restaurar propiedades CORRECTAMENTE
		for obj in pairs(objetosIman) do 
			if obj and obj:FindFirstChild("ImanBV") then obj.ImanBV:Destroy() end
		end
		
		-- Restaurar propiedades originales en lugar de gravityBackup
		restaurarPropiedadesOriginales()
		gravityBackup = {}
		objetosIman = {}
	end

	-- Ajuste distancia/radio con teclado - SOLO EN MODO NORMAL
	if not rotationMode then
		if imanActivo then
			-- Si el imán está activo, Q/E ajustan el radio del imán
			if holdQ then radioIman = math.max(5, radioIman - 1.3)
			elseif holdE then radioIman = math.min(200, radioIman + 1.3) end
		else
			-- Modo normal: Q/E ajustan la distancia de agarre
			if holdQ then holdDistance = math.max(2, holdDistance - 0.4)
			elseif holdE then holdDistance = math.min(1000, holdDistance + 0.4) end
		end
	end
end)

-- ============================================
-- FUNCIONES DE ACCIÓN
-- ============================================

function agarrarOSoltar()
	if not scriptActive then return end
	if imanActivo then return end
	if rotationMode then return end
	
	if holding then
		originalRotation = nil
		vel.Parent, gyro.Parent, anchoredWhileHolding, target, holding = nil, nil, false, nil, false
		
		-- Desactivar modo rotación si estaba activo
		if rotationMode then
			rotationMode = false
			fixedCameraPosition = nil
			fixedCameraRotation = nil
			fixedObjectPosition = nil
			rotationLabel.Visible = false
			positionLock.Parent = nil
			mostrarPersonaje()
		end
		
		-- Restaurar propiedades del objeto que se suelta
		if target and originalPhysicalProperties[target] then
			target.CustomPhysicalProperties = originalPhysicalProperties[target]
			originalPhysicalProperties[target] = nil
		end
	else
		local part = mouse.Target
		if part and part:IsA("BasePart") and not esParteDePersonaje(part) then
			-- Si el objeto está anclado, solo lo puedes agarrar si lo anclaste tú antes
			if part.Anchored then
				if not part:GetAttribute("TelekinesisAnchored") then
					-- Si no tiene el atributo, es del mapa: no puedes agarrarlo
					return
				end
				-- Si lo anclaste tú, desanclalo automáticamente al agarrar
				part.Anchored = false
				part:SetAttribute("TelekinesisAnchored", nil)
			end
			target, anchoredWhileHolding = part, false
			originalRotation = part.CFrame - part.Position
			gyro.CFrame = originalRotation + part.Position
			gyro.Parent = part
			vel.Velocity, vel.Parent = Vector3.zero, part
			local ray = camera:ScreenPointToRay(mouse.X, mouse.Y)
			local _, pos = workspace:FindPartOnRayWithIgnoreList(Ray.new(ray.Origin, ray.Direction.Unit * 1000), {player.Character})
			holdDistance = pos and (camera.CFrame.Position - pos).Magnitude or (camera.CFrame.Position - part.Position).Magnitude
			holding = true
		end
	end
end

function lanzar()
	if not scriptActive then return end
	if imanActivo then return end
	if rotationMode then return end
	
	if holding and target then
		if anchoredWhileHolding then target.Anchored, anchoredWhileHolding = false, false end
		vel.Parent, gyro.Parent, holding = nil, nil, false
		originalRotation = nil
		
		-- Restaurar propiedades antes de lanzar
		if originalPhysicalProperties[target] then
			target.CustomPhysicalProperties = originalPhysicalProperties[target]
			originalPhysicalProperties[target] = nil
		end
		
		-- LANZAMIENTO MEJORADO: Desde cámara hacia el puntero del ratón
		local ray = camera:ScreenPointToRay(mouse.X, mouse.Y)
		local launchDirection = ray.Direction.Unit
		
		local impulse = Instance.new("BodyVelocity")
		impulse.Velocity = launchDirection * fuerzaLanzamiento
		impulse.MaxForce, impulse.P, impulse.Parent = Vector3.new(1,1,1)*1e6, 12500, target
		game:GetService("Debris"):AddItem(impulse, 0.5)
		target = nil
	end
end

function alternarAnclado()
	if not scriptActive then return end
	if imanActivo then return end
	if rotationMode then return end
	
	if holding and target then
		anchoredWhileHolding = not anchoredWhileHolding
		target.Anchored = anchoredWhileHolding

		if anchoredWhileHolding then
			-- MARCA con atributo que tú lo anclaste
			target:SetAttribute("TelekinesisAnchored", true)

			vel.Parent = nil
			gyro.Parent = nil
			target.AssemblyLinearVelocity = Vector3.zero
			target.AssemblyAngularVelocity = Vector3.zero

			local humanoidRoot = player.Character and player.Character:FindFirstChild("HumanoidRootPart")
			if humanoidRoot and (humanoidRoot.Position - target.Position).Magnitude < 5 then
				humanoidRoot.Velocity = Vector3.zero
				humanoidRoot.AssemblyLinearVelocity = Vector3.zero
				humanoidRoot.CFrame = humanoidRoot.CFrame + Vector3.new(0, 3, 0)
			end
		else
			-- QUITA el atributo al desanclar
			target:SetAttribute("TelekinesisAnchored", nil)

			vel.Parent = target
			gyro.Parent = target
		end

		enviarNotificacion(
			anchoredWhileHolding and "📌 Anclado" or "📎 Desanclado",
			"Alternar con R",
			2
		)
	end
end

function anclarMasivoIman()
	if not scriptActive then return end
	if not imanActivo then return end
	if holding then
		enviarNotificacion(
			"❌ No disponible",
			"Suelta el objeto para usar anclaje masivo",
			2
		)
		return
	end
	
	-- Anclar todos los objetos que están siendo atraídos
	local count = 0
	for obj in pairs(objetosIman) do
		if obj and obj:IsDescendantOf(workspace) then
			obj.Anchored = true
			obj:SetAttribute("TelekinesisAnchored", true)
			count = count + 1
		end
	end
	
	enviarNotificacion(
		"📌 Anclaje Masivo",
		"Se anclaron " .. count .. " objetos",
		2
	)
end

local function mostrarPanel()
	enviarNotificacion(
		"��️ CONTROLES - TELEKINESIS",
		"🖱️ Click Izquierdo → Agarrar/Soltar\n🔥 F → Lanzar\n🔀 Q/E (Mantener) → Acercar/Alejar\n📌 R → Anclar o Anclaje Masivo\n🧲 T → Activar Modo Imán\n🔄 C → Rotar Objeto\n⬇️ Z → Bajar Fuerza\n⬆️ X → Subir Fuerza\n👁️ Delete → Mostrar/Ocultar GUI y Script\n❓ Ctrl → Este Panel",
		12
	)
end

-- ============================================
-- INPUT CONNECTIONS
-- ============================================

UIS.InputBegan:Connect(function(input, gpe)
	if gpe then return end
	if input.UserInputType == Enum.UserInputType.Keyboard then
		-- En modo rotación, solo funciona C para salir
		if rotationMode then
			if input.KeyCode == Enum.KeyCode.C then
				alternarModoRotacion()
			end
			return
		end
		
		-- Controles normales
		if input.KeyCode == Enum.KeyCode.Q then holdQ = true
		elseif input.KeyCode == Enum.KeyCode.E then holdE = true
		elseif input.KeyCode == Enum.KeyCode.R then
			if imanActivo then
				anclarMasivoIman()
			else
				alternarAnclado()
			end
		elseif input.KeyCode == Enum.KeyCode.F then lanzar()
		elseif input.KeyCode == Enum.KeyCode.C then
			alternarModoRotacion()
		elseif input.KeyCode == Enum.KeyCode.T then
			if not scriptActive then return end
			if holding then
				enviarNotificacion(
					"❌ No disponible",
					"Suelta el objeto para activar el imán",
					2
				)
				return
			end
			imanActivo = not imanActivo
			if not imanActivo then 
				-- Restaurar propiedades cuando se desactiva el imán
				restaurarPropiedadesOriginales()
				gravityBackup = {}
			end
			enviarNotificacion(
				imanActivo and "🧲 Modo Imán ACTIVADO" or "🧲 Modo Imán DESACTIVADO",
				"Atrae solo piezas sueltas en el círculo azul",
				2
			)
		elseif input.KeyCode == Enum.KeyCode.Delete then
			scriptActive = not scriptActive
			guiVisible = scriptActive
			
			-- Ocultar o mostrar todos los elementos
			fuerzaGui.Enabled = scriptActive
			rotationGui.Enabled = scriptActive
			if usingDrawing and imancircle then
				imancircle.Visible = scriptActive and imanActivo
			elseif circleGui then
				circleGui.Enabled = scriptActive and imanActivo
			end
			
			-- Si se oculta, detener acciones en curso
			if not scriptActive then
				holdQ = false
				holdE = false
				if imanActivo then
					for obj in pairs(objetosIman) do
						if obj and obj:FindFirstChild("ImanBV") then obj.ImanBV:Destroy() end
					end
					objetosIman = {}
					restaurarPropiedadesOriginales()
					gravityBackup = {}
				end
			end
			
			enviarNotificacion(
				scriptActive and "👁️ Script Activo" or "🙈 Script Desactivado",
				"",
				1
			)
		elseif input.KeyCode == Enum.KeyCode.LeftControl or input.KeyCode == Enum.KeyCode.RightControl then 
			if scriptActive then
				mostrarPanel()
			end
		elseif input.KeyCode == Enum.KeyCode.Z then
			if not scriptActive then return end
			if imanActivo then
				fuerzaIman = math.max(fuerzaImanMin, fuerzaIman - 25)
				enviarNotificacion(
					"🧲 Fuerza Imán",
					"↓ " .. math.floor(fuerzaIman),
					1
				)
			else
				fuerzaLanzamiento = math.max(fuerzaLanzamientoMin, fuerzaLanzamiento - 100)
				enviarNotificacion(
					"🎯 Fuerza Lanzamiento",
					"↓ " .. math.floor(fuerzaLanzamiento),
					1
				)
			end
		elseif input.KeyCode == Enum.KeyCode.X then
			if not scriptActive then return end
			if imanActivo then
				fuerzaIman = math.min(fuerzaImanMax, fuerzaIman + 25)
				enviarNotificacion(
					"🧲 Fuerza Imán",
					"↑ " .. math.floor(fuerzaIman),
					1
				)
			else
				fuerzaLanzamiento = math.min(fuerzaLanzamientoMax, fuerzaLanzamiento + 100)
				enviarNotificacion(
					"🎯 Fuerza Lanzamiento",
					"↑ " .. math.floor(fuerzaLanzamiento),
					1
				)
			end
		end
	end
end)

UIS.InputEnded:Connect(function(input)
	if rotationMode then return end
	
	if input.UserInputType == Enum.UserInputType.Keyboard then
		if input.KeyCode == Enum.KeyCode.Q then holdQ = false
		elseif input.KeyCode == Enum.KeyCode.E then holdE = false end
	end
end)

-- ============================================
-- MOUSE CONNECTIONS
-- ============================================

mouse.Button1Down:Connect(function()
	if not rotationMode and scriptActive then
		agarrarOSoltar()
	end
end)

-- ============================================
-- FIN DEL SCRIPT
-- ============================================
print("✅ Script de Telekinesis Cargado Correctamente")