Je crois que je programme trop mal les comptes à rebours en fait, j'ai besoin de votre aide svp

Par exemple : je veux afficher un message disons 5 secondes au dessus d'un joueur quand il appuie sur une touche.

Ok, je sais le faire parce que c'est très simple, mais comment le faire proprement ?

Mon joueur a entre autre une methode update (logique) et disons une methode render, qui renvoit son sprite.

Donc si je veux afficher un message, ce que je fais :
j'ai un boolean, quand il est à true j'affiche le message. (methode render)
Au moment où le joueur presse la touche, je passe le boolean à true. (methode update)
Puis, 5 secondes plus tard, je le passe à false.

Donc là ce que je fais en gros dans le methode update, c'est que j'ai un int que j'incrémente (en tenant compte du "décalage" delta) , et lorsque que les 5 secondes sont passées je passe le boolean à false, ce qui enlève le message.

Donc ça marche, mais imaginons maintenant que dans mon jeu y'a plein de phases comme ça où des trucs se déclenchent un certains temps.

à chaque fois je dois faire tout ce bazar d'utiliser des booleans et des timers à la main ? ça rend le code illisible à la longue.

Alors ce que j'ai fait c'est que j'ai une classe genre "nouveauMessage" qui a sa propre methode update et tout, mais ça reste moche je trouve, je suis persuadé qu'il existe des moyens plus simples.

Je peux pas simplement faire un Thread.sleep() parce que ça bloque toute la methode render..

Vous faîtes comment vous Vous utilisez des threads / forks ?

J'arrive à programmer à peu près ce que je veux en faisant plein de classes mais je suis persuadé qu'il y a plus simple, mais j'arrive à trouver la solution la plus propre / optimale.

Mais j'arrive pas* à trouver la solution

sacrebleu

Il est difficile de parler architecture sans un schema qui explicite un petit peu les concepts mis en place, les relations entre les classes, le cheminement des donnees entre les entites, etc.

Egalement, il n'y a pas de solution unique, donc il faut aussi connaitre tes contraintes pour pouvoir proposer une solution appropriee.

de facon general, il faut abstraire le concept de message qui reste afficher un temps donne pour que tout le code de gestion de ces messages soit unique. Faire un thread par compteur est tres certainement une connerie. Ce que je ferai est qu'a chaque etape du moteur de ton jeu (ou du rendu), j'appellerai une fonction sur tous les messages pour leur donner l'heure courante. Chaque message sait a quelle heure il doit ne plus etre afficher. Un message qui ne doit pas etre afficher passe son boolleen a faux et se retire du systeme de jeu.

Evidement, ca depend de l'architecture exacte de ton programme...

Normalement ceci doit etre passe dans la methode update si j'ai bien compris ton architecture. Tu dois la changer et passer le temps absolu de la boucle du jeu. Tu n'as plus ensuite qu'a en deduire le temps relatif de "visibilite" de ton message, et a incrementer ton petit compteur a chaque appel de update.

Une fois que tempRelatif > 5.0 tu n'as plus qu'a supprimer cet element graphique de la hierarchie et liberer la resource et tout ce que tu veux faire apres.

C'est comme ca que l'on fait dans 99% des jeux de base et de non-base.

Merci pour vos réponses, je faisais donc à priori la bonne technique

Il n'y pas de "bonne" technique, il y a plein de facon de proceder, en fonction de ses contraintes, du reste de l'architecture, du niveau d'abstraction souhaite, etc.

Un bon indicateur, c'est que si ca te parait brouillon, c'est que ca doit l'etre, et qu'il doit etre possible faire mieux.

Maintenant ce n'est pas ici qu'on trouvera facilement une reponse adaptee a un probleme specifique (le reste de ton projet), sans discuter en long en large et en travers des motivations de ton architectures.
Mais pour ameliorer tes connaissances dans ce domaine, et trouver des solutions par toi meme, je ne peux que te recommander de lire :

- Design Patterns: Elements of Reusable Object-Oriented Software
- Large Scale C++ Software Design (bcp du contenu est valable pour d'autres langages, au passage)

(il faudra que je lises ces bouquins un jour)

Je radote un peu a souvent les citer, mais ce sont de tres bonnes references

Toi tu développes avec Slick, non ?

Ça se voit tant que ça ?

Oui, bien joué

Merci pour les livres, je jetterais un oeil un de ces 4

Sinon, pour ton problème, une des solutions serait de donner à ton état un "conteneur de messages".

Si tu utilises Slick, il suffit que tu lui fasses implémenter Renderable pour lui donner une méthode draw.
La méthode draw() de ton container appelle la méthode draw() de tes messages.

Une fois ça fait, tu rempli ton conteneur de messages qui ont un temps d'apparition, un contenu, une position, etc...

Dans ta méthode update, tu incrémentes le temps d'apparition de tes messages via delta et tu traites leur disparition via le conteneur.

Une fois ça fait, tu affiches le conteneur dans ta méthode render().

Pourquoi tu code pas une classe timer (ou un struct) qui contient les infos necessaire, ensuite tu donne 1 timer par sprite (ou message, je sais pas comment tu gere).

Quand tu update() ton message tu va decrementer le timer par exemple, et quand il est à zero tu affiche plus.

Un truc genre:

void spawn(float timeOfLive)
{
this.timer = new Timer(timeOfLive);
}

if(timer.isAlive())
{
// vivant = affiche
render();
timer.decrement(delta);
}
else
{
// pas vivant
...
}

Enfin je sais pas comment ton code est construit mais ça doit pas être ingérable ton histoire