advanced flame pillar server script

local control = script.Parent
local remote = control:WaitForChild("DAMNFIRE")
local debris = game:GetService("Debris")
local tween = game:GetService("TweenService")
local TIN = TweenInfo.new

local animation -- keep this as it is
local holding = false
local hasAttacked = false -- check if guy attacked recently
local fbcooldown = false -- fireball cooldown
local fpcooldown = false -- flame pillar cooldown

local ballval = 0
local fbcd_Time = 1 -- fireball cooldown
local fpcd_Time = 3 -- flame pillar cooldown
local attackcd = .5 -- delay between each attacks (prevent spam)
local charge = 0
local maxcharge = 10 -- maximum charge
local fbdamage = 1 -- base fbdamage * fireball charge fbdamage
local fpdamage = 5 -- flame pillar damage
local burndamage = 5 -- burn fbdamage

function atkcd(cd)
    hasAttacked = true
    if hasAttacked then
        task.delay(cd,function()
            hasAttacked = false
        end)
    end
end

function cvfx(ball:Instance)
    local rando = math.random(5,8)
    local a = Instance.new("Part",ball)
    a.Shape = Enum.PartType.Ball
    a.Material = Enum.Material.Neon
    a.Size = Vector3.new(rando,rando,rando)
    a.Name = "fireball-vfx"
    a.Transparency = 1
    a.Anchored = true
    a.CanCollide = false
    a.CanTouch = false
    a.Massless = true
    a.Parent = ball
    a.Color = Color3.new(1,1,1)
    a.CFrame = ball.CFrame

    local aud = script.chargeUp:Clone()
    aud.Parent = ball
    aud:Play()
    debris:AddItem(aud,aud.TimeLength + 1)

    charge = charge + 1
    tween:Create(a,TIN(1),{Color = ball.Color,Size = Vector3.new(.1,.1,.1),Transparency = 0}):Play()
    ball:WaitForChild("ParticleEmitter"):Emit(math.random(1,5))
    debris:AddItem(a,1.2)
end

function velocity(Part,Speed,Start,End)
    local vel = Instance.new("BodyVelocity",Part)
    vel.Velocity = CFrame.new(Start,End).LookVector * Speed
    vel.MaxForce = Vector3.new(5000,5000,5000)
    vel.P = 10000
    return vel
end

function burn(Repeats,DamageDelay,Damage,Humanoid)
    coroutine.wrap(function()
        if Humanoid.Parent ~= nil then
            local checkforpart = Humanoid.Parent:FindFirstChildOfClass("Part")
            local particle = script.burnpe:Clone()
            if checkforpart then
                local aud = script.burn:Clone()
                aud.Parent = Humanoid.Parent:FindFirstChildOfClass("Part")
                aud:Play();debris:AddItem(aud,aud.TimeLength + 1)
            end

            for i = 1,Repeats do
                if Humanoid ~= nil and Humanoid.Parent ~= nil then
                    Humanoid:TakeDamage(Damage)
                    checkforpart = Humanoid.Parent:FindFirstChildOfClass("Part")
                    if checkforpart then
                        local ouch = particle:Clone()
                        ouch.Parent = Humanoid.Parent:FindFirstChildOfClass("Part")
                        ouch:Emit(math.random(5,10))
                        debris:AddItem(ouch,1)
                    end
                end

                task.wait(DamageDelay)
            end
        end
    end)()
end


