Salut

Sa faisait quelque temps que je n´avait plus posé de question.
Cette fois je reviens pour un petit probleme sur une fonction d´animation.

L´idée de base est de créer une fonction avec 4 arguments : un sdl_surface* de l´image, un int avec le nombre de sprites en longueur, un int avec le nombre de sprites en hauteur, et un int pour déterminer le temps ou l´on passera d´un sprite a l´autre (multiple de 20 ms plus précisement). Le problème étant justement sur ce dernier paramètre. Le reste est assez facile a faire, mais je ne vois pas comment gérer le temps.
J´ais deja une autre fonction qui renvoie 1 toute les 20ms, c´est pour sa que je pensais n´utiliser que des multiple de 20ms pour cette nouvelle fonction.
Mais je ne vois pas du tout comment gérer le temps sur chaque animation, ou plutôt le stocker. J´ais bien pensé faire un tableau avec une case propre a chaque animation (chaque case aura le multiple de 20ms qu´ils ont deja effectué jusqu´a atteindre celui demandé), mais pour sa, je devrais créer une case pour chaque animation potentielle, meme si elle ne se passera jamais, d´autant que je ne peux pas vraiment prévoir a l´avance combien il y en aura, et si le nombre dépasse mon tableau, je pense que le prog ne va pas apprécier.

Je pense qu´il doit bien exister une solution plus propre et plus simple, mais je ne trouve pas. Donc quelqu´un qui a compris mes explications pourrait-il me donner une voie a suivre?

Merci d´avance

Ce que tu peux faire, c´est lancer un rafraichissement de l´affichage toutes les 2ms par exemple, et dans la fonction d´affichage du sprite : vérifier si au moins 20 ms se sont écoulées depuis le dernier changement d´image, et changer d´image le cas échéant.

Il existe des fonctions de la SDL pour connaitre le temps ou lancer un timer.

En fait j´ais deja fait une fonction pour rafraichir l´image toutes les 20 ms (avec windows.h).
Ce que tu propose, c´est justement ce que je pensais faire, mais c´est pas vraiment réalisable dans la mesure ou s´il y a plusieurs animations, il faudra créer autant de variable pour savoir ou en sont chaques animation dans le décompte du temps. Comme je ne peux pas savoir a l´avance combien il y aura d´animation a gérer, meme en faisant un tableau, je pense que je risque un plantage.

C´est la dessus que je demandais de l´aide en fait.

En tout cas merci pour la reponse

Arf, oui, je voyais une conception objet de la chose, chaque indication de temps étant liée à un sprite instancié il n´y a pas de capacité à dépasser (sinon la mémoire de la machine, mais bon). Je ne connais pas bien les structures de données en C (j´imagine que c´est le langage que tu utilises), mais s´il y a un tableau dynamique/une liste ça pourrait être la solution à ton problème.
Bien conçu, tu n´as pas à répéter les SDL_surface en mémoire (c´est ça qui prend de la place) donc il te faut gérer par sprite animé: un int pour le temps et... boarf un byte pour ton animation, je doute que tu aies plus de 256 images par sprite. Ça fait quoi? 5 octets... Stocker "Bonjour" prend plus de place.

Regardes du côté des structures allouées dynamiquement, ça te permettra de dépasser la contrainte t´espace d´un tableau fixe.

Tu as des structure en C (des classes sans fonction) qui te permette de faire cela.

Sans rentrer dans le détail, j´utilise des variables pour enregistrer des chaînes de caractères.

En simplifiant :
1 variable qui gère le numéro de l´animation,
1 variable qui gère le temps.

Je fais tourner mes jeux en 60 images par secondes, je compte donc toutes les temporisations par rapport aux boucles du jeu.

Var1="00 01 02 03 02 01 00"
var2="03 08 03 04 04 05 02"

Je récupère les information en utilisant "Trim" (c´est du basic, mais en C ça doit être la même chose), et je convertis en entier.

Donc dans ce cas :
animation 0 a l´image 00 et une temporisation de 03,
animation 1 a l´image 01 et une temporisation de 08,
etc.

J´espère que c´est clair

Kaoron "Bien conçu, tu n´as pas à répéter les SDL_surface en mémoire" Tu parles de quoi exactement quand tu dis ça, j´ais du mal a comprendre.

Godrik comme je débute je ne connais pas trop les structures, mais bon, faut bien avancer :d . Si j´ais un problème dessus je reviendrais

reno_ La par contre j´ais carrément du mal a comprendre ce que tu veux faire. Tu pourrais réexpliquer?

Merci a tous

Ha, je savais que ce n´était pas clair... en même temps je m´explique mal !

Pour les chaines, c´est du Mid(), pas du Trim() ;)

Exemple de code :

1 - dessiner une image :

drawimage image,positionX,positionY,animation

2 - desssiner une image à chaque boucle de jeu :

Var1$="00 01 02 03 02 01 00"
----
image=mid$(Var1$,1,3)
//mid$=récupère variable, le point de départ dans la chaine, et la longueur.

drawimage image,positionX,positionY,image

3 - dessiner image qui change à chaque boucle de jeu :

