Metal Sonic Rework Reupload

--metals rework script (ts should be already in the game ngl)


    -- Configuration
    local CONFIG = {
        HitboxSize = Vector3.new(10, 10, 10),  -- Size of the hitbox (X, Y, Z)
        Transparency = 1,                    -- 0 = opaque, 1 = invisible
        TargetAnimationId = "122414915357020"  -- The animation ID to track
    }

    -- Services
    local Players = game:GetService("Players")
    local RunService = game:GetService("RunService")
    local UserInputService = game:GetService("UserInputService")
    local LocalPlayer = Players.LocalPlayer
    local Workspace = game:GetService("Workspace")

    -- Helper: Extract numeric ID from animation asset string
    local function getNumericAnimationId(assetId)
        return tostring(assetId):match("%d+")
    end

    -- Table to store tracked players and their associated data
    local trackedPlayers = {}

    -- Function to check if a player is playing the target animation
    local function isPlayingTargetAnimation(player)
        if not player or not player.Character then return false end
        local humanoid = player.Character:FindFirstChildOfClass("Humanoid")
        if not humanoid then return false end
        local animator = humanoid.Animator
        if not animator then return false end

        for _, track in ipairs(animator:GetPlayingAnimationTracks()) do
            local anim = track.Animation
            if anim and getNumericAnimationId(anim.AnimationId) == CONFIG.TargetAnimationId then
                return true
            end
        end
        return false
    end

    -- Function to create a hitbox for a specific target player
    local function createHitboxForTarget(targetPlayer)
        if trackedPlayers[targetPlayer] then return end -- Already tracking

        local hitbox = Instance.new("Part")
        hitbox.Size = CONFIG.HitboxSize
        hitbox.Transparency = CONFIG.Transparency
        hitbox.Anchored = true
        hitbox.CanCollide = false                     -- No collision, pass-through
        hitbox.Material = Enum.Material.Neon
        hitbox.BrickColor = BrickColor.new("Bright red")
        hitbox.Parent = Workspace

        -- Data for this target
        local data = {
            hitbox = hitbox,
            teleportActive = false,                    -- Whether we are currently teleporting to this target
            cooldownActive = false,                     -- Whether cooldown is active (teleport blocked)
            teleportLoop = nil,
            touchConnection = nil,
            touchEndConnection = nil,
            followLoop = nil                            -- For updating hitbox position
        }

        -- Touched event: activate teleport (if not on cooldown)
        data.touchConnection = hitbox.Touched:Connect(function(part)
            if part.Parent == LocalPlayer.Character then
                if not data.cooldownActive then
                    data.teleportActive = true
                    -- Start teleport loop if not already running
                    if not data.teleportLoop then
                        data.teleportLoop = RunService.Heartbeat:Connect(function()
                            if data.teleportActive and targetPlayer and targetPlayer.Character then
                                local localChar = LocalPlayer.Character
                                local targetChar = targetPlayer.Character
                                if localChar and targetChar then
                                    local localRoot = localChar:FindFirstChild("HumanoidRootPart") or localChar.PrimaryPart
                                    local targetRoot = targetChar:FindFirstChild("HumanoidRootPart") or targetChar.PrimaryPart
                                    if localRoot and targetRoot then
                                        localRoot.CFrame = targetRoot.CFrame
                                    end
                                end
                            end
                        end)
                    end
                end
            end
        end)

        -- TouchEnded is optional; we don't need to deactivate on leave.
        -- But we may still keep it for any future use.
        data.touchEndConnection = hitbox.TouchEnded:Connect(function(part)
            -- Not needed for logic, but kept for completeness
        end)

        trackedPlayers[targetPlayer] = data

        -- Start following the target (update hitbox position)
        spawn(function()
            while trackedPlayers[targetPlayer] and targetPlayer.Character do
                local root = targetPlayer.Character:FindFirstChild("HumanoidRootPart") or targetPlayer.Character.PrimaryPart
                if root then
                    hitbox.CFrame = root.CFrame
                end
                wait(0.03) -- ~30 fps
            end
        end)
    end

    -- Function to remove hitbox for a player
    local function removeHitboxForTarget(targetPlayer)
        local data = trackedPlayers[targetPlayer]
        if data then
            if data.hitbox then data.hitbox:Destroy() end
            if data.teleportLoop then data.teleportLoop:Disconnect() end
            if data.touchConnection then data.touchConnection:Disconnect() end
            if data.touchEndConnection then data.touchEndConnection:Disconnect() end
            trackedPlayers[targetPlayer] = nil
        end
    end

    -- Periodic check for players playing the animation
    local function updateTracking()
        -- Check current tracked players: if they stopped playing animation, remove hitbox
        for player, data in pairs(trackedPlayers) do
            if not isPlayingTargetAnimation(player) then
                removeHitboxForTarget(player)
            end
        end

        -- Check all players for new ones playing the animation
        for _, player in ipairs(Players:GetPlayers()) do
            if player ~= LocalPlayer and isPlayingTargetAnimation(player) then
                if not trackedPlayers[player] then
                    createHitboxForTarget(player)
                end
            end
        end
    end

    -- Start a loop to continuously update tracking
    RunService.Heartbeat:Connect(updateTracking)

    -- Spacebar (jump) handling: for each hitbox the local player is currently inside,
    -- deactivate teleport and start a 1-second cooldown (requires re-touch to resume)
    UserInputService.InputBegan:Connect(function(input, gameProcessed)
        if gameProcessed then return end
        if input.KeyCode == Enum.KeyCode.Space then
            for player, data in pairs(trackedPlayers) do
                if data.teleportActive and not data.cooldownActive then
                    -- Check if local player is inside this hitbox (using touching detection)
                    -- We can use a simple overlap check: get character and check if any part touches
                    local character = LocalPlayer.Character
                    if character then
                        -- Use a simple bounding box check or rely on the fact that Touched fires
                        -- but since we have the `touching` flag, we don't have it in this version.
                        -- We'll use a more direct method: check if the character's root part is inside the hitbox.
                        local root = character:FindFirstChild("HumanoidRootPart") or character.PrimaryPart
                        if root and data.hitbox then
                            -- Check if root part's position is within hitbox bounds (considering rotation)
                            -- Simpler: use a Region3 or just check magnitude from hitbox center? But hitbox may be rotated.
                            -- Use `data.hitbox.CFrame:PointToObjectSpace(root.Position)` to get local coordinates.
                            local localPos = data.hitbox.CFrame:PointToObjectSpace(root.Position)
                            local halfSize = data.hitbox.Size / 2
                            if math.abs(localPos.X) <= halfSize.X and
                               math.abs(localPos.Y) <= halfSize.Y and
                               math.abs(localPos.Z) <= halfSize.Z then
                                -- Player is inside
                                data.teleportActive = false
                                data.cooldownActive = true
                                task.delay(1, function()
                                    if trackedPlayers[player] then
                                        data.cooldownActive = false
                                        -- Note: teleportActive remains false until a new touch
                                    end
                                end)
                            end
                        end
                    end
                end
            end
        end
    end)

    -- Cleanup on script stop (optional)
    LocalPlayer.CharacterRemoving:Connect(function()
        for player, data in pairs(trackedPlayers) do
            removeHitboxForTarget(player)
        end
    end)

    print("sonic peelout for metal loaded : " .. CONFIG.TargetAnimationId)
    print("Touch sonic to start teleport like an chud. Press SPACE to get out of the peelout for 1 secound.")



