-- [[ VOID HORROR ENGINE - MOTION UPDATE ]] --
-- [[ FEATURES: PROCEDURAL SWAY + GHOST TRAILS + STABLE EXECUTION ]] --
local Players = game:GetService("Players")
local PhysicsService = game:GetService("PhysicsService")
local RunService = game:GetService("RunService")

local LocalPlayer = Players.LocalPlayer

local function forcePushable(character)
    if not character then return end
    
    for _, obj in ipairs(character:GetDescendants()) do
        if obj:IsA("BasePart") then
            -- Reset to default colliding behavior
            obj.CollisionGroup = "Default"
            obj.CanCollide = true
            obj.Massless = false
            
            -- Strong physical properties for good push feel
            obj.CustomPhysicalProperties = PhysicalProperties.new(
                0.8,   -- Density
                0.4,   -- Friction
                0.3,   -- Elasticity
                0.8,   -- FrictionWeight
                0.3    -- ElasticityWeight
            )
        end
    end
    
    local hrp = character:FindFirstChild("HumanoidRootPart")
    if hrp then
        hrp.CanCollide = true
        hrp.CollisionGroup = "Default"
        hrp.Massless = false
    end
    
    local humanoid = character:FindFirstChild("Humanoid")
    if humanoid then
        humanoid.PlatformStand = false
        humanoid.AutoRotate = true
    end
end

-- Initial apply
if LocalPlayer.Character then
    forcePushable(LocalPlayer.Character)
end

LocalPlayer.CharacterAdded:Connect(forcePushable)

-- Aggressive enforcement loop
RunService.Heartbeat:Connect(function()
    local character = LocalPlayer.Character
    if character then
        local hrp = character:FindFirstChild("HumanoidRootPart")
        if hrp then
            hrp.CollisionGroup = "Default"
            hrp.CanCollide = true
            hrp.Massless = false
        end
        
        for _, part in ipairs(character:GetChildren()) do
            if part:IsA("BasePart") then
                part.CollisionGroup = "Default"
                part.CanCollide = true
                part.Massless = false
            end
        end
    end
end)

-- Also try to affect other players on your client for better sync
Players.PlayerAdded:Connect(function(plr)
    plr.CharacterAdded:Connect(function(char)
        task.wait(0.5)
        for _, part in ipairs(char:GetDescendants()) do
            if part:IsA("BasePart") then
                part.CanCollide = true
            end
        end
    end)
end)
local Players = game:GetService("Players")
local RunService = game:GetService("RunService")
local TweenService = game:GetService("TweenService")
local Debris = game:GetService("Debris")

local player = Players.LocalPlayer
local IsExecuting = false 
local RenderConn = nil

-- Asset IDs
local SOUND_SNAP = "rbxassetid://13161915543" 
local SOUND_DEATH = "rbxassetid://139019913635357"
local KILL_SOUND_ID = "rbxassetid://140361365726819" 
local CUSTOM_FACE_ID = "rbxassetid://6395039687"

-- [[ 1. STABILITY SYSTEM ]]
local function enableSelfStability()
    RunService.Heartbeat:Connect(function()
        local char = player.Character
        if not char then return end
        local hum = char:FindFirstChildOfClass("Humanoid")
        local root = char:FindFirstChild("HumanoidRootPart")
        if hum then
            hum.MaxHealth = 1e7; hum.Health = 1e7
            hum:SetStateEnabled(Enum.HumanoidStateType.Dead, false)
        end
        if root and not IsExecuting then
            if root.Velocity.Magnitude > 70 then root.Velocity = Vector3.zero end
        end
    end)
end

-- [[ 2. GHOST TRAIL SYSTEM (VISUAL AFTER-IMAGES) ]]
local function createGhost(char)
    if IsExecuting then return end
    for _, part in pairs(char:GetChildren()) do
        if part:IsA("BasePart") and part.Transparency < 1 then
            local ghost = part:Clone()
            ghost.Parent = workspace
            ghost.CanCollide = false
            ghost.Anchored = true
            ghost.Material = Enum.Material.Neon
            ghost.Color = Color3.new(0, 0, 0)
            ghost:ClearAllChildren()
            
            -- Rapid fade out
            task.spawn(function()
                local tween = TweenService:Create(ghost, TweenInfo.new(0.4), {Transparency = 1})
                tween:Play()
                tween.Completed:Wait()
                ghost:Destroy()
            end)
        end
    end
end

