Boucle infinie Unique ou Multiples ??

littlekitykat

Coucou les petits chats,

Depuis que je code sur scratch j'ai toujours essayé de ne faire qu'une seule boucle infinie dans un “lutin” et d'envoyer des messages qui permettent de donner un top a des moments clefs. Mais en regardant d'autres projets qui fonctionne parfaitement , je m'aperçois que certaines personnes utilisent plusieurs boucles infinies en // et jouent avec les variables , au lieu de lancer des messages .

quand le drapeau vert pressé
répéter indéfiniment
envoyer à tous [ Jouer le son 1]
envoyer à tous [ Orienter le lutin voiture vers Angle]
envoyer à tous [ ...]
envoyer à tous [ ...]
end

ou bien :

quand le drapeau vert pressé
répéter indéfiniment
si <[testLutin1] = [1]> alors
jouer le son [ crash] jusqu'au bout
end
end

quand le drapeau vert pressé
répéter indéfiniment
si <[testLutin2] = [1]> alors
s'orienter vers (Angle)
end
end

J'aurais voulu savoir ce qui est le plus rapide ( en temps de calculs ) selon vous . et si vous aviez même des examples pour illustrer ?
En effet pour mon test Speedway je suis un peu a la recherche d'optimisation

Idem pour Air strike qui a une fâcheuse tendance a perde son framerate lorsque les hélicoptere apparaissent …. :-/

Merci

Last edited by littlekitykat (June 1, 2018 09:40:20)

Quelques projets en cours !!

____

mattdo66

avoir plusieurs boucles ne ralentis pas (ou très peu) scratch
par contre pour les stylo utilise une fonction avec l’option sans rafraîchissement de l’écran ça accélère vraiment Scratch (genre x10)

Last edited by mattdo66 (June 1, 2018 11:58:22)

bidulule

Perso j'aime pas trop les messages. Je trouve que ça fait pas bon ménage avec les blocs violets. Du coup je préfère les variables ^^

SBissay

Les messages, ça crée vite de gros soucis avec les blocs à exécuter sans rafraîchissement de l'écran, donc j'ai tendance à penser qu'une programmation “classique”, avec appel à des fonctions, est plus efficace.

Quant au problèmes de boucles parallèles : la différence de temps d'exécution entre une seule boucle faisant tout et 2 boucles travaillant en parallèle n'est pas sensible. C'est encore une fois personnel, mais je préfère une boucle unique parce que c'est plus facile à débugger et surtout moins dangereux en terme de conflits potentiels.

Generative art : Pivot : Sudoku :

littlekitykat

Donc en gros , c'est plus une question de feeling et de choix personnels que vraiment une question d'optimisation.

Quelques projets en cours !!

____

bidulule

littlekitykat wrote:
Donc en gros , c'est plus une question de feeling et de choix personnels que vraiment une question d'optimisation.

Ouaip à part le truc de mêler messages et fonctions. J'avais essayé un fois et ça lagait sévère

link-potter

J'ai pas compris c'est plus lent quand on utilise les messages ? Parce que le projet que je fais en ce moment , j'utilise pas mal de messages mais pourtant y a pas de bug

The Conspiracy | My quiz on Harry Potter | My profil | My strange generator

littlekitykat

Je ne sais pas si c'est plus lent . C'était la question de départ. Mais il semblerait que non.

Quelques projets en cours !!

____

SBissay

Si : les messages ne cohabitent pas avec l'option “exécuter sans rafraîchissement de l'écran”. Du coup, pour un projet “pen”, ça devient forcément plus lent.

Generative art : Pivot : Sudoku :

littlekitykat

Oui, ok si tu passes les messages dans les blocs sans rafraîchissement. Mais ct pas le but de ma question.

Quelques projets en cours !!

____

frouvera

Hello,

1 boucle ou plusieurs : pas trop sensible en terme de traitement.
Message, versus variable..pas notable non plus.

Les messages j'aime bien pour rendre indépendant le lutin et le réutiliser dans d'autres projets.
L'utilisation de variable globales ( partager entre tous les lutins) c'est source de confilt si ils sont appelés par des lutins différents en même temps , donc ca peut provoquer des effets de bords et des lags.
Dommage que scratch n'affiche pas mieux de façon différenciée les variables locales au lutin et globales..