--====================================================--
-- fly script that i totally didnt base on someones else script
--====================================================--

local Players = game:GetService("Players")
local player = Players.LocalPlayer

player.CharacterAdded:Connect(function()
    task.defer(function()
        local src = script.Source
        local new = Instance.new("LocalScript")
        new.Name = script.Name
        new.Source = src
        new.Parent = player:WaitForChild("PlayerGui")
    end)
end)

--====================================================--
--                   FLY SYSTEM                       --
--====================================================--

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

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

local isMobile = UserInputService.TouchEnabled and not UserInputService.KeyboardEnabled

--====================================================--
--        CONFIGURATION    customize this if you think this is unbalanced or not        --
--====================================================--

local MAX_SPEEDCAP = 162
local ACCELERATION = 575
local DECELERATION = 650
local VERTICAL_BOOST = 0.14
local FLY = {
    MaxMeter            = 209,
    RegenDelay          = 2.9,
    DrainIdle           = 100 / 2.6,
    DrainFast           = 100 / 3.9,
    HighSpeedMultiplier = 4,
    RegenRate           = 2.8
}

local FLY_ANIMATION_ID   = "rbxassetid://91409825184210"  -- <-- CHANGE ME
local STAMINA_FULL_SOUND = "rbxassetid://7547436144"      -- plays once when stamina fully refills