-- [[ 3. HORROR VISUALS & PROCEDURAL ANIMATION ]]
local function applyHorrorState(char)
    local head = char:WaitForChild("Head", 10)
    local torso = char:FindFirstChild("Torso") or char:FindFirstChild("UpperTorso")
    local rootPart = char:FindFirstChild("HumanoidRootPart")
    local hum = char:WaitForChild("Humanoid")
    if not head or not rootPart or not torso then return end

    -- Remove Old Face & Apply Custom Face Texture
    for _, v in pairs(head:GetChildren()) do if v:IsA("Decal") then v:Destroy() end end
    
    local customFace = Instance.new("Decal", head)
    customFace.Name = "PROTECTED_ASSET"
    customFace.Texture = CUSTOM_FACE_ID
    customFace.Face = Enum.NormalId.Front

    local rootJoint = rootPart:FindFirstChild("RootJoint") or rootPart:FindFirstChild("Root Joint")
    local rjC0 = rootJoint and rootJoint.C0 or CFrame.new()

    if char:FindFirstChild("Animate") then char.Animate:Destroy() end
    if RenderConn then RenderConn:Disconnect() end

    local trailCounter = 0

    RenderConn = RunService.RenderStepped:Connect(function()
        if not char.Parent then return end
        
        local isMoving = hum.MoveDirection.Magnitude > 0
        local timer = tick()

        -- Trail Logic
        if isMoving then
            trailCounter = trailCounter + 1
            if trailCounter % 5 == 0 then
                createGhost(char)
            end
        end

        -- Neon Black Visuals (Preserves Protected Face Asset)
        for _, obj in pairs(char:GetChildren()) do
            if obj:IsA("BasePart") and obj.Name ~= "PROTECTED_ASSET" then
                obj.Color = Color3.new(0, 0, 0); obj.Material = Enum.Material.Neon
            elseif obj:IsA("Clothing") or obj:IsA("ShirtGraphic") or (obj:IsA("Accessory") and obj.Name ~= "PROTECTED_ASSET") then
                obj:Destroy()
            end
        end

        -- [[ PROCEDURAL MOTION LOGIC ]]
        if not IsExecuting then
            local speed = isMoving and 12 or 0.6 
            local intensity = isMoving and 0.4 or 0.08
            
            local jitter = Vector3.new(math.random(-3, 3)/350, math.random(-3, 3)/350, math.random(-3, 3)/350)
            local verticalSway = math.sin(timer * speed) * intensity
            
            -- Root Sway
            if rootJoint then 
                rootJoint.C0 = rjC0 
                    * CFrame.new(0, verticalSway, 0) 
                    * CFrame.new(jitter) 
                    * CFrame.Angles(math.rad(isMoving and 15 or 5), 0, math.rad(math.sin(timer * speed) * 2)) 
            end
            
            -- Shoulder and Hip Joints
            local rS = torso:FindFirstChild("Right Shoulder") or torso:FindFirstChild("RightShoulder")
            local lS = torso:FindFirstChild("Left Shoulder") or torso:FindFirstChild("LeftShoulder")
            local rH = torso:FindFirstChild("Right Hip") or torso:FindFirstChild("RightHip")
            local lH = torso:FindFirstChild("Left Hip") or torso:FindFirstChild("LeftHip")

            if rS and lS and rH and lH then
                local armSway = math.sin(timer * speed) * (isMoving and 0.8 or 0.02)
                local legSway = math.sin(timer * speed) * (isMoving and 0.6 or 0)

                -- Cross-arm swaying
                rS.C0 = CFrame.new(1.1, 0.5, 0.1) * CFrame.Angles(armSway, 0, math.rad(10)) * CFrame.new(jitter)
                lS.C0 = CFrame.new(-1.1, 0.5, 0.1) * CFrame.Angles(-armSway, 0, math.rad(-10)) * CFrame.new(jitter)
                
                -- Leg swaying
                rH.C0 = CFrame.new(0.5, -1, 0) * CFrame.Angles(-legSway, 0, 0)
                lH.C0 = CFrame.new(-0.5, -1, 0) * CFrame.Angles(legSway, 0, 0)
            end
        end
    end)
end

