Existe-t-il un moyen de gérer plusieurs compteurs avec Lingo? En effet,
chaque fois qu'on utlise StartTimer, cette instruction remet à zéro tout
compteur alors en cours.
Cette action est irreversible, confirmez la suppression du commentaire ?
Signaler le commentaire
Veuillez sélectionner un problème
Nudité
Violence
Harcèlement
Fraude
Vente illégale
Discours haineux
Terrorisme
Autre
bubarnet
> Existe-t-il un moyen de gérer plusieurs compteurs avec Lingo? En
effet,
chaque fois qu'on utlise StartTimer, cette instruction remet à zéro tout compteur alors en cours.
Pourquoi ne pas créer ton propre système de compteur, beaucoup plus souple.
Tu crèes un objet (je le donne de tête, à vérifier) : property plID,pID
on new me plID=[] pID=0 (the actorlist).add(me)
return me end
on destructeur me (the actorlist).deleteone(me) end
on register me,obj,fonc,time pID=pID+1 symb=symbol("ID"&pID) plID.add(symb,[#obj:obj,#fonc:fonc,#starttime:the milliseconds,#intervalle:time]) return symb end
on free me,ID plID.deleteprop(symb) end
on stepframe me ml=the milliseconds repeat with elem in plID if elem.starttime+elem.intervalle<ml then call(elem.fonc,elem.obj) elem.startime=ml end if end repeat end
--gotimer : variable global contenant l'instance de l'objet gotimer=script("objet_timer").new() --Ensuite chaque script d'objet ou comportement qui a besoin d'un compteur, s'enregistre : --#steptime : le symbole de la fonction qui recevra le message --10000 : nb de milliseconds pour recevoir le message pID=gotimer.register(me,#steptime,10000) --pID contient un identifiant de ce compteur --le comportement/objet devra avoir une fonction (ici on steptime me) qui sera appelée toutes les 10000 millisecondes. --si le script n'a plus besoin du compteur, il le libère gotimer.free(pID) --A la fin du programme, tu détruis proprement l'objet timer gotimer.destructeur() gotimer=VOID
Les avantages : - multiples compteurs pour tous les comportements/objets - un même script peut utiliser une infinité de compteur (il suffit de donner le nom de plusieurs fonctions dans un même script)
Désavantage : - c'est un petit peu moins précis que les appels internes au timer de director. La différence est vraiment négligeable dans la plupart des cas
-- Bubar
> Existe-t-il un moyen de gérer plusieurs compteurs avec Lingo? En
effet,
chaque fois qu'on utlise StartTimer, cette instruction remet à zéro tout
compteur alors en cours.
Pourquoi ne pas créer ton propre système de compteur, beaucoup plus souple.
Tu crèes un objet (je le donne de tête, à vérifier) :
property plID,pID
on new me
plID=[]
pID=0
(the actorlist).add(me)
return me
end
on destructeur me
(the actorlist).deleteone(me)
end
on register me,obj,fonc,time
pID=pID+1
symb=symbol("ID"&pID)
plID.add(symb,[#obj:obj,#fonc:fonc,#starttime:the
milliseconds,#intervalle:time])
return symb
end
on free me,ID
plID.deleteprop(symb)
end
on stepframe me
ml=the milliseconds
repeat with elem in plID
if elem.starttime+elem.intervalle<ml then
call(elem.fonc,elem.obj)
elem.startime=ml
end if
end repeat
end
--gotimer : variable global contenant l'instance de l'objet
gotimer=script("objet_timer").new()
--Ensuite chaque script d'objet ou comportement qui a besoin d'un compteur,
s'enregistre :
--#steptime : le symbole de la fonction qui recevra le message
--10000 : nb de milliseconds pour recevoir le message
pID=gotimer.register(me,#steptime,10000)
--pID contient un identifiant de ce compteur
--le comportement/objet devra avoir une fonction (ici on steptime me) qui
sera appelée toutes les 10000 millisecondes.
--si le script n'a plus besoin du compteur, il le libère
gotimer.free(pID)
--A la fin du programme, tu détruis proprement l'objet timer
gotimer.destructeur()
gotimer=VOID
Les avantages :
- multiples compteurs pour tous les comportements/objets
- un même script peut utiliser une infinité de compteur (il suffit de donner
le nom de plusieurs fonctions dans un même script)
Désavantage :
- c'est un petit peu moins précis que les appels internes au timer de
director. La différence est vraiment négligeable dans la plupart des cas
> Existe-t-il un moyen de gérer plusieurs compteurs avec Lingo? En
effet,
chaque fois qu'on utlise StartTimer, cette instruction remet à zéro tout compteur alors en cours.
Pourquoi ne pas créer ton propre système de compteur, beaucoup plus souple.
Tu crèes un objet (je le donne de tête, à vérifier) : property plID,pID
on new me plID=[] pID=0 (the actorlist).add(me)
return me end
on destructeur me (the actorlist).deleteone(me) end
on register me,obj,fonc,time pID=pID+1 symb=symbol("ID"&pID) plID.add(symb,[#obj:obj,#fonc:fonc,#starttime:the milliseconds,#intervalle:time]) return symb end
on free me,ID plID.deleteprop(symb) end
on stepframe me ml=the milliseconds repeat with elem in plID if elem.starttime+elem.intervalle<ml then call(elem.fonc,elem.obj) elem.startime=ml end if end repeat end
--gotimer : variable global contenant l'instance de l'objet gotimer=script("objet_timer").new() --Ensuite chaque script d'objet ou comportement qui a besoin d'un compteur, s'enregistre : --#steptime : le symbole de la fonction qui recevra le message --10000 : nb de milliseconds pour recevoir le message pID=gotimer.register(me,#steptime,10000) --pID contient un identifiant de ce compteur --le comportement/objet devra avoir une fonction (ici on steptime me) qui sera appelée toutes les 10000 millisecondes. --si le script n'a plus besoin du compteur, il le libère gotimer.free(pID) --A la fin du programme, tu détruis proprement l'objet timer gotimer.destructeur() gotimer=VOID
Les avantages : - multiples compteurs pour tous les comportements/objets - un même script peut utiliser une infinité de compteur (il suffit de donner le nom de plusieurs fonctions dans un même script)
Désavantage : - c'est un petit peu moins précis que les appels internes au timer de director. La différence est vraiment négligeable dans la plupart des cas
-- Bubar
Anthony
Merci pour ta méthode...
Anthony
"bubarnet" a écrit dans le message de news:bqfibj$7pj$
> Existe-t-il un moyen de gérer plusieurs compteurs avec Lingo? En effet, > chaque fois qu'on utlise StartTimer, cette instruction remet à zéro tout > compteur alors en cours.
Pourquoi ne pas créer ton propre système de compteur, beaucoup plus
souple.
Tu crèes un objet (je le donne de tête, à vérifier) : property plID,pID
on new me plID=[] pID=0 (the actorlist).add(me)
return me end
on destructeur me (the actorlist).deleteone(me) end
on register me,obj,fonc,time pID=pID+1 symb=symbol("ID"&pID) plID.add(symb,[#obj:obj,#fonc:fonc,#starttime:the milliseconds,#intervalle:time]) return symb end
on free me,ID plID.deleteprop(symb) end
on stepframe me ml=the milliseconds repeat with elem in plID if elem.starttime+elem.intervalle<ml then call(elem.fonc,elem.obj) elem.startime=ml end if end repeat end
--gotimer : variable global contenant l'instance de l'objet gotimer=script("objet_timer").new() --Ensuite chaque script d'objet ou comportement qui a besoin d'un
compteur,
s'enregistre : --#steptime : le symbole de la fonction qui recevra le message --10000 : nb de milliseconds pour recevoir le message pID=gotimer.register(me,#steptime,10000) --pID contient un identifiant de ce compteur --le comportement/objet devra avoir une fonction (ici on steptime me) qui sera appelée toutes les 10000 millisecondes. --si le script n'a plus besoin du compteur, il le libère gotimer.free(pID) --A la fin du programme, tu détruis proprement l'objet timer gotimer.destructeur() gotimer=VOID
Les avantages : - multiples compteurs pour tous les comportements/objets - un même script peut utiliser une infinité de compteur (il suffit de
donner
le nom de plusieurs fonctions dans un même script)
Désavantage : - c'est un petit peu moins précis que les appels internes au timer de director. La différence est vraiment négligeable dans la plupart des cas
-- Bubar
Merci pour ta méthode...
Anthony
"bubarnet" <bubarnet_SPAM_DE_M@yahoo.fr> a écrit dans le message de
news:bqfibj$7pj$1@forums.macromedia.com...
> Existe-t-il un moyen de gérer plusieurs compteurs avec Lingo? En
effet,
> chaque fois qu'on utlise StartTimer, cette instruction remet à zéro tout
> compteur alors en cours.
Pourquoi ne pas créer ton propre système de compteur, beaucoup plus
souple.
Tu crèes un objet (je le donne de tête, à vérifier) :
property plID,pID
on new me
plID=[]
pID=0
(the actorlist).add(me)
return me
end
on destructeur me
(the actorlist).deleteone(me)
end
on register me,obj,fonc,time
pID=pID+1
symb=symbol("ID"&pID)
plID.add(symb,[#obj:obj,#fonc:fonc,#starttime:the
milliseconds,#intervalle:time])
return symb
end
on free me,ID
plID.deleteprop(symb)
end
on stepframe me
ml=the milliseconds
repeat with elem in plID
if elem.starttime+elem.intervalle<ml then
call(elem.fonc,elem.obj)
elem.startime=ml
end if
end repeat
end
--gotimer : variable global contenant l'instance de l'objet
gotimer=script("objet_timer").new()
--Ensuite chaque script d'objet ou comportement qui a besoin d'un
compteur,
s'enregistre :
--#steptime : le symbole de la fonction qui recevra le message
--10000 : nb de milliseconds pour recevoir le message
pID=gotimer.register(me,#steptime,10000)
--pID contient un identifiant de ce compteur
--le comportement/objet devra avoir une fonction (ici on steptime me) qui
sera appelée toutes les 10000 millisecondes.
--si le script n'a plus besoin du compteur, il le libère
gotimer.free(pID)
--A la fin du programme, tu détruis proprement l'objet timer
gotimer.destructeur()
gotimer=VOID
Les avantages :
- multiples compteurs pour tous les comportements/objets
- un même script peut utiliser une infinité de compteur (il suffit de
donner
le nom de plusieurs fonctions dans un même script)
Désavantage :
- c'est un petit peu moins précis que les appels internes au timer de
director. La différence est vraiment négligeable dans la plupart des cas
"bubarnet" a écrit dans le message de news:bqfibj$7pj$
> Existe-t-il un moyen de gérer plusieurs compteurs avec Lingo? En effet, > chaque fois qu'on utlise StartTimer, cette instruction remet à zéro tout > compteur alors en cours.
Pourquoi ne pas créer ton propre système de compteur, beaucoup plus
souple.
Tu crèes un objet (je le donne de tête, à vérifier) : property plID,pID
on new me plID=[] pID=0 (the actorlist).add(me)
return me end
on destructeur me (the actorlist).deleteone(me) end
on register me,obj,fonc,time pID=pID+1 symb=symbol("ID"&pID) plID.add(symb,[#obj:obj,#fonc:fonc,#starttime:the milliseconds,#intervalle:time]) return symb end
on free me,ID plID.deleteprop(symb) end
on stepframe me ml=the milliseconds repeat with elem in plID if elem.starttime+elem.intervalle<ml then call(elem.fonc,elem.obj) elem.startime=ml end if end repeat end
--gotimer : variable global contenant l'instance de l'objet gotimer=script("objet_timer").new() --Ensuite chaque script d'objet ou comportement qui a besoin d'un
compteur,
s'enregistre : --#steptime : le symbole de la fonction qui recevra le message --10000 : nb de milliseconds pour recevoir le message pID=gotimer.register(me,#steptime,10000) --pID contient un identifiant de ce compteur --le comportement/objet devra avoir une fonction (ici on steptime me) qui sera appelée toutes les 10000 millisecondes. --si le script n'a plus besoin du compteur, il le libère gotimer.free(pID) --A la fin du programme, tu détruis proprement l'objet timer gotimer.destructeur() gotimer=VOID
Les avantages : - multiples compteurs pour tous les comportements/objets - un même script peut utiliser une infinité de compteur (il suffit de
donner
le nom de plusieurs fonctions dans un même script)
Désavantage : - c'est un petit peu moins précis que les appels internes au timer de director. La différence est vraiment négligeable dans la plupart des cas