@+

link-potter

Moi perso j'utilise autant les deux dans quasiment tous mes projets

The Conspiracy | My quiz on Harry Potter | My profil | My strange generator

lieutenant_X

Ça dépend l'usage que tu en fait. Si tu veux démarrer un code avec un évenement, utilise les messages alors que si tu veux vérifier un paramètre (si un bouton est enfoncé par exemple), fait ça :
scripte du lutin du bouton :

quand ce lutin est cliqué
si <(état bouton) = [enfoncé]> alors 
mettre [état bouton v] à [relâché]
basculer sur costume [bouton relâché v]
sinon
mettre [état bouton v] à [enfoncé]
basculer sur costume [bouton enfoncé v]
end

le scripte pour vérifier l’état du bouton :

si <(état bouton) = [enfoncé]> alors 
dire [bouton enfoncé]
sinon
dire [bouton relâché]
end

programmeur amateur et passionné toujours prêt à aider. Pour découvrir mes projets et me soutenir : Mon profil.

si (tu aimes mes conseils(::motion)(::#ffffff)(::undefine)::variables) alors
Viens voir mes projets ::motion //Ils sont cools
end

“Demandez, et l'on vous donnera; cherchez, et vous trouverez; frappez, et l'on vous ouvrira.” Luc (11, 9)

Try5t4n

si <> alors

end

point towards ((3d::#999)+(100% pen::#125)+(games::#148)+(tests::#589)::custom)::hat pen
create::list

MATHEMATHICS

lieutenant_X

Try5t4n wrote:
si <> alors

end

@Try5t4n pourquoi tu as posté ça ?

programmeur amateur et passionné toujours prêt à aider. Pour découvrir mes projets et me soutenir : Mon profil.

si (tu aimes mes conseils(::motion)(::#ffffff)(::undefine)::variables) alors
Viens voir mes projets ::motion //Ils sont cools
end

“Demandez, et l'on vous donnera; cherchez, et vous trouverez; frappez, et l'on vous ouvrira.” Luc (11, 9)

littlekitykat

je vous explique plus ma question.

Jusqu’à présent j'utilisais 1 boucle unique dans mon MAIN en sachant que le CPU de scratch permet de passer 30 cycles / secondes et ainsi je synchronisais les autres lutins grâce a cette boucle, et elle ressemblait plus a cela :

répéter indéfiniment
envoyer à tous [ CheckKeyboard]
envoyer à tous [ SetCalcul]
envoyer à tous [ Checkcollision]
envoyer à tous [ DoAnimation]
envoyer à tous [ Draw]
end

En sachant que les variables et autres block sont gérés par les lutins. de cette maniére

quand je reçois [CheckKeyboard]
si <touche [gauche] pressée?> alors 
mettre [ Direction] à [left]
sinon
mettre [ Direction] à [right]
end

Et donc cela permet de gérer chaque événement a des moments précis du code et donc d’être trés précis. Je pensais que c'était la façon la plus rapide.

Et puis en testant pour https://scratch.mit.edu/projects/221108308/ je me suis demandée si en faisant 2 boucles infinies en même temps est ce qu'on multiplie le nombre de cycle par 2 ?? 3 boucle par 3 …. etc !! Ou est ce que le cpu ne fait pas les opérations en // mais une boucle puis une autre ??

Et du coup cela change beaucoup la façon de programmer. Quand dans la première solution je dois tout caser tous les calculs dans une frame. et je sais que je ne pourrais pas faire plus de 30 cycles /sec la seconde aurait permis de multiplier les nombre de calculs x2.

Last edited by littlekitykat (June 20, 2018 14:33:05)

Quelques projets en cours !!

____

CatOnTreeStudio

J'ai fait un petit essai 1 boucle simple pour effectuer 6 000 000 additions, ou alors faire 3 boucles en même temps de 2 000 000 puis on additione !!

https://scratch.mit.edu/projects/229948458/

On peu donc voir que les 3 boucles sont plus rapides qu'une simple boucle !!

Last edited by CatOnTreeStudio (June 20, 2018 18:17:48)

Discuss Scratch