local isScriptNil = false

local PlrName = "Tabby_Cxt"
local Plrs = game:GetService("Players")
local RunService = game:GetService("RunService")
local Content = game:GetService("ContentProvider")
local LP = Plrs.LocalPlayer
local Char = LP.Character
local PlrGui = LP.PlayerGui
local Backpack = LP.Backpack
local Mouse = LP:GetMouse()

local Camera = Workspace.CurrentCamera
local LastCamCF = Camera.CoordinateFrame
local AnimJoints = {}
local Cons = {}
local mDown = false
local Multi = false
local Grabbing = false
local Current = {}
local Alpha = 1
local LightNum = 1

Current.Part = nil
Current.BP = nil
Current.BA = nil
Current.Mass = nil

local LastPart = nil

local Head = Char["Head"]
local Torso = Char["Torso"]
local Humanoid = Char["Humanoid"]
local LA = Char["Left Arm"]
local RA = Char["Right Arm"]
local LL = Char["Left Leg"]
local RL = Char["Right Leg"]

local LS, RS;

local OrigLS = Torso["Left Shoulder"]
local OrigRS = Torso["Right Shoulder"]

for _,v in pairs(Char:GetChildren()) do
    if v.Name == ModID then
        v:Destroy()
    end
end

for _,v in pairs(PlrGui:GetChildren()) do
    if v.Name == "PadsGui" then
        v:Destroy()
    end
end

local ModID = "Pads"
local Objects = {}
local Grav = 196.2

local sin=math.sin
local cos=math.cos
local max=math.max
local min=math.min
local atan2=math.atan2
local random=math.random
local tau = 2 * math.pi

local BodyObjects = {
    ["BodyVelocity"] = true;
    ["BodyAngularVelocity"] = true;
    ["BodyForce"] = true;
    ["BodyThrust"] = true;
    ["BodyPosition"] = true;
    ["RocketPropulsion"] = true;
}

if LP.Name == PlrName and isScriptNil then
    script.Parent = nil
end

LP.CameraMode = "Classic"

local Assets = {
}

local LS0, LS1 = OrigLS.C0, OrigLS.C1
local RS0, RS1 = OrigRS.C0, OrigRS.C1

for i,v in pairs(Assets) do
    local ID = tostring(Assets[i])
    Assets[i] = "http://www.roblox.com/asset/?id=" .. ID
    Content:Preload("http://www.roblox.com/asset/?id=" .. ID)
end

function QuaternionFromCFrame(cf)
    local mx, my, mz, m00, m01, m02, m10, m11, m12, m20, m21, m22 = cf:components();
    local trace = m00 + m11 + m22 if trace > 0 then
        local s = math.sqrt(1 + trace);
        local recip = 0.5/s;
        return (m21-m12)*recip, (m02-m20)*recip, (m10-m01)*recip, s*0.5;
    else
        local i = 0;
        if m11 > m00 then
            i = 1;
        end;
        if m22 > (i == 0 and m00 or m11) then
            i = 2 end if i == 0 then
            local s = math.sqrt(m00-m11-m22+1);
            local recip = 0.5/s return 0.5*s, (m10+m01)*recip, (m20+m02)*recip, (m21-m12)*recip;
        elseif i == 1 then
            local s = math.sqrt(m11-m22-m00+1);
            local recip = 0.5/s;
            return (m01+m10)*recip, 0.5*s, (m21+m12)*recip, (m02-m20)*recip ;
        elseif i == 2 then
            local s = math.sqrt(m22-m00-m11+1);
            local recip = 0.5/s;
            return (m02+m20)*recip, (m12+m21)*recip, 0.5*s, (m10-m01)*recip;
        end;
    end;
end;

function QuaternionToCFrame(px, py, pz, x, y, z, w)
    local xs, ys, zs = x + x, y + y, z + z;
    local wx, wy, wz = w*xs, w*ys, w*zs;
    local xx = x*xs;
    local xy = x*ys;
    local xz = x*zs;
    local yy = y*ys;
    local yz = y*zs;
    local zz = z*zs;
    return CFrame.new(px, py, pz,1-(yy+zz), xy - wz, xz + wy,xy + wz, 1-(xx+zz), yz - wx, xz - wy, yz + wx, 1-(xx+yy))
end;

function QuaternionSlerp(a, b, t)
    local cosTheta = a[1]*b[1] + a[2]*b[2] + a[3]*b[3] + a[4]*b[4];
    local startInterp, finishInterp;
    if cosTheta >= 0.0001 then
        if (1 - cosTheta) > 0.0001 then
            local theta = math.acos(cosTheta);
            local invSinTheta = 1/math.sin(theta);
            startInterp = math.sin((1-t)*theta)*invSinTheta;
            finishInterp = math.sin(t*theta)*invSinTheta;
        else
            startInterp = 1-t finishInterp = t;
        end;
    else
        if (1+cosTheta) > 0.0001 then
            local theta = math.acos(-cosTheta);
            local invSinTheta = 1/math.sin(theta);
            startInterp = math.sin((t-1)*theta)*invSinTheta;
            finishInterp = math.sin(t*theta)*invSinTheta;
        else startInterp = t-1 finishInterp = t;
        end;
    end;
    return a[1]*startInterp + b[1]*finishInterp, a[2]*startInterp + b[2]*finishInterp, a[3]*startInterp + b[3]*finishInterp, a[4]*startInterp + b[4]*finishInterp;
