Neko et haxe.Timer.delayed ()

Question

Comme tous les développeurs Haxe le savent, vous pouvez utiliser haxe.Timer.delayed () pour retarder un appel de fonction pendant un certain temps. Mais cette fonction n'existe pas du tout pour Neko. Existe-t-il un moyen d’obtenir les mêmes résultats?

Answer 1

Je dois d'abord vérifier mais

function delayed(f, time) {
   neko.vm.Thread.create(function() {
       neko.Sys.sleep(time);
       f();
   });
}

pourrait être la chose la plus proche possible. Le seul inconvénient est que l'application devient multithread, ce qui pourrait entraîner de graves problèmes.

Answer 2

J'ai pensé à votre problème et je pense que le meilleur moyen est de créer votre propre classe Timer pour Neko. J'ai créé un cours de minuterie pour vous:

NekoTimer.hx

package;
import neko.Sys;

    class NekoTimer 
    {
    private static var threadActive:Bool = false;
    private static var timersList:Array<TimerInfo> = new Array<TimerInfo>();
    private static var timerInterval:Float = 0.1;

    public static function addTimer(interval:Int, callMethod:Void->Void):Int
    {
        //setup timer thread if not yet active
        if (!threadActive) setupTimerThread();

        //add the given timer
        return timersList.push(new TimerInfo(interval, callMethod, Sys.time() * 1000)) - 1;
    }

    public static function delTimer(id:Int):Void
    {
        timersList.splice(id, 1);
    }

    private static function setupTimerThread():Void
    {
        threadActive = true;
        neko.vm.Thread.create(function() {
            while (true) {
                Sys.sleep(timerInterval);
                for (timer in timersList) {
                    if (Sys.time() * 1000 - timer.lastCallTimestamp >= timer.interval) {
                        timer.callMethod();
                        timer.lastCallTimestamp = Sys.time() * 1000;
                    }
                }
            }
        });
    }
}

private class TimerInfo
{
    public var interval:Int;
    public var callMethod:Void->Void;
    public var lastCallTimestamp:Float;

    public function new(interval:Int, callMethod:Void->Void, lastCallTimestamp:Float) {
        this.interval = interval;
        this.callMethod = callMethod;
        this.lastCallTimestamp = lastCallTimestamp;
    }
}

Appelez ça comme ça:

package ;

import neko.Lib;

class Main 
{
    private var timerId:Int;

    public function new()
    {
        trace("setting up timer...");
        timerId = NekoTimer.addTimer(5000, timerCallback);
        trace(timerId);

        //idle main app
        while (true) { }
    }

    private function timerCallback():Void
    {
        trace("it's now 5 seconds later");
        NekoTimer.delTimer(timerId);
        trace("removed timer");
    }

    //neko constructor
    static function main() 
    {
        new Main();
    }
}

L’espoir que cela aide.

Remarque: celui-ci a une précision de 100 ms. Vous pouvez l'augmenter en diminuant le paramètre timerInterval.

Answer 3

J'ai aussi utilisé le cours et j'ai trouvé un problème. Parce qu’il n’est pas complètement en temps réel, il dort l’intervalle, appelle la fonction et dort à nouveau l’intervalle. Ainsi, en fonction de la durée de votre fonction, la vitesse est plus ou moins rapide.

Je l'ai résolu en remplaçant la ligne 39 comme suit:

//timer.lastCallTimestamp = Sys.time() * 1000;
timer.lastCallTimestamp = timer.lastCallTimestamp + timer.interval;

Answer 4

Oui, je ne sais rien à part ce que vous mentionnez dans votre première réponse. Sous Linux, vous pouvez utiliser SIGALARM - mais cela n’a pas l’air banal, du code C pur à 100%, et doit être manipulé avec le plus grand soin afin d’éviter le crash de la machine virtuelle.