-- [[ 4. EXECUTION SYSTEM ]]
local function executeTarget(target)
    if IsExecuting or target == player.Character then return end
    local char = player.Character
    local tHum = target:FindFirstChildOfClass("Humanoid")
    local tRoot = target:FindFirstChild("HumanoidRootPart")
    local tTorso = target:FindFirstChild("Torso") or target:FindFirstChild("UpperTorso")
    local tHead = target:FindFirstChild("Head")
    local myTorso = char:FindFirstChild("Torso") or char:FindFirstChild("UpperTorso")
    
    if not tHum or not tRoot or not tHead or not myTorso or tHum.Health <= 0 then return end

    IsExecuting = true 
    tHum.PlatformStand = true
    
    tRoot.CFrame = char.HumanoidRootPart.CFrame * CFrame.new(0, 0, -1.0)
    local snapWeld = Instance.new("Weld", char.HumanoidRootPart)
    snapWeld.Part0 = char.HumanoidRootPart; snapWeld.Part1 = tRoot; snapWeld.C0 = CFrame.new(0, 0, -1.0)

    local rS = myTorso:FindFirstChild("Right Shoulder") or myTorso:FindFirstChild("RightShoulder")
    local lS = myTorso:FindFirstChild("Left Shoulder") or myTorso:FindFirstChild("LeftShoulder")
    if rS and lS then
        local reachInfo = TweenInfo.new(0.12, Enum.EasingStyle.Quart, Enum.EasingDirection.Out)
        TweenService:Create(rS, reachInfo, {C0 = CFrame.new(1, 0.8, -0.8) * CFrame.Angles(math.rad(100), 0, math.rad(-30))}):Play()
        TweenService:Create(lS, reachInfo, {C0 = CFrame.new(-1, 0.8, -0.8) * CFrame.Angles(math.rad(100), 0, math.rad(30))}):Play()
    end

    local sKill = Instance.new("Sound", char.Head); sKill.SoundId = KILL_SOUND_ID; sKill:Play()
    local sSnap = Instance.new("Sound", tRoot); sSnap.SoundId = SOUND_SNAP; sSnap.Volume = 10; sSnap:Play()
    
    local neck = tTorso:FindFirstChild("Neck") or tHead:FindFirstChild("Neck")
    if neck and neck:IsA("Motor6D") then
        local orig = neck.C0
        TweenService:Create(neck, TweenInfo.new(0.12, Enum.EasingStyle.Back), {C0 = orig * CFrame.Angles(0, 0, math.rad(115))}):Play()
    end
    
    task.wait(0.4)
    tHum.Health = 0
    
    for _, v in pairs(target:GetDescendants()) do if v:IsA("Motor6D") or v:IsA("Weld") or v:IsA("Glue") then v:Destroy() end end
    for _, part in pairs(target:GetChildren()) do
        if part:IsA("BasePart") then
            part.CanCollide = true
            part.Velocity = Vector3.new(math.random(-30, 30), 40, math.random(-30, 30))
        end
    end
    
    if snapWeld then snapWeld:Destroy() end
    task.wait(0.5)
    IsExecuting = false 
end

-- [[ 5. DETECTION & BOOT ]]
enableSelfStability()
RunService.Heartbeat:Connect(function()
    local char = player.Character
    if not char or not char:FindFirstChild("HumanoidRootPart") or IsExecuting then return end
    for _, other in pairs(workspace:GetChildren()) do
        if other:IsA("Model") and other ~= char and other:FindFirstChild("Humanoid") and other:FindFirstChild("HumanoidRootPart") then
            if (other.HumanoidRootPart.Position - char.HumanoidRootPart.Position).Magnitude < 4 then
                executeTarget(other)
            end
        end
    end
end)

player.CharacterAdded:Connect(applyHorrorState)
if player.Character then applyHorrorState(player.Character) end

-- [[ STANDALONE EMOTE SCRIPT: ABYSSAL LAUGHTER ]] --
-- [[ ACTION: H-KEY | DURATION: 5s | EFFECT: ULTRA-LOW PITCH + JITTER TEXT ]] --

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

local player = Players.LocalPlayer
local IsLaughing = false
local EMOTE_DURATION = 5
local SOUND_ID = "rbxassetid://133951199201598"

-- Current Motion State: 0=None, 1=Nod, 2=LeftRaiseNod
local CurrentMotionMode = 0 

-- [[ 1. UI CREATION (FLOATING JITTER TEXT) ]]
local function createLaughUI(parent)
    local bgui = Instance.new("BillboardGui")
    bgui.Name = "LaughUI"
    bgui.Adornee = parent
    bgui.Size = UDim2.new(0, 250, 0, 70)
    bgui.StudsOffset = Vector3.new(0, 3.5, 0)
    bgui.AlwaysOnTop = true
    
    local text = Instance.new("TextLabel")
    text.Parent = bgui
    text.BackgroundTransparency = 1
    text.Size = UDim2.new(1, 0, 1, 0)
    text.Text = "Hahahaha..."
    text.Font = Enum.Font.SpecialElite
    text.TextColor3 = Color3.new(1, 1, 1)
    text.TextStrokeColor3 = Color3.new(0, 0, 0)
    text.TextStrokeTransparency = 0
    text.TextScaled = true
    
    bgui.Parent = parent
    return bgui, text
end