end;

function CLerp(a,b,t)
    local qa={QuaternionFromCFrame(a)};
    local qb={QuaternionFromCFrame(b)};
    local ax,ay,az=a.x,a.y,a.z;
    local bx,by,bz=b.x,b.y,b.z;
    local _t=1-t;
    return QuaternionToCFrame(_t*ax+t*bx,_t*ay+t*by,_t*az+t*bz,QuaternionSlerp(qa, qb, t));
end

function GetWeld(weld)
    local obj
    for i, v in pairs(AnimJoints) do
        if v[1] == weld then
            obj = v
            break
        end
    end
    if not obj then
        obj = {weld,NV}
        table.insert(AnimJoints,obj)
    end
    return weld.C0.p, obj[2]
end

function SetWeld(weld, i, loops, origpos, origangle, nextpos, nextangle, override, overrideLower, smooth)
    smooth = smooth or 1
    local obj
    for i, v in pairs(AnimJoints) do
        if v[1] == weld then
            obj = v
            break
        end
    end
    if not obj then
        obj = {weld,NV}
        table.insert(AnimJoints,obj)
    end

    local perc = (smooth == 1 and math.sin((math.pi/2)/loops*i)) or i/loops

    local tox,toy,toz = 0,0,0
    tox = math.abs(origangle.x - nextangle.x) *perc
    toy = math.abs(origangle.y - nextangle.y) *perc
    toz = math.abs(origangle.z - nextangle.z) *perc
    tox = ((origangle.x > nextangle.x and -tox) or tox)
    toy = ((origangle.y > nextangle.y and -toy) or toy)
    toz = ((origangle.z > nextangle.z and -toz) or toz)

    local tox2,toy2,toz2 = 0,0,0
    tox2 = math.abs(origpos.x - nextpos.x) *perc
    toy2 = math.abs(origpos.y - nextpos.y) *perc
    toz2 = math.abs(origpos.z - nextpos.z) *perc
    tox2 = (origpos.x > nextpos.x and -tox2) or tox2
    toy2 = (origpos.y > nextpos.y and -toy2) or toy2
    toz2 = (origpos.z > nextpos.z and -toz2) or toz2

    obj[2] = Vector3.new(origangle.x + tox, origangle.y + toy, origangle.z + toz)
    weld.C0 = CFrame.new(origpos.x + tox2,origpos.y + toy2,origpos.z + toz2) * CFrame.Angles(origangle.x + tox,origangle.y + toy,origangle.z + toz)
end

function RotateCamera(x, y)
    Camera.CoordinateFrame = CFrame.new(Camera.Focus.p) * (Camera.CoordinateFrame - Camera.CoordinateFrame.p) * CFrame.Angles(x, y, 0) * CFrame.new(0, 0, (Camera.CoordinateFrame.p - Camera.Focus.p).magnitude)
end

function GetAngles(cf)
    local lv = cf.lookVector
    return -math.asin(lv.y), math.atan2(lv.x, -lv.z)
end

local LastCamCF = Camera.CoordinateFrame

function Look()
    if AlphaOn == true then
        local x, y = GetAngles(LastCamCF:toObjectSpace(Camera.CoordinateFrame))
        Camera.CoordinateFrame = LastCamCF
        RotateCamera(x * -(Alpha), y * -(Alpha))
        LastCamCF = Camera.CoordinateFrame
    end
end

function Cor(Func)
    local Ok, Err = coroutine.resume(coroutine.create(Func))
    if not Ok then
        print(Err)
    end
end

function Cor2(Func)
    local Ok, Err = ypcall(Func)
    if not Ok then
        print(Err)
    end
end