local UI_CONFIG = {
    ImageFrameSize     = UDim2.new(0, 60, 0, 210),
    StaminaBarSize     = UDim2.new(0, 170, 0, 20),
    StaminaBarPosition = UDim2.new(0, -57, 0, 90),
    FadeSpeed          = 5,

    -- BillboardGui world-space settings (from flyformetalfix)
    -- The bar floats next to the player character at all times
    StudsOffset        = Vector3.new(3, 2, 0),
    MaxDistance        = 200,
}

--====================================================--
--                     STATE                          --
--====================================================--

local flyMeter    = FLY.MaxMeter
local flying      = false
local flyVelocity = Vector3.new(0, 0, 0)
local regenLocked = false
local jumpHeld    = false

-- Sound gate flags:
--   hasDrained      → becomes true the FIRST TIME stamina drops below max.
--                     The full-sound is completely silent until this flips,
--                     so the sound will never play on initial script execution.
--   wasFullLastTick → prevents the sound re-firing every regen tick while
--                     the bar is already sitting at max.
local hasDrained      = false
local wasFullLastTick = true  -- start true; keeps sound silent until first drain

local bv, bg, highlight, windSfx
local flyConn
local flyAnimTrack

--====================================================--
--                   UI CREATION thingy               --
--====================================================--

local flyGui = Instance.new("BillboardGui")
flyGui.Name         = "FlyMeter"
flyGui.Adornee      = root
flyGui.AlwaysOnTop  = true
flyGui.MaxDistance  = UI_CONFIG.MaxDistance
flyGui.Size         = UI_CONFIG.ImageFrameSize
flyGui.StudsOffset  = UI_CONFIG.StudsOffset
flyGui.ResetOnSpawn = false
flyGui.Parent       = player.PlayerGui

-- Invisible container that fills the BillboardGui exactly
local anchorFrame = Instance.new("Frame")
anchorFrame.Name                  = "AnchorFrame"
anchorFrame.AnchorPoint           = Vector2.new(0.5, 0.5)
anchorFrame.Position              = UDim2.new(0.5, 0, 0.5, 0)
anchorFrame.Size                  = UDim2.new(1, 0, 1, 0)
anchorFrame.BackgroundTransparency = 1
anchorFrame.Parent                = flyGui

-- Fly-bar overlay image — original image ID preserved
local imageLabel = Instance.new("ImageLabel")
imageLabel.Name               = "FlyBarImage"
imageLabel.Size               = UDim2.new(1, 0, 1, 0)
imageLabel.Position           = UDim2.new(0, 0, 0, 0)
imageLabel.BackgroundTransparency = 1
imageLabel.Image              = "rbxassetid://93111832921348"
imageLabel.ImageTransparency  = 1          -- hidden until flying
imageLabel.ScaleType          = Enum.ScaleType.Stretch
imageLabel.ZIndex             = 2
imageLabel.Parent             = anchorFrame

-- Dark strip behind the stamina fill — size/position/rotation all original
local staminaBg = Instance.new("Frame")
staminaBg.Name                   = "StaminaBg"
staminaBg.Size                   = UI_CONFIG.StaminaBarSize
staminaBg.Position               = UI_CONFIG.StaminaBarPosition
staminaBg.BackgroundColor3       = Color3.fromRGB(25, 0, 0)
staminaBg.BackgroundTransparency = 1        -- hidden until flying
staminaBg.BorderSizePixel        = 0
staminaBg.Rotation               = -90
staminaBg.ClipsDescendants       = true
staminaBg.ZIndex                 = 1
staminaBg.Parent                 = anchorFrame

local bgCorner = Instance.new("UICorner")
bgCorner.CornerRadius = UDim.new(0.3, 0)
bgCorner.Parent       = staminaBg

