web-dev-qa-db-fra.com

Comment attendre 3 secondes dans ActionScript 2 ou 3?

Existe-t-il un moyen d'implémenter l'attente pendant, par exemple, 3 secondes dans ActionScript, tout en restant dans la même fonction? J'ai regardé setInterval, setTimeOut et des fonctions similaires, mais ce dont j'ai vraiment besoin, c'est ceci:

public function foo(param1, param2, param3) {
  //do something here
  //wait for 3 seconds
  //3 seconds have passed, now do something more
}

Au cas où vous vous demanderiez pourquoi j'ai besoin de cela - c'est une obligation légale, et non, je ne peux pas le changer.

actionscript
13
TheJavaGuy-Ivan Milosavljević

Utilisez la variable Timer pour appeler une fonction après 3 secondes.

var timer:Timer = new Timer(3000);
timer.addEventListener(TimerEvent.TIMER, callback); // will call callback()
timer.start();

Pour ce faire, vous devez créer le minuteur en tant que variable d'instance afin de pouvoir supprimer le programme d'écoute et l'instance du minuteur lorsque la fonction est appelée, afin d'éviter les fuites.

class Test {
    private var timer:Timer = new Timer(3000);

    public function foo(param1:int, param2:int, param3:int):void {
        // do something here
        timer.addEventListener(TimerEvent.TIMER, fooPartTwo);
        timer.start();
    }

    private function fooPartTwo(event:TimerEvent):void {
        timer.removeEventListener(TimerEvent.TIMER, fooPartTwo);
        timer = null;
        // 3 seconds have passed, now do something more
    }
}

Vous pouvez également utiliser une autre fonction dans votre fonction foo et conserver la portée, de sorte que vous n'avez pas besoin de transmettre de variables.

function foo(param1:int, param2:int, param3:int):void {
    var x:int = 2; // you can use variables as you would normally

    // do something here

    var timer:Timer = new Timer(3000);
    var afterWaiting:Function = function(event:TimerEvent):void {
       timer.removeEventListener(TimerEvent.TIMER, afterWaiting);
       timer = null;

       // 3 seconds have passed, now do something more

       // the scope is retained and you can still refer to the variables you
       // used earlier
       x += 2;
    }

    timer.addEventListener(TimerEvent.TIMER, afterWaiting);
    timer.start();
}
26
rid

Pour AS3, utilisez la réponse de Radu .

Pour AS2, utilisez la fonction setInterval comme ceci:

var timer = setInterval(function, 3000, param1, param2);

function (param1, param2) {

// your function here
clearInterval(timer);

}
4
George Reith

Vous pouvez également utiliser delayCall , from TweenMax . IMHO, c'est le moyen le plus efficace de le faire si vous êtes familier avec la famille TweenMax.

TweenMax.delayedCall(1, myFunction, ["param1", 2]);

function myFunction(param1:String, param2:Number):void  
{ 
   trace("called myFunction and passed params: " + param1 + ", " + param2); 
}

Dans votre cas, utilisez une fonction anonymous :

public function foo(param1, param2, param3) {
   //do something here
   trace("I gonna wait 3 seconds");

   TweenMax.delayedCall(3, function()
   {
       trace("3 seconds have passed");
   });
}
4
Marcelo Assis

Il n'y a pas Sleep dans ActionScript. Mais il existe d'autres moyens de réaliser la même chose sans avoir tout votre code dans une seule fonction et attendre au sein de cette fonction un laps de temps spécifique.

Vous pouvez facilement avoir votre code dans deux fonctions et appeler la 2e après un délai spécifique que vous avez défini dans votre 1re fonction.

2
DanielB

pourquoi vous faites des choses confuses au lieu de faire les choses correctement?

il existe une méthode nommée: "setTimeout ()";

setTimeout(myFunction,3000);

myFunction est la fonction que vous souhaitez appeler après la période. Et 3000 est la période que vous souhaitez attendre (en millisecondes).

vous n'avez pas besoin de définir ensuite un intervalle vide, de créer une minuterie avec un compte de répétition ou de faire autre chose avec plus de problèmes.

2
HITMAN

CECI IS PAS DANS UNE FONCTION - RÉPONSES: "Comment attendre X secondes dans AS2 & 3" 

... sans en utilisant setInterval ou clearInterval.

Les réponses affichées ci-dessus sont beaucoup plus rapides et faciles à utiliser. J'ai posté ceci ici, juste au cas où ...

Parfois, vous ne pourrez peut-être pas utiliser set/clearInterval ou d'autres méthodes basées sur des restrictions de développement. Voici un moyen de créer un délai sans utiliser ces méthodes.

