Simplifying function on ActionScript 3.0

Question

Heloo, I'd like to make an animation in my program. I've tried a function and its worked. But, this function is gonna be very very long if I continue. Here is my function.

if(jalan) 
    {
        dt1 += t;
        s1 = -A*Math.sin(w*dt1);
        P1.y = s01 + s1;
        var delay1:Timer = new Timer(1000,1);
        delay1.addEventListener(TimerEvent.TIMER,f_delay1);
        delay1.start();
        function f_delay1(event:TimerEvent)
        {
            dt2 += t;
            s2 = -A*Math.sin(w*dt2);
            P2.y = s02 + s2;
            var delay2:Timer = new Timer(1000,1);
            delay2.addEventListener(TimerEvent.TIMER,f_delay2);
            delay2.start();
            function f_delay2(event:TimerEvent)
            {
                dt3 += t;
                s3 = -A*Math.sin(w*dt3);
                P3.y = s03 + s3;
                var delay3:Timer = new Timer(1000,1);
                delay3.addEventListener(TimerEvent.TIMER,f_delay3);
                delay3.start();
                function f_delay3(event:TimerEvent)
                {
                    dt4 += t;
                    s4 = -A*Math.sin(w*dt4);
                    P4.y = s04 + s4;
                    var delay4:Timer = new Timer(1000,1);
                    delay4.addEventListener(TimerEvent.TIMER,f_delay4);
                    delay4.start();
                    function f_delay4(event:TimerEvent)
                    {
                        dt5 += t;
                        s5 = -A*Math.sin(w*dt5);
                        P5.y = s05 + s5;
                        var delay5:Timer = new Timer(1000,1);
                        delay5.addEventListener(TimerEvent.TIMER,f_delay5);
                        delay5.start();
                        function f_delay5(event:TimerEvent)
                        {
                            dt6 += t;
                            s6 = -A*Math.sin(w*dt6);
                            P6.y = s06 + s6;
                            var delay6:Timer = new Timer(1000,1);
                            delay6.addEventListener(TimerEvent.TIMER,f_delay6);
                            delay6.start();
                            function f_delay6(event:TimerEvent)
                            {
                                dt7 += t;
                                s7 = -A*Math.sin(w*dt7);
                                P7.y = s07 + s7;
                                var delay7:Timer = new Timer(1000,1);
                                delay7.addEventListener(TimerEvent.TIMER,f_delay7);
                                delay7.start();
                                function f_delay7(event:TimerEvent)
                                {
                                    dt8 += t;
                                    s8 = -A*Math.sin(w*dt8);
                                    P8.y = s08 + s8;
                                    var delay8:Timer = new Timer(1000,1);
                                    delay8.addEventListener(TimerEvent.TIMER,f_delay8);
                                    delay8.start();
                                    function f_delay8(event:TimerEvent)
                                    {
                                        dt9 += t;
                                        s9 = -A*Math.sin(w*dt9);
                                        P9.y = s09 + s9;
                                        var delay9:Timer = new Timer(1000,1);
                                        delay9.addEventListener(TimerEvent.TIMER,f_delay9);
                                        delay9.start();
                                        function f_delay9(event:TimerEvent)
                                        {
                                            dt10 += t;
                                            s10 = -A*Math.sin(w*dt10);
                                            P10.y = s010 + s10;
                                            var delay10:Timer = new Timer(1000,1);
                                            delay10.addEventListener(TimerEvent.TIMER,f_delay10);
                                            delay10.start();
                                            function f_delay10(event:TimerEvent)
                                            {
                                                dt11 += t;
                                                s11 = -A*Math.sin(w*dt11);
                                                P11.y = s011 + s11;
                                                var delay11:Timer = new Timer(1000,1);
                                                delay11.addEventListener(TimerEvent.TIMER,f_delay11);
                                                delay11.start();
                                                function f_delay11(event:TimerEvent)
                                                {
                                                    dt12 += t;
                                                    s12 = -A*Math.sin(w*dt12);
                                                    P12.y = s012 + s12;
                                                }
                                            }
                                        }
                                    }
                                }
                            }   
                        }
                    }
                }
            }
        }
    }

Is there another function that can simplify this function? Thanks

Making some wave animation by vibrating some particles in a pattern with delay in each particle

Answer 1

When processing data in a similar manner, it is always about Arrays and loops, even if there is a need for delay between loop iterations.

Something like that, I guess. Not tested, but the idea should be clear.

import flash.utils.setTimeout;

// Array of Arrays
var Sequence:Array =
[
    {dt:dt1, P:P1, s0:s01},
    {dt:dt2, P:P2, s0:s02},
    {dt:dt3, P:P3, s0:s03},
    {dt:dt4, P:P4, s0:s04},
    {dt:dt5, P:P5, s0:s05},
    {dt:dt6, P:P6, s0:s06},
    {dt:dt7, P:P7, s0:s07},
    {dt:dt8, P:P8, s0:s08},
    {dt:dt9, P:P9, s0:s09},
    {dt:dt10, P:P10, s0:s010},
    {dt:dt11, P:P11, s0:s011},
];

function onNext(index:int = 0):void
{
    // Checking, if there anything left on the Sequence to do.
    if (index >= Sequence.length)
    {
        return;
    }
    
    // Extract the first tuple of data.
    var aData:Object = Sequence[index];
    
    // Your initial logic here.
    aData.dt += t;
    aData.P.y = aData.s0 - A * Math.sin(w * aData.dt);
    
    // Wait before addressing the next particle.
    setTimeout(onNext, 1000, index + 1);
}

if (jalan)
{
    // The initial call.
    onNext();
}