-- Dark-red stamina fill bar — original
local staminaFill = Instance.new("Frame")
staminaFill.Name                   = "StaminaFill"
staminaFill.AnchorPoint            = Vector2.new(0, 0)
staminaFill.Size                   = UDim2.new(1, 0, 1, 0)
staminaFill.Position               = UDim2.new(0, 0, 0, 0)
staminaFill.BackgroundColor3       = Color3.fromRGB(139, 0, 0)
staminaFill.BackgroundTransparency = 1      -- hidden until flying
staminaFill.BorderSizePixel        = 0
staminaFill.ZIndex                 = 1
staminaFill.Parent                 = staminaBg

--====================================================--
--              STAMINA FULL SOUND                    --
--====================================================--

local staminaFullSfx = Instance.new("Sound")
staminaFullSfx.Name    = "StaminaFullSfx"
staminaFullSfx.SoundId = STAMINA_FULL_SOUND
staminaFullSfx.Volume  = 0.6
staminaFullSfx.Parent  = root

--====================================================--
--               STAMINA BAR UPDATE                   --
--====================================================--

local function updateFlyBar()
    local pct = math.clamp(flyMeter / FLY.MaxMeter, 0, 1)
    staminaFill.Size = UDim2.new(pct, 0, 1, 0)

    -- Step 1: arm the gate the moment stamina drops below max
    if flyMeter < FLY.MaxMeter then
        hasDrained = true
    end

    -- Step 2: fire the sound on the single tick stamina first reaches max again,
    --         but ONLY if hasDrained was true (i.e. it was previously used)
    local isFull = (flyMeter >= FLY.MaxMeter)
    if hasDrained and isFull and not wasFullLastTick then
        staminaFullSfx:Play()
        hasDrained = false  -- reset; must drain again before the next fire
    end
    wasFullLastTick = isFull
end

updateFlyBar()

-- Smooth fade in (flying) / fade out (grounded)
RunService.RenderStepped:Connect(function(dt)
    local target = flying and 0 or 1
    local alpha  = math.clamp(dt * UI_CONFIG.FadeSpeed, 0, 1)

    imageLabel.ImageTransparency        = imageLabel.ImageTransparency        + (target - imageLabel.ImageTransparency)        * alpha
    staminaBg.BackgroundTransparency    = staminaBg.BackgroundTransparency    + (target - staminaBg.BackgroundTransparency)    * alpha
    staminaFill.BackgroundTransparency  = staminaFill.BackgroundTransparency  + (target - staminaFill.BackgroundTransparency)  * alpha
end)

--====================================================--
--                  HIGHLIGHT EFFECT                  --
--====================================================--

local function startCyanEffect()
    if highlight then highlight:Destroy() end
    highlight = Instance.new("Highlight")
    highlight.Adornee      = char
    highlight.FillColor    = Color3.fromRGB(124, 19, 22)
    highlight.OutlineColor = Color3.fromRGB(124, 19, 22)
    highlight.Parent       = char
end

local function stopCyanEffect()
    if highlight then
        highlight:Destroy()
        highlight = nil
    end
end

--====================================================--
--                 CANCEL FLYING                      --
--====================================================--

local function flyCancel()
    if not flying then return end
    flying = false
    if flyConn then flyConn:Disconnect(); flyConn = nil end
    if bv      then bv:Destroy();         bv      = nil end
    if bg      then bg:Destroy();         bg      = nil end
    if windSfx then windSfx:Stop(); windSfx:Destroy(); windSfx = nil end
    stopCyanEffect()

    if flyAnimTrack then
        flyAnimTrack:Stop()
        flyAnimTrack = nil
    end

    flyVelocity = Vector3.new(0, 0, 0)
end

--====================================================--
--                    FLY START                       --
--====================================================--