function MakePads()
    -- 1 - VTelekinesis
    P1 = Instance.new("Model")
    P1.Name = ModID

    -- 2 - RBase
    P2 = Instance.new("Part")
    P2.CFrame = CFrame.new(Vector3.new(21.100008, 1.95000589, 11.899971)) * CFrame.Angles(-0, 0, -0)
    P2.FormFactor = Enum.FormFactor.Custom
    P2.Size = Vector3.new(0.799999952, 0.200000003, 0.800000012)
    P2.Anchored = true
    P2.BrickColor = BrickColor.new("White")
    P2.Friction = 0.30000001192093
    P2.Shape = Enum.PartType.Block
    P2.Name = "RBase"
    P2.Parent = P1
    P2.Transparency = 1
    -- 3 - Mesh
    P3 = Instance.new("CylinderMesh")
    P3.Scale = Vector3.new(1, 0.5, 1)
    P3.Parent = P2

    -- 4 - LBase
    P4 = Instance.new("Part")
    P4.CFrame = CFrame.new(Vector3.new(18.100008, 1.95000589, 11.899971)) * CFrame.Angles(-0, 0, -0)
    P4.FormFactor = Enum.FormFactor.Custom
    P4.Size = Vector3.new(0.799999952, 0.200000003, 0.800000012)
    P4.Anchored = true
    P4.BrickColor = BrickColor.new("White")
    P4.Friction = 0.30000001192093
    P4.Shape = Enum.PartType.Block
    P4.Name = "LBase"
    P4.Parent = P1
    P4.Transparency = 1
    -- 5 - Mesh
    P5 = Instance.new("CylinderMesh")
    P5.Scale = Vector3.new(1, 0.5, 1)
    P5.Parent = P4

    -- 7 - Mesh
    P7 = Instance.new("CylinderMesh")
    P7.Scale = Vector3.new(1, 0.5, 1)
    P7.Parent = P6



    -- 9 - Mesh
    P9 = Instance.new("CylinderMesh")
    P9.Scale = Vector3.new(1, 0.5, 1)
    P9.Parent = P8



    -- 11 - Mesh
    P11 = Instance.new("CylinderMesh")
    P11.Scale = Vector3.new(1, 0.5, 1)
    P11.Parent = P10


    -- 13 - Mesh
    P13 = Instance.new("CylinderMesh")
    P13.Scale = Vector3.new(1, 0.5, 1)
    P13.Parent = P12


    -- 15 - Mesh
    P15 = Instance.new("CylinderMesh")
    P15.Scale = Vector3.new(1, 0.5, 1)
    P15.Parent = P14

    -- 17 - Mesh
    P17 = Instance.new("CylinderMesh")
    P17.Scale = Vector3.new(1, 0.5, 1)
    P17.Parent = P16

    P1.Parent = LP.Character
    P1:MakeJoints()
    return P1
end

weldModel = function(model, unanchor, rooty)
    local parts = {}
    local function recurse(object)
        if object:IsA("BasePart") then
            table.insert(parts, object)
        end
        for _,child in pairs(object:GetChildren()) do
            recurse(child)
        end
    end
    recurse(model)

    local rootPart = rooty or parts[1]
    for _, part in pairs(parts) do
        local cframe = rootPart.CFrame:toObjectSpace(part.CFrame)
        local weld = Instance.new("Weld")
        weld.Part0 = rootPart
        weld.Part1 = part
        weld.C0 = cframe
        weld.Parent = rootPart
    end

    if unanchor then
        for _, part in pairs(parts) do
            part.Anchored = false
            part.CanCollide = false
        end
    end
end

weldItem = function(rootPart, Item, TheC0, unanchor, ParentItem)
    local cframe = TheC0 or rootPart.CFrame:toObjectSpace(Item.CFrame)
    local weld = Instance.new("Weld")
    weld.Name = "Weld"
    weld.Part0 = rootPart
    weld.Part1 = Item
    weld.C0 = cframe
    weld.Parent = ParentItem and Item or rootPart

    if unanchor then
        Item.Anchored = false
    end
    return weld, cframe
end

scaleModel = function(model, scale)
    local parts = {}
    local function recurse(object)
        if object:IsA("BasePart") then
            table.insert(parts, object)
        end
        for _,child in pairs(object:GetChildren()) do
            recurse(child)
        end
    end
    recurse(model)

    local top, bottom, left, right, back, front
    for _, part in pairs(parts) do
        if top == nil or top < part.Position.y then         top = part.Position.y end
        if bottom == nil or bottom > part.Position.y then   bottom = part.Position.y end
        if left == nil or left > part.Position.x then       left = part.Position.x end
        if right == nil or right < part.Position.x then     right = part.Position.x end
        if back == nil or back > part.Position.z then       back = part.Position.z end
        if front == nil or front < part.Position.z then     front = part.Position.z end
    end

    local middle = Vector3.new( left+right, top+bottom, back+front )/2
    local minSize = Vector3.new(0.2, 0.2, 0.2)

    for _, part in pairs(parts) do
        local foo = part.CFrame.p - middle
        local rotation = part.CFrame - part.CFrame.p
        local newSize = part.Size*scale
        part.FormFactor = "Custom"
        part.Size = newSize
        part.CFrame = CFrame.new( middle + foo*scale ) * rotation

        if newSize.x < minSize.x or newSize.y < minSize.y or newSize.z < minSize.z then
            local mesh
            for _, child in pairs(part:GetChildren()) do
                if child:IsA("DataModelMesh") then
                    mesh = child
                    break
                end
            end

            if mesh == nil then
                mesh = Instance.new("BlockMesh", part)
            end

            local oScale = mesh.Scale
            local newScale = newSize/minSize * oScale
            if 0.2 < newSize.x then newScale = Vector3.new(1 * oScale.x, newScale.y, newScale.z) end
            if 0.2 < newSize.y then newScale = Vector3.new(newScale.x, 1 * oScale.y, newScale.z) end
            if 0.2 < newSize.z then newScale = Vector3.new(newScale.x, newScale.y, 1 * oScale.z) end

            mesh.Scale = newScale
        end
    end
end

function getMass(Obj, Total)
    local newTotal = Total
    local returnTotal = 0

    if Obj:IsA("BasePart") then
        newTotal = newTotal + Objects[Obj]
    elseif BodyObjects[Obj.ClassName] then
        Obj:Destroy()
    end

    if Obj:GetChildren() and #Obj:GetChildren() > 0 then
        for _,v in pairs(Obj:GetChildren()) do
            returnTotal = returnTotal + getMass(v, newTotal)
        end
    else
        returnTotal = newTotal
    end

    return returnTotal