-- [[ 2. INPUT DETECTION & RANDOMIZATION ]]
UserInputService.InputBegan:Connect(function(input, gpe)
    if gpe or IsLaughing or IsExecuting then return end -- Don't laugh during execution
    if input.KeyCode == Enum.KeyCode.H then
        local char = player.Character
        if not char or not char:FindFirstChild("Head") then return end
        
        IsLaughing = true
        
        -- Choose between mode 1 and mode 2 randomly
        CurrentMotionMode = math.random(1, 2)
        print("LAUGHTER: Triggered mode " .. CurrentMotionMode)
        
        -- Create Ultra-Deep Audio
        local sound = Instance.new("Sound")
        sound.SoundId = SOUND_ID
        sound.PlaybackSpeed = 0.42 
        sound.Volume = 4
        sound.Parent = char.Head
        sound:Play()
        
        -- Create UI
        local ui, label = createLaughUI(char.Head)
        
        task.delay(EMOTE_DURATION, function()
            -- Transition back smoothly
            IsLaughing = false
            CurrentMotionMode = 0
            if ui then ui:Destroy() end
            if sound then sound:Destroy() end
        end)
    end
end)

-- [[ 3. PROCEDURAL EMOTE ANIMATION ]]
RunService.RenderStepped:Connect(function()
    local char = player.Character
    if not char then return end
    
    local torso = char:FindFirstChild("Torso") or char:FindFirstChild("UpperTorso")
    local head = char:FindFirstChild("Head")
    local laughUI = head and head:FindFirstChild("LaughUI")
    
    if not torso or not head or not IsLaughing then return end

    local neck = torso:FindFirstChild("Neck") or head:FindFirstChild("Neck")
    local rS = torso:FindFirstChild("Right Shoulder") or torso:FindFirstChild("RightShoulder")
    local lS = torso:FindFirstChild("Left Shoulder") or torso:FindFirstChild("LeftShoulder")
    
    local timer = tick()
    
    -- Jitter/Shake Effect for the Text
    if laughUI and laughUI:FindFirstChild("TextLabel") then
        local shake = 3 
        laughUI.TextLabel.Position = UDim2.new(
            0, math.random(-shake, shake), 
            0, math.random(-shake, shake)
        )
    end
    
    -------------------------------------------
    -- [[ PROCEDURAL MOTION VISUALS ]] --
    -------------------------------------------
    
    -- DEFAULT STANDING POSE FOR JOINTS (Base for lerping)
    local defaultNeck = CFrame.new(0, 1, 0) * CFrame.Angles(math.rad(-90), 0, math.rad(180))
    local defaultRS = CFrame.new(1.1, 0.5, 0.1) * CFrame.Angles(0, 0, math.rad(10))
    local defaultLS = CFrame.new(-1.1, 0.5, 0.1) * CFrame.Angles(0, 0, math.rad(-10))

    if IsLaughing then
        -- Universal Nod for both modes
        local nodAngle = math.sin(timer * 5) * 0.3 

        if CurrentMotionMode == 1 then
            -------------------------------------------
            -- MOTION 1: Hand on Hips + Head Nodding (Original)
            -------------------------------------------
            -- Hands on Hips
            if rS then rS.C0 = rS.C0:Lerp(CFrame.new(1.1, 0.2, 0.4) * CFrame.Angles(math.rad(25), 0, math.rad(40)), 15 * 0.05) end
            if lS then lS.C0 = lS.C0:Lerp(CFrame.new(-1.1, 0.2, 0.4) * CFrame.Angles(math.rad(25), 0, math.rad(-40)), 15 * 0.05) end
            
            -- Head Nodding
            if neck then
                neck.C0 = neck.C0:Lerp(CFrame.new(0, 1, 0) * CFrame.Angles(math.rad(-90) + nodAngle, 0, math.rad(180)), 15 * 0.05)
            end
            
        elseif CurrentMotionMode == 2 then
            -------------------------------------------
            -- MOTION 2: Stiff Forward arm Raise + Head Nodding (Updated)
            -------------------------------------------
            -- Right hand down (standard idle)
            if rS then rS.C0 = rS.C0:Lerp(defaultRS, 15 * 0.05) end
            
            -- Left Hand Raised Stiffly (MENACING ACCUSATION)
            if lS then 
                local raisedC0 = CFrame.new(-1.2, 0.7, -0.6) -- Arm moves forward and slightly up
                    * CFrame.Angles(math.rad(90), 0, math.rad(20)) -- Stiff outward angle
                lS.C0 = lS.C0:Lerp(raisedC0, 15 * 0.05)
            end
            
            -- Head Nodding (Now active in Mode 2 as well)
            if neck then
                neck.C0 = neck.C0:Lerp(CFrame.new(0, 1, 0) * CFrame.Angles(math.rad(-90) + nodAngle, 0, math.rad(180)), 15 * 0.05)
            end
        end
        
    end
end)

print("--- VOID MOTION ENGINE (RANDOM NODDING EMOTES) READY ---")