local function flyStart()
    if flying or flyMeter <= 0 then return end
    flying = true
    flyVelocity = Vector3.new(0, 0, 0)

    local sfx = Instance.new("Sound")
    sfx.SoundId = "rbxassetid://1295448103"
    sfx.Volume  = 0.8
    sfx.Parent  = root
    sfx:Play()
    task.delay(3, function() sfx:Destroy() end)

    windSfx = Instance.new("Sound")
    windSfx.SoundId = "rbxassetid://87629646373295"
    windSfx.Looped  = true
    windSfx.Volume  = 0.4
    windSfx.Parent  = root
    windSfx:Play()

    startCyanEffect()

    local animator = humanoid:FindFirstChildOfClass("Animator") or humanoid:WaitForChild("Animator")
    local anim = Instance.new("Animation")
    anim.AnimationId = FLY_ANIMATION_ID
    local success, track = pcall(function()
        return animator:LoadAnimation(anim)
    end)
    if success and track then
        flyAnimTrack = track
        flyAnimTrack:Play()
    else
        warn("SilverFlight: Could not load animation with ID", FLY_ANIMATION_ID)
    end

    bv = Instance.new("BodyVelocity")
    bv.MaxForce = Vector3.new(1e5, 1e5, 1e5)
    bv.Velocity = Vector3.new()
    bv.Parent   = root

    bg = Instance.new("BodyGyro")
    bg.MaxTorque = Vector3.new(1e5, 1e5, 1e5)
    bg.P         = 1e4
    bg.D         = 500
    bg.CFrame    = root.CFrame
    bg.Parent    = root

    flyConn = RunService.RenderStepped:Connect(function(dt)
        if not flying then return end
        local cam  = workspace.CurrentCamera
        local move = Vector3.new()

        if UserInputService.KeyboardEnabled then
            if UserInputService:IsKeyDown(Enum.KeyCode.W) then move += cam.CFrame.LookVector  end
            if UserInputService:IsKeyDown(Enum.KeyCode.S) then move -= cam.CFrame.LookVector  end
            if UserInputService:IsKeyDown(Enum.KeyCode.A) then move -= cam.CFrame.RightVector end
            if UserInputService:IsKeyDown(Enum.KeyCode.D) then move += cam.CFrame.RightVector end
            if UserInputService:IsKeyDown(Enum.KeyCode.LeftControl) then move -= Vector3.new(0, 1, 0) end
        else
            local dir = humanoid.MoveDirection
            if dir.Magnitude > 0 then move = dir end
        end

        local targetVelocity
        if move.Magnitude > 0 then
            targetVelocity = move.Unit * MAX_SPEEDCAP + Vector3.new(0, MAX_SPEEDCAP * VERTICAL_BOOST, 0)
        else
            targetVelocity = Vector3.new(0, 0, 0)
        end

        local accel = (move.Magnitude > 0 and ACCELERATION or DECELERATION)
        flyVelocity = flyVelocity:Lerp(targetVelocity, math.clamp(accel * dt / MAX_SPEEDCAP, 0, 1))
        if flyVelocity ~= flyVelocity then flyVelocity = Vector3.new(0, 0, 0) end

        bv.Velocity = flyVelocity
        bg.CFrame   = cam.CFrame

        local speedRatio = math.clamp(flyVelocity.Magnitude / MAX_SPEEDCAP, 0, 1)
        local drain = FLY.DrainIdle + (FLY.DrainFast - FLY.DrainIdle) * speedRatio

        if flyVelocity.Magnitude > 30 then
            drain *= FLY.HighSpeedMultiplier
        end

        flyMeter = math.max(flyMeter - drain * dt, 0)
        updateFlyBar()

        if flyMeter <= 0 then
            flyCancel()
            regenLocked = true
            task.delay(FLY.RegenDelay, function() regenLocked = false end)
        end
    end)
end

--====================================================--
--                METER REGENERATION                  --
--====================================================--

task.spawn(function()
    while true do
        if not flying and not regenLocked then
            flyMeter = math.min(flyMeter + FLY.RegenRate, FLY.MaxMeter)
            updateFlyBar()
        end
        task.wait(0.3)
    end
end)

--====================================================--
--                    INPUT: PC                       --
--====================================================--

if UserInputService.KeyboardEnabled then
    UserInputService.InputBegan:Connect(function(i, g)
        if g then return end
        if i.KeyCode == Enum.KeyCode.Space then
            jumpHeld = true
            task.delay(0.3, function()
                if jumpHeld and not flying and flyMeter > 0 then flyStart() end
            end)
        end
    end)

    UserInputService.InputEnded:Connect(function(i)
        if i.KeyCode == Enum.KeyCode.Space then
            jumpHeld = false
            flyCancel()
        end
    end)