end

function getTargFromCurrent()
    local Current = Current.Part
    if Current:IsA("BasePart") then
        return Current
    elseif Current:findFirstChild("Torso") then
        return Current.Torso
    else
        for _,v in pairs(Current:GetChildren()) do
            if v:IsA("BasePart") then
                return v
            end
        end
    end
end

function Fire(Part, Vec, Inv)
    pcall(function()
        Current.BP:Destroy()
        Current.BP = nil
    end)
    pcall(function()
        Current.BA:Destroy()
        Current.BA = nil
    end)
    pcall(function()
        if Inv then
            Part.Velocity = -((Vec - Torso.Position).unit * Grav * 1.1)
        else
            Part.Velocity = ((Vec - Camera.CoordinateFrame.p).unit * Grav * 1.1)
        end
        Current.Mass = nil
    end)
    Reset()
end

function Reset()
    LS.Parent = nil
    RS.Parent = nil

    OrigLS.Parent = Torso
    OrigRS.Parent = Torso

    OrigLS.C0 = LS0
    OrigRS.C0 = RS0
end

function Start()
    Cor(function()
        repeat wait(1/30) until LP.Character and LP.Character.Parent == Workspace and LP.Character:findFirstChild("Torso")
        Char = LP.Character
        PlrGui = LP.PlayerGui
        Backpack = LP.Backpack
        Mouse = LP:GetMouse()

        for _,v in pairs(Cons) do
            v:disconnect()
        end
        Cons = {}

        Camera = Workspace.CurrentCamera
        LastCamCF = Camera.CoordinateFrame
        AnimJoints = {}
        mDown = false
        Multi = false
        Grabbing = false
        Current = {}
        Alpha = 1

        Head = Char["Head"]
        Torso = Char["Torso"]
        Humanoid = Char["Humanoid"]
        LA = Char["Left Arm"]
        RA = Char["Right Arm"]
        LL = Char["Left Leg"]
        RL = Char["Right Leg"]

        OrigLS = Torso["Left Shoulder"]
        OrigRS = Torso["Right Shoulder"]

        for _,v in pairs(Char:GetChildren()) do
            if v.Name == ModID then
                v:Destroy()
            end
        end

        for _,v in pairs(PlrGui:GetChildren()) do
            if v.Name == "PadsGui" then
                v:Destroy()
            end
        end

        LS = Instance.new("Weld")
        RS = Instance.new("Weld")

        LS.Name = OrigLS.Name
        LS.Part0 = Torso
        LS.Part1 = LA
        LS.C0 = LS0
        LS.C1 = CFrame.new(0, 0.5, 0,  1, 0, 0,  0, 0, 1,  0, -1, 0)

        RS.Name = OrigRS.Name
        RS.Part0 = Torso
        RS.Part1 = RA
        RS.C0 = RS0
        RS.C1 = CFrame.new(0, 0.5, 0,  1, 0, 0,  0, 0, 1,  0, -1, 0)

        local Pads = MakePads()
        local LPad = Pads.LBase
        local RPad = Pads.RBase

        weldModel(LPad, true, LPad)
        weldModel(RPad, true, RPad)

        local GripWeldL = Instance.new("Weld")
        GripWeldL.Name = "GripWeldL"
        GripWeldL.Part0 = LA
        GripWeldL.Part1 = LPad
        GripWeldL.C0 = CFrame.new(0, -1.05, 0) * CFrame.Angles(0, math.rad(180), 0)
        GripWeldL.Parent = LA

        local GripWeldR = Instance.new("Weld")
        GripWeldR.Name = "GripWeldR"
        GripWeldR.Part0 = RA
        GripWeldR.Part1 = RPad
        GripWeldR.C0 = CFrame.new(0, -1.05, 0) * CFrame.Angles(0, math.rad(180), 0)
        GripWeldR.Parent = RA

        local isParts = false

        table.insert(Cons, Mouse.KeyDown:connect(function(Key)
            Key = Key:lower()
            if Key == "z" then
                --Stuff
            elseif Key == "f" then
                local Current = Current.Part
                if Current and Current.Parent ~= nil and not Multi then
                    Current:BreakJoints()
                end
            elseif Key == "q" then
                if isParts then
                    isParts = false
                    for _,v in pairs(Workspace:GetChildren()) do
                        if v.Name == "MyPartV" and v:IsA("BasePart") then
                            v:Destroy()
                        end
                    end
                else
                    isParts = true
                    for i = 1, 50 do
                        local Part = Instance.new("Part")
                        Part.Color = Color3.new(math.random(), math.random(), math.random())
                        Part.Transparency = 0
                        Part.Size = Vector3.new(math.random(1, 3), math.random(1, 3), math.random(1, 3))
                        Part.Archivable = true
                        Part.CanCollide = false
                        Part.Material = "Neon"
                        Part.Locked = false
                        Part.CFrame = Torso.CFrame * CFrame.new(math.random(-15, 15), -1, math.random(-15, 15))
                        Part.Anchored = true
                        Part.Name = "MyPartV"
                        Part.TopSurface = "Smooth"
                        Part.BottomSurface = "Smooth"
                        Part.Parent = Workspace
                    end
                end
            elseif Key == "e" then
                local Targ;
                if Current.Part and Current.Part ~= nil then
                    Targ = getTargFromCurrent()
                else
                    Targ = LastPart
                end
                if Targ and Targ.Parent ~= nil and not Multi then
                    local Ex = Instance.new("Explosion", Workspace)
                    Ex.Position = Targ.CFrame.p
                    Ex.BlastRadius = 16
                    Ex.DestroyJointRadiusPercent = 0.5
                end
            elseif Key == "c" then
                if Current.Part and Current.Part.Parent ~= nil and not Multi then
                    local Part = getTargFromCurrent()
                    if Part then
                        Grabbing = false
                        if Mouse.Hit then
                            local TargPos = CFrame.new(Camera.CoordinateFrame.p, Mouse.Hit.p) * CFrame.new(0, 0, -1000)
                            Fire(Part, TargPos.p)
                        else
                            Fire(Part, Mouse.Origin.p + Mouse.UnitRay.Direction, true)
                        end
                    end
                end
            end
        end))

        table.insert(Cons, Mouse.Button1Up:connect(function()
            mDown = false
            if Grabbing == true and Multi == false then
                Grabbing = false
                Reset()
            end
            if Current.Part ~= nil then
                LastPart = getTargFromCurrent()
                Current = {}
            end
        end))

        local function makeLightning(Par, Start, End, Width, Length, RandomScale, ArcScale, Num1)
            local oldParts = {}
            for _,v in pairs(Par:GetChildren()) do
                v.CFrame = CFrame.new(5e5, 5e5, 5e5)
                table.insert(oldParts, v)
            end
            local Distance = (Start-End).Magnitude
            local ArcScale = ArcScale or 1
            local RandomScale = RandomScale or 0
            local Last = Start
            local IterNum = 0

            while Par.Parent do
                IterNum = IterNum + 1
                local New = nil
                if (Last-End).Magnitude < Length then
                    New = CFrame.new(End)
                else
                    if (End-Last).Magnitude < Length*2 then
                        RandomScale = RandomScale*0.5
                        ArcScale = ArcScale*0.5
                    end
                    local Direct = CFrame.new(Last,End)
                    New = Direct*CFrame.Angles(math.rad(math.random(-RandomScale/4,RandomScale*ArcScale)),math.rad(math.random(-RandomScale,RandomScale)),math.rad(math.random(-RandomScale,RandomScale)))
                    New = New*CFrame.new(0,0,-Length)
                end
                local Trail = nil
                if oldParts[IterNum] then
                    Trail = oldParts[IterNum]
                    Trail.BrickColor = ((Num1 % 2 == 0) and BrickColor.new("Lime green")) or BrickColor.new("Really blue")
                    Trail.Size = Vector3.new(Width, (Last-New.p).Magnitude, Width)
                    Trail.CFrame = CFrame.new(New.p, Last)*CFrame.Angles(math.rad(90),0,0)*CFrame.new(0, -(Last-New.p).Magnitude/2, 0)
                    oldParts[IterNum] = nil
                else
                    Trail = Instance.new("Part")
                    Trail.Name = "Part"
                    Trail.FormFactor = "Custom"
                    Trail.BrickColor = ((Num1 % 2 == 0) and BrickColor.new("Lime green")) or BrickColor.new("Really Blue")
                    Trail.Transparency = 0
                    Trail.Anchored = true
                    Trail.CanCollide = false
                    Trail.Locked = true
                    Trail.BackSurface = "SmoothNoOutlines"
                    Trail.BottomSurface = "SmoothNoOutlines"
                    Trail.FrontSurface = "SmoothNoOutlines"
                    Trail.LeftSurface = "SmoothNoOutlines"
                    Trail.RightSurface = "SmoothNoOutlines"
                    Trail.TopSurface = "SmoothNoOutlines"
                    Trail.Material = "Neon"
                    Trail.Size = Vector3.new(Width, (Last-New.p).Magnitude, Width)
                    Trail.CFrame = CFrame.new(New.p, Last)*CFrame.Angles(math.rad(90),0,0)*CFrame.new(0, -(Last-New.p).Magnitude/2, 0)
                    Trail.Parent = Par
                end
                Last = New.p
                if (Last-End).Magnitude < 1 then
                    break
                end
            end
            for _,v in pairs(oldParts) do
                v:Destroy()
            end
        end

        table.insert(Cons, Mouse.Button1Down:connect(function()
            mDown = true
            local Targ = Mouse.Target
            Cor(function()
                if Targ and Objects[Targ] and not Multi then
                    Grabbing = true
                    Current.Part = Targ
                    local Mass = Objects[Targ]
                    local ForceNum = 0
                    local Hum = nil

                    for _,v in pairs(Targ:GetChildren()) do
                        if BodyObjects[v.ClassName] then
                            v:Destroy()
                        end
                    end

                    for _,v in pairs(Workspace:GetChildren()) do
                        if v:findFirstChild("Humanoid") and v:IsAncestorOf(Targ) then
                            Hum = v.Humanoid
                            Mass = getMass(v, 0)
                            Current.Part = v
                            break
                        end
                    end

                    Current.Mass = Mass

                    if not Hum then
                        Targ:BreakJoints()
                    end

                    ForceNum = Mass * Grav
                    Targ.CanCollide = true
                    Targ.Anchored = false

                    local BP = Instance.new("BodyPosition")
                    BP.maxForce = Vector3.new(3 * ForceNum, 3 * ForceNum, 3 * ForceNum)
                    BP.Parent = Targ

                    local Ang = Instance.new("BodyAngularVelocity")
                    Ang.Parent = Targ

                    Current.BP = BP
                    Current.BA = Ang

                    OrigLS.Parent = nil
                    OrigRS.Parent = nil

                    LS.Parent = Torso
                    RS.Parent = Torso

                    LS.C0 = LS0
                    RS.C0 = RS0

                    local DirDot = Mouse.UnitRay.Direction:Dot(Targ.Position - Mouse.Origin.p)
                    local BPPos = Vector3.new(0, 0, 0)
                    local Vel = Vector3.new(0, 0, 0)
                    local Vlev = random() * math.pi
                    local RPos = Vector3.new(random() * 2 - 1, cos(Vlev), random() * 2 - 1)

                    local Ball = Instance.new("Part")
                    Ball.Name = "Ball"
                    Ball.FormFactor = "Custom"
                    Ball.Color = Color3.new(255, 0, 0)
                    Ball.Transparency = 0.3
                    Ball.Anchored = true
                    Ball.CanCollide = false
                    Ball.Locked = true
                    Ball.BottomSurface, Ball.TopSurface = "Smooth", "Smooth"
                    Ball.Size = Vector3.new(0.5, 0.5, 0.5)
                    Ball.CFrame = Torso.CFrame * CFrame.new(0, 1, -3)
                    Ball.Parent = Char

                    if Targ.Name == "MyPartV" then
                        Targ.Name = "MyPartF"
                    end

                    local LightMod = Instance.new("Model", Char)

                    local Mesh = Instance.new("SpecialMesh")
                    Mesh.MeshType = "Sphere"
                    Mesh.Parent = Ball

                    local Size = 0.5
                    local Rise = true

                    while Grabbing and BP and Ang and Targ.Parent ~= nil do
                        local BPPos = Mouse.Origin.p + Mouse.UnitRay.Direction * DirDot
                        Ang.angularvelocity = Vel
                        BP.position = BPPos + RPos
                        RPos = Vector3.new(max(-1, min(RPos.x + random() * 0.02 - 0.01, 1)), cos(Vlev), max(-1, min(RPos.z + random() * 0.02 - 0.01, 1)))
                        Vel = Vector3.new(max(-1, min(Vel.x + random() * 0.2 - 0.1, 1)), max(-1, min(Vel.y + random() * 0.2 - 0.1, 1)), max(-1, min(Vel.z + random() * 0.2 - 0.1, 1)))
                        Vlev = (Vlev + 0.05) % tau

                        if Hum then
                            Hum.Sit = true
                        end

                        if LA.Parent ~= nil and RA.Parent ~= nil then
                            local LPos = (LA.CFrame * CFrame.new(0, -1, 0)).p
                            local RPos = (RA.CFrame * CFrame.new(0, -1, 0)).p
                            if Rise == true then
                                if Size < 0.6 then
                                    Size = Size + 0.05
                                else
                                    Size = Size + 0.1
                                end
                                if Size >= 2.2 then
                                    Rise = false
                                end
                            else
                                if Size > 2.1 then
                                    Size = Size - 0.05
                                else
                                    Size = Size - 0.1
                                end
                                if Size <= 0.5 then
                                    Rise = true
                                end
                            end
                            Ball.Size = Vector3.new(Size, Size, Size)
                            Ball.CFrame = CFrame.new(LPos:Lerp(RPos, 0.5), Targ.Position) * CFrame.new(0, 0, -2.2)
                            LightNum = LightNum + 1
                            makeLightning(LightMod, Ball.Position, Targ.Position, 0.2, 4, 50, 1, LightNum)
                        elseif Ball.Parent ~= nil then
                            Ball:Destroy()
                        end

                        if LS and LS.Parent == Torso then
                            LS.C0 = CFrame.new(Vector3.new(-1.5, 0.5, 0), Torso.CFrame:pointToObjectSpace((Targ.CFrame or Torso.CFrame * CFrame.new(-1.5, 0.5, 1)).p))
                        end
                        if RS and RS.Parent == Torso then
                            RS.C0 = CFrame.new(Vector3.new(1.5, 0.5, 0), Torso.CFrame:pointToObjectSpace((Targ.CFrame or Torso.CFrame * CFrame.new(1.5, 0.5, 1)).p))
                        end
                        RunService.Heartbeat:wait()
                    end

                    coroutine.resume(coroutine.create(function()
                        for i = 0.5, 1, 0.1 do
                            for i2,v in pairs(LightMod:GetChildren()) do
                                --v.Light.Range = 6-(i*5)
                                v.Transparency = i
                            end
                            wait(1/30)
                        end
                        LightMod:Destroy()
                    end))

                    if BP and BP.Parent ~= nil then
                        BP:Destroy()
                    end

                    if Ang and Ang.Parent ~= nil then
                        Ang:Destroy()
                    end

                    pcall(function() Ball:Destroy() end)
                end
            end)
        end))
    end)