Var1$="00 01 02 03 02 01 00"
V=1
----

image=mid$(Var1$,V,3)

drawimage image,positionX,positionY,image

v=(v+3)
if v>len(Var1$) then v=1
//len retourne le nombre de caractère dans une variable de chaine

Là c´est le principe de base. C´est plus clair ?

"Bien conçu, tu n´as pas à répéter les SDL_surface en mémoire" Tu parles de quoi exactement quand tu dis ça, j´ais du mal a comprendre.
J´évoquais une de mes erreurs de débutant, qui consistait à créér un sdl_surface par sprite instancié. Après j´ai appris les références...

Bref, pour la solution que tu avais trouvée, tu peux créer un Struct par animation contenant :
Une référence vers l´image utilisée. (SDL_Surface)
Une variable contenant le numéro de la portion d´image actuellement affichée
Une variable contenant la date du dernier changement d´image

C´est ce struct que tu stockeras dans un tableau dynamique/une liste/autre chose. Tant que tu as une structure de données dynamique, tu n´as pas à craindre d´avoir trop de sprites... la machine ramera à l´affichage avant que tu atteignes ses limites en mémoire.

La solution de reno semble avoir à peu près le même fonctionnement (une granularité de temps générale et un rafraichissement spécifique pour chaque animation), mais permet une gestion un peu plus fine des temporisations en associant une sous-image à sa durée d´affichage dans l´animation. (Désolé si je me trompe) Je ne suis pas sur que c´était ce que tu cherchais.

Si tu as des difficultés avec les structures et la gestion mémoire, documente toi dessus avant d´entreprendre quelque chose.

Salut!
en fait ton premier post n´est pas très claire, tu dis vouloir une fonction... alors qu´apparament tu veux une struct

struct Animation
{
SDL_Surface *sprites;
int row_count;
int col_count;
float time;
}

?

Ensuite quand tu veux jouer l´animation tu fait une structure player :
struct AnimationPlayer
{
Animation *anim;
int current_frame;
float time_on_current_frame;
}

a chaque update du jeu tu appelle la fonction
AnimationPlayerUpdate(struct AnimationPlayer *player, float dt)
{
player->time_on_current_frame += dt;
if(player->time_on_current_frame > player->anim->time) {
player->current_frame++;
if(player->current_frame > frame_count etc... (pour eviter d´aller sur un sprite qui n´existe pas) ...
player->time_on_current_frame -= player->anim;
}
}

et voila...

pilo1488 Je ne connais pas bien les struct (jamais servis), mais pour faire une animation j´ais deja écris une fonction, le probleme était lorsque j´aurais plusieurs animations, je ne voyais pas ou/comment stocker chaques variables spécifiques a chaque anim. C´était juste là le probleme.

reno_ Ah oui ok je vois mieux maintenant, merci

Sinon je vais suivre le conseil de Kaoron et me documenter sur les struct

Merci

Désolé du double post

Kaoron, juste une petite remarque, quand tu dis
"Bref, pour la solution que tu avais trouvée, tu peux créer un Struct par animation contenant :
Une référence vers ..."

Le probleme de base était justement que je ne pouvais pas prévoir a l´avance combien il y avait d´animation a faire, donc je ne peux pas créer un nombre de struct défini. C´était juste une erreur de formulation ou un oubli?

Merci

pilo1488 Je ne connais pas bien les struct (jamais servis), mais pour faire une animation j´ais deja écris une fonction, le probleme était lorsque j´aurais plusieurs animations, je ne voyais pas ou/comment stocker chaques variables spécifiques a chaque anim. C´était juste là le probleme.

c´est bien a ca que je te propose une solution, avec une struct ;)

Le probleme de base était justement que je ne pouvais pas prévoir a l´avance combien il y avait d´animation a faire, donc je ne peux pas créer un nombre de struct défini. C´était juste une erreur de formulation ou un oubli?

La tu as pas le choix, il te faut une liste dynamique.

Comme le rappelle pilo1488, j´ t´ai ensuite dit : "C´est ce struct que tu stockeras dans un tableau dynamique/une liste/autre chose."

C´est pour apprendre les avantages et inconvénients des structures de données existantes, et plus généralement l´algorithmique des structures de données que je t´ai conseillé de te documenter. Une structure dynamique, tableau ou liste, te permet d´allouer un espace à mesure de ton besoin ou de pouvoir l´étendre si nécessaire, ainsi tu n´es pas obligé de savoir la quantité d´informations qui sera générée à l´exécution.
Le site de Fvirtman devrait certainement t´apporter les précisions nécessaires sur ce point, et un petit cours d´algo et structures de données linéaires ne serait pas du luxe pour comprendre comment ça marche.
Bon courage

Bon une derniere question, après j´essayerais de me demerder seul

J´ais lu le tuto de Fvirtman sur les tableaux et les struct dynamiques, mais ce que j´ais vu au mieu, c´est pour faire un tableau de struct qui possède quand meme une limite X. Donc quand Kaoron disait qu´il fallait étendre cette limite au besoin, comment je suis censé faire?