function flamePillarATK(Amount,DistanceOffset,Damage,Humanoid,Parent, Origin, Direction)
    local newdirection = Origin + Direction*2
    local ignorelist = {Parent}

    for i = 1,Amount do
        local p = Instance.new("Part",Parent)
        p.Anchored = true
        p.CastShadow = false
        p.CanCollide = false
        p.Size = Vector3.new(.15,.15,.15)
        p.Orientation = Vector3.new(0,180,90)
        p.Shape = Enum.PartType.Cylinder
        p.Color = Color3.fromRGB(255, 170, 0)
        p.Material = Enum.Material.Neon
        p.Position = newdirection + (Direction * p.Size.X * DistanceOffset * i)

        local params = RaycastParams.new()
        params.FilterType = Enum.RaycastFilterType.Blacklist
        params.FilterDescendantsInstances = ignorelist
        params.IgnoreWater = true

        task.delay(1.5,function()
            if p ~= nil then
                local fphasdamaged = false
                local pillarSize = 15
                local pilar = p:Clone()
                pilar.Size = p.Size - Vector3.new(0,1,1)
                pilar.Transparency = 1
                pilar.Parent = p

                local aud = script.erupt:Clone()
                aud.Parent = p
                aud:Play()

                if i > 1 then
                    pillarSize = 15 + 5 * i
                end

                coroutine.wrap(function()
                    while task.wait(.1) do
                        if p.Parent ~= nil then
                            for _,parts in next,workspace:GetChildren() do
                                if parts:IsA("Model") then
                                    coroutine.wrap(function()
                                        local eroot = parts:FindFirstChild("HumanoidRootPart")
                                        if eroot and (eroot.Position - p.Position).Magnitude < 10 then
                                            local ehum = parts:FindFirstChildOfClass("Humanoid")
                                            if ehum and ehum ~= Humanoid then
                                                if fphasdamaged == false then
                                                    fphasdamaged = true
                                                    ehum:TakeDamage(Damage)
                                                    local eroot = ehum.Parent:FindFirstChild("HumanoidRootPart")
                                                    if eroot then
                                                        local vel = velocity(eroot,30,eroot.Position,eroot.Position + Vector3.new(0,100,0))
                                                        debris:AddItem(vel,.1)
                                                    end
                                                    task.delay(1,function()
                                                        fphasdamaged = false
                                                    end)
                                                end
                                            end
                                        end
                                    end)()
                                end

                                task.wait()
                            end
                        else
                            break
                        end
                    end
                end)()

                tween:Create(pilar,TIN(.25),{Size = Vector3.new(pillarSize,pilar.Size.Y,pilar.Size.Z),Position = Vector3.new(pilar.Position.X + pilar.Size.X,pilar.Position.Y,pilar.Position.Z),Transparency = 0}):Play()
                task.delay(1.5,function()
                    if pilar ~= nil then
                        tween:Create(pilar,TIN(.5),{Size = Vector3.new(pillarSize,1,1),Transparency = 1}):Play()
                    end
                end)
            end
        end)

        tween:Create(p,TIN(.5),{Size = Vector3.new(p.Size.X,10,10)}):Play()
        for _,v in next, workspace:GetChildren() do
            if v:IsA("Model") then
                if v:FindFirstChildOfClass("Humanoid") then
                    table.insert(ignorelist,v)
                    params.FilterDescendantsInstances = ignorelist
                end
            end
        end

        local ray = workspace:Raycast(p.Position,p.Position - Vector3.new(0,1000,0),params)
        if ray then
            local hit = ray.Instance
            if hit then
                p.Position = Vector3.new(p.Position.X,ray.Position.Y,p.Position.Z)
            end
        else
            p:Destroy()
        end

        task.delay(3.5,function()
            if p ~= nil then
                tween:Create(p,TIN(.5),{Size = Vector3.new(.1,.1,.1),Transparency = 1}):Play()
                debris:AddItem(p,.65)
            end
        end)

        task.wait(.1)
    end
end