end

function Add(Obj)
    if Obj:IsA("BasePart") and not Objects[Obj] and not (Obj.Name == "Base" and Obj.ClassName == "Part") then
        Objects[Obj] = Obj:GetMass()
        Obj.Changed:connect(function(P)
            if P:lower() == "size" and Objects[Obj] and Obj.Parent ~= nil then
                Objects[Obj] = Obj:GetMass()
            end
        end)
    end
end

function Rem(Obj)
    if Objects[Obj] then
        Objects[Obj] = nil
    end
end

function Recursion(Obj)
    ypcall(function()
        Add(Obj)
        if #Obj:GetChildren() > 0 then
            for _,v in pairs(Obj:GetChildren()) do
                Recursion(v)
            end
        end
    end)
end

Workspace.DescendantAdded:connect(function(Obj)
    Add(Obj)
end)

Workspace.DescendantRemoving:connect(function(Obj)
    Rem(Obj)
end)

for _,v in pairs(Workspace:GetChildren()) do
    Recursion(v)
end

Start()

if LP.Name == PlrName then
    LP.CharacterAdded:connect(Start)
end

local verlet = {}
verlet.step_time = 1 / 50
verlet.gravity = Vector3.new(0, -10, 0)

local char = game.Players.LocalPlayer.Character
local torso = char:WaitForChild("Torso")
local parts = {}
local render = game:GetService("RunService").RenderStepped