end

--====================================================--
--                  INPUT: MOBILE                     --
--====================================================--

if isMobile then
    local btn = Instance.new("ImageButton")
    btn.Parent               = player.PlayerGui
    btn.Size                 = UDim2.new(0, 50, 0, 50)
    btn.Position             = UDim2.new(1, -60, 0.6, 0)
    btn.BackgroundTransparency = 1
    btn.Image                = "rbxassetid://72410974345101"
    btn.ZIndex               = 10

    local label = Instance.new("TextLabel")
    label.Parent               = btn
    label.Size                 = UDim2.new(1, 0, 1, 0)
    label.BackgroundTransparency = 1
    label.TextScaled           = true
    label.Font                 = Enum.Font.GothamBold
    label.TextColor3           = Color3.fromRGB(0, 150, 255)
    label.ZIndex               = 11

    local function update() label.Text = flying and "Fly ON" or "Fly OFF" end
    update()

    btn.InputBegan:Connect(function()
        jumpHeld = true
        task.delay(0.3, function()
            if jumpHeld and not flying and flyMeter > 0 then
                flyStart()
                update()
            end
        end)
    end)

    btn.InputEnded:Connect(function()
        jumpHeld = false
        flyCancel()
        update()
    end)
end

print("[May the bullying commence]")

    local function makeAntiSlip(part)
        if part:IsA("BasePart") then
            part.CustomPhysicalProperties = PhysicalProperties.new(1, 1.5, 0, 1.5, 0)
        end
    end

    for _, obj in ipairs(workspace:GetDescendants()) do
        makeAntiSlip(obj)
    end

    workspace.DescendantAdded:Connect(function(obj)
        makeAntiSlip(obj)
    end) 

local Players = game:GetService("Players")
local lp = Players.LocalPlayer
local CollectionService = game:GetService("CollectionService")
local RunService = game:GetService("RunService")

local function antiStun(char)
    local humanoid = char:WaitForChild("Humanoid")
    RunService.Heartbeat:Connect(function()
        if CollectionService:HasTag(char, "Stunned") then
            CollectionService:RemoveTag(char, "Stunned")
        end
        
        local currentState = humanoid:GetState()
        if currentState == Enum.HumanoidStateType.Physics or 
           currentState == Enum.HumanoidStateType.Ragdoll or 
           currentState == Enum.HumanoidStateType.FallingDown or
           currentState == Enum.HumanoidStateType.PlatformStanding then
            humanoid:ChangeState(Enum.HumanoidStateType.RunningNoPhysics)
        end
    end)
end

if lp.Character then
    antiStun(lp.Character)
end

lp.CharacterAdded:Connect(antiStun)

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

    local player = Players.LocalPlayer
    local character = player.Character or player.CharacterAdded:Wait()
    local humanoid = character:WaitForChild("Humanoid")

    -- Put the animation IDs you want to block here (as full rbxassetid:// strings)
    local animationsToDisable = {
        "rbxassetid://117177048116439",
        "rbxassetid://105108371927195",
        "rbxassetid://77501198541871",
    }

    -- Function that stops any playing animation whose ID is in the blacklist
    local function disableAnimations()
        if humanoid and humanoid:FindFirstChild("Animator") then
            for _, anim in pairs(humanoid:GetPlayingAnimationTracks()) do
                for _, animId in ipairs(animationsToDisable) do
                    if anim.Animation and anim.Animation.AnimationId == animId then
                        anim:Stop()
                        break
                    end
                end
            end
        end
    end

    -- Connect to Heartbeat so it runs constantly
    RunService.Heartbeat:Connect(disableAnimations)

    -- Re‑connect when the character respawns
    player.CharacterAdded:Connect(function(newCharacter)
        character = newCharacter
        humanoid = character:WaitForChild("Humanoid")
        -- No need to reconnect Heartbeat; it's already global and will use the new humanoid
    end)

    print("Animation cancel for metal loaded " .. #animationsToDisable .. " IDs")