remote.OnServerEvent:Connect(function(p,v,m)
    local root = p.Character:FindFirstChild("HumanoidRootPart")
    local humanoid = p.Character:FindFirstChildOfClass("Humanoid")

    if p.Character ~= nil and root and humanoid then
        local animator = humanoid:FindFirstChildOfClass("Animator")
        if hasAttacked == false and animator then
            local info = string.lower(tostring(v))
            if fbcooldown == false then
                if animation == nil then
                    animation = animator:LoadAnimation(control:WaitForChild("Animations").Charge)
                end

                if info == "fbfire" then
                    fbcooldown = true
                    atkcd(attackcd)

                    coroutine.wrap(function()
                        for l = 1,5 do -- repeat 3 times and stop animation
                            animation:Stop()
                            task.wait() -- a bit of delay
                        end
                    end)()

                    local totalDmg = fbdamage * charge -- fbdamage multiplied by charge

                    animator:LoadAnimation(control:WaitForChild("Animations").Fire):Play()
                    local ball = root.Parent:FindFirstChild("fireball"..ballval)

                    if ball then
                        local hasHit = false

                        ball.ParticleEmitter:Emit(math.random(5,10))
                        ball.Transparency = 1
                        debris:AddItem(ball,1)

                        local ball2 = ball:Clone()
                        ball2.Joint:Destroy()
                        ball2.Name = ball.Name.."_projectile"
                        ball2.Parent = root.Parent
                        ball2.Position = ball.Position
                        ball2.Anchored = false
                        ball2.Transparency = 0

                        local aud = script.fire:Clone()
                        aud.Parent = ball2
                        aud:Play()

                        debris:AddItem(aud,aud.TimeLength + 1)
                        for _,c in next,ball2:GetChildren() do
                            if c:IsA("Part") then
                                c:Destroy()
                            end
                        end

                        for f,j in next,root.Parent:GetChildren() do
                            if string.match(j.Name,"fireball") then --and not string.match("projectile",j.Name) then
                                if not string.match(j.Name,"projectile") then
                                    if j ~= ball then
                                        debris:AddItem(j,.5)
                                        animation:Stop()
                                    end
                                end
                            end
                        end

                        debris:AddItem(ball2,10)
                        velocity(ball2,100,ball2.Position,m)
                        ball2.Touched:Connect(function(hit)
                            if hasHit == false then
                                local IGNORENAME = {"BASE","Base","Baseplate"} -- ignored hit parts name
                                if hit and not table.find(IGNORENAME,hit.Name) then
                                    if hit.Parent ~= root.Parent and not string.match(hit.Name,"projectile") and not string.match(hit.Name,"vfx") then
                                        hasHit = true

                                        local ehum = hit.Parent:FindFirstChildOfClass("Humanoid") or hit.Parent.Parent:FindFirstChildOfClass("Humanoid")
                                        if ehum and ehum ~= humanoid then
                                            ehum:TakeDamage(totalDmg)
                                            burn(5,1,burndamage,ehum)
                                        end

                                        tween:Create(ball2,TIN(.45),{Transparency = 1,Size = Vector3.new(5,5,5)}):Play()
                                        debris:AddItem(ball2,.5)
                                    end
                                end
                            end
                        end)
                    end

                    task.delay(fbcd_Time,function()
                        fbcooldown = false
                        charge = 0
                    end)
                elseif info == "fbholding" then
                    if holding == false then
                        holding = true
                        local ball = root.Parent:FindFirstChild("fireball"..ballval)
                        if ball then
                            if charge < maxcharge then
                                cvfx(ball)
                                charge = charge + 1
                            end
                        end

                        task.delay(.5,function()
                            holding = false
                        end)
                    end
                elseif info == "fbstart" then
                    if fbcooldown == false then
                        local ball = script:WaitForChild("fireball"):Clone()

                        ballval = ballval + 1
                        ball.Parent = root.Parent
                        ball.Name = ball.Name..ballval
                        ball.Joint.Part0 = root.Parent:FindFirstChild("Right Arm")
                        task.delay(.1,function()
                            if holding == true then
                                animation:Play()
                            end
                        end)
                    end
                end
            end

            if fpcooldown == false then
                if not holding then
                    local info = string.lower(tostring(v))
                    if animation == nil then
                        animation = animator:LoadAnimation(control:WaitForChild("Animations").Charge)
                    end

                    if info == "fpfire" then
                        if fpcooldown == false then
                            fpcooldown = true

                            coroutine.wrap(function()
                                atkcd(attackcd)
                                local i = animator:LoadAnimation(control.Animations.Pillar)
                                i:Play();task.wait(.2)

                                flamePillarATK(math.random(5,7),45,fpdamage,humanoid,root.Parent,root.Position,root.CFrame.LookVector)
                            end)()

                            task.delay(fpcd_Time,function()
                                fpcooldown = false
                            end)
                        end
                    end
                end
            end
        end
    end
end)