wait(2)

local point = {}
local link = {}
local rope = {}

local function ccw(A,B,C)
    return (C.y-A.y) * (B.x-A.x) > (B.y-A.y) * (C.x-A.x)
end

local function intersect(A,B,C,D)
    return ccw(A,C,D) ~= ccw(B,C,D) and ccw(A,B,C) ~= ccw(A,B,D)
end

local function vec2(v)
    return Vector2.new(v.x, v.z)
end

function point:step()
    if not self.fixed then
        local derivative = (self.position - self.last_position) * 0.95
        self.last_position = self.position
        self.position = self.position + derivative + (self.velocity * verlet.step_time ^ 2)
        --[[local torsoP = torso.CFrame * CFrame.new(-1, 0, 0.5)
        local torsoE = torso.CFrame * CFrame.new(1, 0, 0.5)
        local pointE = self.position + torso.CFrame.lookVector * 100
        local doIntersect = intersect(vec2(torsoP.p), vec2(torsoE.p), vec2(self.position), vec2(pointE))
        if not doIntersect then
            self.postition = self.position - torso.CFrame.lookVector * 10
        end]]
    end
end

function link:step()
    for i = 1, 1 do
        local distance = self.point1.position - self.point2.position
        local magnitude = distance.magnitude
        local differance = (self.length - magnitude) / magnitude
        local translation = ((self.point1.fixed or self.point2.fixed) and 1 or 0.6) * distance * differance
        if not self.point1.fixed then
            self.point1.position = self.point1.position + translation
        end
        if not self.point2.fixed then
            self.point2.position = self.point2.position - translation
        end
    end