AS2 - Si vous copiez/collez le code ci-dessous dans votre plan de montage, veillez à ajouter deux clips vidéo sur la scène, btnTest et btnGlowTest (inclure des noms d'occurrence semblables). Faites "btnGlowTest" plus grand, d’une couleur différente et derrière "btnTest" (pour simuler une lueur et un bouton, respectivement).

Compilez et vérifiez dans le panneau de sortie les instructions de trace pour voir comment le code fonctionne. Cliquez sur btnTest - btnGlowTest deviendra alors visible pendant toute la durée du délai (uniquement à des fins de représentation visuelle). 

J'ai un compte à rebours onEnterFrame ici aussi (démos arrêtant/commutant les minuteries). 

Si vous souhaitez que le délai/la lueur soit plus longue, augmentez le nombre glowGameTime. Modifiez les noms pour répondre à vos propres besoins et/ou appliquez la logique différemment.

var startTime:Number = 0;
var currentTime:Number = 0;
var mainTime:Number = 5;//"game" time on enter frame

var glowStartTime:Number = 0;
var glowCurrentTime:Number = 0;
var glowGameTime:Number = 1.8;//"delayed" time on press

btnGlowTest._visible = false;

this.onEnterFrame = TimerFunction;
startTime = getTimer();

function TimerFunction()
{   
    currentTime = getTimer();   

    var timeLeft:Number = mainTime - ((currentTime - startTime)/1000);

    timeLeft = Math.floor(timeLeft);    
    trace("timeLeft = " + timeLeft);

    if(timeLeft <= 0)
    {
        trace("time's up...3 bucks off");
        //...do stuff here
        btnGlowTest._visible = false;//just for show
        btnTest._visible = false;//just for show
        StopTime();
    }
}

function glowTimerFunction()
{   
    glowCurrentTime = getTimer();   

    var glowTimeLeft:Number = glowGameTime - ((glowCurrentTime - glowStartTime)/1000);  

    glowTimeLeft = Math.floor(glowTimeLeft);    
    //trace("glowTimeleft = " + glowTimeLeft);

    if(glowTimeLeft <= 0)
    {
        trace("TIME DELAY COMPLETE!");
        //...do stuff here
        btnGlowTest._visible = false;//just for show
        btnTest._visible = false;//just for show
        StopTime();
    }
}

btnTest.onPress = function()
{
    trace("onPress");
    btnGlowTest._visible = true;
    StopTime(); 
    GlowTime();
}

function GlowTime()
{
    trace("GlowTime Function"); 
    this.onEnterFrame = glowTimerFunction;  
    glowStartTime = getTimer();
}

function StopTime()
{
    trace(">>--StopTime--<<");
    delete this.onEnterFrame;   
}

AS3 - Voici le code de la configuration ci-dessus pour s'exécuter en AS3. Il existe différentes manières d'obtenir des résultats similaires, mais en fonction de la portée du projet, ce sont les méthodes qui ont été utilisées pour que les choses fonctionnent correctement. 

Si vous copiez/collez le code ci-dessous dans votre plan de montage chronologique, veillez à ajouter deux clips vidéo à la scène, btnTest et btnGlowTest (inclure des noms d'instance similaires). Faites "btnGlowTest" plus grand, d’une couleur différente et derrière "btnTest" (pour simuler une lueur et un bouton, respectivement).

Compilez et vérifiez dans le panneau de sortie les instructions de trace pour voir comment le code fonctionne. Cliquez sur btnTest - btnGlowTest deviendra alors visible pendant toute la durée du délai (uniquement à des fins de représentation visuelle). 

Si vous souhaitez que le délai/la lueur soit plus longue, augmentez le nombre GlowTimer:Timer (actuellement réglé sur 950). Modifiez les noms pour répondre à vos propres besoins et/ou appliquez la logique différemment. 

import flash.events.MouseEvent;
import flash.utils.Timer;
import flash.events.TimerEvent;

var startTime:Number = 0;
var currentTime:Number = 0;
var gameTime:Number = 4;//"game" time on enter frame

var GlowTimer:Timer = new Timer(950,0);//"delayed" time on press

btnGlowTest.visible = false;

GlowTimer.addEventListener(TimerEvent.TIMER, GlowTimeListener, false, 0, true);
btnTest.addEventListener(MouseEvent.MOUSE_DOWN, btnTestPressed, false, 0, true);
addEventListener(Event.ENTER_FRAME,TimerFunction, false, 0, true);

startTime = getTimer();

function TimerFunction(event:Event)
{   
    currentTime = getTimer();

    var timeLeft:Number = gameTime - ((currentTime - startTime)/1000);  

    timeLeft = Math.floor(timeLeft);
    trace("timeLeft = " + timeLeft);

    if(timeLeft <= 0)
    {
        trace("time's up, 3 bucks off");
        StopTime();
    }   
}

function GlowTimeListener (e:TimerEvent):void
{
    trace("TIME DELAY COMPLETE!");      
    StopTime();
}

function btnTestPressed(e:MouseEvent)
{   
    trace("PRESSED");       
    removeEventListener(Event.ENTER_FRAME, TimerFunction);
    btnGlowTest.visible = true;
    GlowTimer.start();
}

function StopTime()
{
    trace(">>--Stop Time--<<");
    btnGlowTest.visible = false;//just for show
    btnTest.visible = false;//just for show
    GlowTimer.stop();
    removeEventListener(TimerEvent.TIMER, GlowTimeListener);
    removeEventListener(Event.ENTER_FRAME, TimerFunction);
}
0
CrabMan