Cette sacrée fonction repeatedly execute !

Bonjour !

J'ai une question à propos de cette sacrée fonction repeatedly execute !

Son existence est très réjouissante, car elle permet de faire beaucoup de choses, et ça c'est super. Seulement, je me demande à quel point on peut lui demander des choses sans avoir peur d'alourdir la fluidité du jeu.

Par exemple, j'utilise cette fonction dans le "repeatedly execute always" du global script (donc cette fonction est appellée tout le temps même quand le jeu est en pause) :

Code:

function repeatedly_execute_always()
{
  GUIControl *bouton=GUIControl.GetAtScreenXY(mouse.x, mouse.y);
  GUI *guicheck=GUI.GetAtScreenXY(mouse.x, mouse.y);
  if (bouton != null && bouton.AsButton!=null && bouton.AsButton.Text != "New Button")
  {
    for (int i=0 ; i < bouton.OwningGUI.ControlCount ; i++)
    {
      if (bouton.OwningGUI.Controls[i].AsButton != null) bouton.OwningGUI.Controls[i].AsButton.TextColor=0;
    }
    bouton.AsButton.TextColor=30;
  }
  else if (guicheck!=null)
  {
    for (int f=0 ; f < guicheck.ControlCount ; f++)
    {
      if (guicheck.Controls[f].AsButton != null) guicheck.Controls[f].AsButton.TextColor=0;
    }
  }
}

Cette fonction me permet d'avoir des boutons de GUI dont le texte se colore en blanc lorsque la souris passe dessus, et redeviennent noirs lorsque la souris est ailleurs.

Dans certains cas rares, certains boutons restent blancs car cette fonction ne marche que pour le GUI en cours d'affichage. Des fois, j'ai plusieurs GUI affichés de différentes tailles, et si par exemple en cliquant sur un bouton un des GUI disparaît, le bouton sur lequel j'ai cliqué restera avec le texte blanc car il m'aurait fallu repasser sur son GUI pour qu'il redevienne noir.

Du coup, je m'imagine augmenter cette fonction en faisant que lorsqu'on n'est pas avec la souris sur un bouton de GUI, cela va scanner tous les boutons de tous les GUI de mon jeu et leur rendre la couleur du texte noire.

Mais faire une telle chose serait peut-être fatale pour la fluidité ?

Ou alors, faire un système où la fonction n'est appellée que les n cycles de jeu, pour qu'elle ne fonctionne pas non stop et pour soulager l'ordi qui travaillera sans cesse ?

En clair, je me demande à quel point on peut demander des choses complexes dans ce repeteadly execute. C'est valable pour mon problème de texte de GUI noir ou blanc, mais à terme, je pourrais avoir envie de l'utiliser pour autre chose, mais je voudrais pas que le jeu rame sur des ordis un peu lents...

Une façon de tester ça est d'essayer sur un programme test analogue en passant le débit du programme à 1000 fps (l'exécution d'AGS reste assez lente de base donc tu ne devrais pas dépasser les 200-300 fps quoi qu'il arrive) et tester combien de boucles peuvent être exécuter à la seconde, où à partir de quand il y a des chutes. Ce qui peut être un peu lent n'est pas tant l'exécution du code que les mises à jour graphiques. Néanmoins j'ai travaillé sur un programme où il y avait parfois des milliers de boucles par cycle avec des DrawingSurface qui s'exécutaient pixel par pixel et ça prenait du temps pour passer sous les 40 fps (le programme se complexifiait au fur et à mesure qu'il tournait).

Mais bon en gros ça devrait aller parce que si tu fais des trucs du genre

Code:

if (bouton.AsButton.TextColor != 30) bouton.AsButton.TextColor = 30

finalement la mise à jour graphique n'interviendra qu'a des moments précis donc ça ira.
Et même si tu le fais en bourrinant à chaque cycle, à moins que tu aies des centaines de boutons à la fois, ça ira, surtout si tu n'as pas d'animations par ailleurs.

Je n'ai pas tout suivi ce que tu as fait donc peut-être que je visualise mal, mais a priori ça ne m'inquiète pas trop. Si ça devient gênant alors il faut ruser pour optimiser le truc et éviter les modifications intempestives (et inutiles), comme dans mon exemple précédent.

Merci Valoulef pour ta réponse !

OK je comprends mieux. C'est donc plus les mises à jour graphiques qui demandent du boulot aux programmes. Les lignes de code, les boucles et tout cela, il les lit à une telle vitesse qu'on peut lui en faire gober avant qu'il rechigne !

Du coup, j'ai revu ma fonction, et précisé les conditions que la mise à jour graphique n'est faite que si la couleur n'est pas la bonne :

Code:

function repeatedly_execute_always()
{
  GUIControl *bouton=GUIControl.GetAtScreenXY(mouse.x, mouse.y);
  GUI *guicheck=GUI.GetAtScreenXY(mouse.x, mouse.y);
  if (bouton != null && bouton.AsButton!=null && bouton.AsButton.Text != "New Button") // C'est un bouton et il a du texte
  {
    for (int i=0 ; i < bouton.OwningGUI.ControlCount ; i++)
    {
      if (bouton.OwningGUI.Controls[i].AsButton != null && bouton.OwningGUI.Controls[i].AsButton.TextColor==30) bouton.OwningGUI.Controls[i].AsButton.TextColor=0;
    }
    bouton.AsButton.TextColor=30;
  }
  else if (guicheck!=null) // Si on n'est pas sur un bouton mais qu'on est sur un GUI on rend tous les boutons de ce GUI qui ont un texte blanc en noir
  {
    for (int f=0 ; f < guicheck.ControlCount ; f++)
    {
      if (guicheck.Controls[f].AsButton != null && guicheck.Controls[f].AsButton.TextColor==30) guicheck.Controls[f].AsButton.TextColor=0;
    }
  }
  else if (guicheck==null) // Si on n'est pas sur un GUI, alors on scanne tous les GUI et on mets les textes des boutons blancs en noir
  {
    for (int x=0; x < Game.GUICount ; x++)
    {
      for (int y=0 ; y < gui[x].ControlCount ; y++)
      {
        if (gui[x].Controls[y].AsButton != null && gui[x].Controls[y].AsButton.TextColor==30) gui[x].Controls[y].AsButton.TextColor=0;
      }
    }
  }
}

Je ne note pas de ralentissement, donc je pense que ça doit aller ! Mais effectivement c'est une bonne idée de préciser les conditions pour qu'on minimise les choses à faire lorsqu'elles sont inutiles (par exemple, changer la couleur du texte en noir quand elle est déjà en noir...!)

Oui là a priori il faudrait vraiment que tu aies des milliers de boutons pour que ça pose problème je pense (mais je ne connais pas le temps que met AGS à traiter le design des boutons).

Baguettator a écrit:

Les lignes de code, les boucles et tout cela, il les lit à une telle vitesse qu'on peut lui en faire gober avant qu'il rechigne !

Pour donner un ordre d'idée très approximatif, lors de mes tests j'ai eu de mémoire du 400 000 à 600 000 boucles* par seconde qui contenaient quelques calculs de int (peut-être une dizaine de lignes par boucle, je ne sais plus trop) sans intervention graphique. C'est vague parce que ça dépend de beaucoup de facteurs (la puissance du processeur, le contenu des boucles, le nombre de calculs...) mais bon ça peut donner une petite idée. Ça laisse quand même une bonne marge.

*je parle évidemment de boucles while ou for, pas du nombre d'exécutions du repeatedly_execute qui est plafonné à 1000/s.

Oulaa... Oui j'ai de la marge

Merci pour les explications !