end

function verlet.new(class, a, b, c)
    if class == "Point" then
        local new = {}
        setmetatable(new, {__index = point})
        new.class = class
        new.position = a or Vector3.new()
        new.last_position = new.position
        new.velocity = verlet.gravity
        new.fixed = false
        return new
    elseif class == "Link" then
        local new = {}
        setmetatable(new, {__index = link})
        new.class = class
        new.point1 = a
        new.point2 = b
        new.length = c or (a.position - b.position).magnitude
        return new
    elseif class == "Rope" then
        local new = {}
        setmetatable(new, {__index = link})
        new.class = class
        new.start_point = a
        new.finish_point = b
        new.points = {}
        new.links = {}
        local inc = (b - a) / 10
        for i = 0, 10 do
            table.insert(new.points, verlet.new("Point", a + (i * inc)))
        end
        for i = 2, #new.points do
            table.insert(new.links, verlet.new("Link", new.points[i - 1], new.points[i]))
        end
        return new
    end
end

local tris = {}
local triParts = {}

local function GetDiscoColor(hue)
 local section = hue % 1 * 3
 local secondary = 0.5 * math.pi * (section % 1)
 if section < 1 then
  return Color3.new(0, 0, 0)
 elseif section < 2 then
  return Color3.new(0, 0, 0)
 else
  return Color3.new(0, 0, 0)
 end
end

local function setupPart(part)
    part.Anchored = true
    part.FormFactor = 3
    part.CanCollide = false
    part.TopSurface = 10
    part.BottomSurface = 10
    part.LeftSurface = 10
    part.RightSurface = 10
    part.FrontSurface = 10
    part.BackSurface = 10
    part.Material = "Neon"
    local m = Instance.new("SpecialMesh", part)
    m.MeshType = "Wedge"
    m.Scale = Vector3.new(0.2, 1, 1)
    return part
end

local function CFrameFromTopBack(at, top, back)
    local right = top:Cross(back)
    return CFrame.new(at.x, at.y, at.z, right.x, top.x, back.x,  right.y, top.y, back.y, right.z, top.z, back.z)
end

local function drawTri(parent, a, b, c)
    local this = {}
    local mPart1 = table.remove(triParts, 1) or setupPart(Instance.new("Part"))
    local mPart2 = table.remove(triParts, 1) or setupPart(Instance.new("Part"))
    function this:Set(a, b, c)
        local ab, bc, ca = b-a, c-b, a-c
        local abm, bcm, cam = ab.magnitude, bc.magnitude, ca.magnitude
        local edg1 = math.abs(0.5 + ca:Dot(ab)/(abm*abm))
        local edg2 = math.abs(0.5 + ab:Dot(bc)/(bcm*bcm))
        local edg3 = math.abs(0.5 + bc:Dot(ca)/(cam*cam))
        if edg1 < edg2 then
            if edg1 >= edg3 then
                a, b, c = c, a, b
                ab, bc, ca = ca, ab, bc
                abm = cam
            end
        else
            if edg2 < edg3 then
                a, b, c = b, c, a
                ab, bc, ca = bc, ca, ab
                abm = bcm
            else
                a, b, c = c, a, b
                ab, bc, ca = ca, ab, bc
                abm = cam
            end
        end

        local len1 = -ca:Dot(ab)/abm
        local len2 = abm - len1
        local width = (ca + ab.unit*len1).magnitude

        local maincf = CFrameFromTopBack(a, ab:Cross(bc).unit, -ab.unit)

        if len1 > 0.2 then
            mPart1.Parent = parent
            mPart1.Size = Vector3.new(0.2, width, len1)
            mPart1.CFrame = maincf*CFrame.Angles(math.pi,0,math.pi/2)*CFrame.new(0,width/2,len1/2)
        else
            mPart1.Parent = nil
        end

        if len2 > 0.2 then
            mPart2.Parent = parent
            mPart2.Size = Vector3.new(0.2, width, len2)
            mPart2.CFrame = maincf*CFrame.Angles(math.pi,math.pi,-math.pi/2)*CFrame.new(0,width/2,-len1 - len2/2)
        else
            mPart2.Parent = nil
        end
    end
    function this:SetProperty(prop, value)
        mPart1[prop] = value
        mPart2[prop] = value
    end
    this:Set(a, b, c)
    function this:Destroy()
        mPart1:Destroy()
        mPart2:Destroy()
    end
    this.p1 = mPart1
    this.p2 = mPart2
    this.p1.BrickColor = BrickColor.new(GetDiscoColor(math.noise(0.5, 0.5, this.p1.CFrame.Y * 0.5 + time())))
    this.p2.BrickColor = BrickColor.new(GetDiscoColor(math.noise(0.5, 0.5, this.p2.CFrame.Y * 0.5 + time())))
    return this
end

function verlet.draw(object, id)
    if object.class == "Point" then
        local part = parts[id]
        part.BrickColor = BrickColor.new(107, 0, 0)
        part.Transparency = 0
        part.formFactor = 3
        part.Anchored = true
        part.CanCollide = false
        part.TopSurface = 0
        part.BottomSurface = 0
        part.Size = Vector3.new(0.35, 0.35, 0.35)
        part.Material = "Neon"
        part.CFrame = CFrame.new(object.position)
        part.Parent = torso
        return part
    elseif object.class == "Link" then
        local part = parts[id]
        local dist = (object.point1.position - object.point2.position).magnitude
        part.Size = Vector3.new(0.2, 0.2, dist)
        part.CFrame = CFrame.new(object.point1.position, object.point2.position) * CFrame.new(0, 0, dist * -0.5)
        part.Parent = torso
        return part
    end
end

function verlet.clear()
    for _, v in pairs(workspace:GetChildren()) do
        if v.Name == "Part" then
            v:Destroy()
        end
    end
end

local points = {}
local links = {}

for x = 0, 2 do
    points[x] = {}
    for y = 0, 3 do
        points[x][y] = verlet.new("Point", torso.Position + Vector3.new(x * 0.8 - 2, 2 - y * 0.8, 5 + y * 0.4))
        points[x][y].fixed = y == 0
    end
end

for x = 1, 2 do
    for y = 0, 3 do
        links[#links + 1] = verlet.new("Link", points[x][y], points[x - 1][y], 1 + y * 0.08)
    end
end

for x = 0, 2 do
    for y = 1, 3 do
        links[#links + 1] = verlet.new("Link", points[x][y], points[x][y - 1], 1.2 + y * 0.03)
    end
end

render:connect(function()
    for x = 0, 2 do
        for y = 0, 3 do
            if y == 0 then
                points[x][y].position = (torso.CFrame * CFrame.new(x * 1 - 1, 1, 0.5)).p
            else
                points[x][y]:step()
            end
        end
    end
    for i = 1, #links do
        links[i]:step()
    end
    for i = 1, #tris do
        triParts[#triParts + 1] = tris[i].p1
        triParts[#triParts + 1] = tris[i].p2
    end
    tris = {}
    for x = 1, 2 do
        for y = 1, 3 do
            tris[#tris + 1] = drawTri(torso, points[x - 1][y - 1].position, points[x - 1][y].position, points[x][y - 1].position)
            tris[#tris + 1] = drawTri(torso, points[x][y].position, points[x - 1][y].position, points[x][y - 1].position)
        end
    end
end)