Oui mais le but de la malloc c'est justement de créer ces SDL_Rect nan ? J'peux pas appréhender le nombre de tir que je fais. A chaque appuie sur t, ça doit me créer un nouveau sprite, et disparaît lorsqu'il a été en collision !

" Oui mais le but de la malloc c'est justement de créer ces SDL_Rect nan ? "

Oui entre autres, enfin si tant est que tu as besoin d'autre chose, je ne sais pas exactement comment ça se présente, seul toi le sais.

Tu peux utiliser "realloc" pour redéfinir la taille du bloque de mémoire à l'emplacement pointé (si il manque de la place, le tout sera alloue sur un autre emplacement en mémoire).

Sinon je te conseil de passer au C++, c'est plus confortable (enfin moi je trouve en tout cas, certains diront peut-être le contraire), tu pourras utiliser des classes avec des méthodes et constructeur/destructeur, puis les opérateurs new et delete au lieu de malloc et free, puis tu pourrais éventuellement utiliser les conteneurs de la librairie standard.

J'ai déjà songé au C++, la SDL me permet juste d'affiner mes connaissances en C !
Mais tu as raison, je vais m'y tourner prochainement, c'est vrai qu'au fur et à mesure mon petit projet se complexifie, et le C n'est pas le meilleur module pour créer des jeux-vidéos..

Au moins je fais quelque chose d'un peu poussé, ce qui me permet de me forcer à réfléchir et de trouver des solutions, très bon exercice (même si je viens demander aide ici !)

Je continue de voir tout ça, sur l'alloc' dyna'

"mmmh j'ai pas conseillé d'utiliser une liste chainée. Meme si c'est certainement plus propre, c'est quand meme plus de boulot a mettre en place correctement qu'un tableau tout bête. "

J'ai lu un peu vite je crois.

M'enfin bon une liste chainée est très bien quand même pour ce qu'il veut faire.

Au fait Glosoli les collisions, tu maitrises ?

Odol
Ouais à fond, j'ai une maîtrise reconnue par d'autres, j'avais travaillé avec un autre sur son petit projet, et il m'a dit qu'il comprenait rien aux collisions..

Nan mais je gère Regarde dans le pastebin dans le post original, tu y trouves facilement une gestion de collision bien étoffée

Sinon j'en arrive aussi à un souci à ce niveau.. Lorsque j'ajoute une surface, lorsque je ne la touche pas, je suis donc soumis à la gravité.. Et donc la gravité est plus lourde (Dragon Ball spotted), et ainsi de suite que j'ajoute une plateforme !

Et donc à chaque fois je dois monter la hauteur du saut.. Et ça me gêne quoi Alors j'ai pensé que j'devais me mettre au tile mapping, mais ça me plaît pas trop..
Alors j'ai un peu laissé tomber à ce niveau, je reverrai lorsque j'aurai acquis suffisamment de bases pour entamer un vrai jeu présentable

Ou alors j'ai pas trouvé de solution.. (Doit y en avoir une, je devrais plus disperser mon code en dehors du main, remplacer par des pointeurs etc.. pour avoir une meilleure gestion de chaque chose)

Et tu peux voir que la gestion animation est bien dégueulasse Je sais qu'il faut mettre tout ça dans un tableau, mais faut gérer un peu le temps.. Me suis pas encore pris le temps de voir ça.. pourtant y'a pas grand chose à faire

Pour ton problème renseigne toi sur les listes chainées. En gros c'est une sorte de tableau. Les objets sont raccordé les uns les autres par un pointeurs sur l'objet suivant. Mais ils ne se suivent pas en mémoire.

C'est c'que j'ai lu ouaip.
Faut déjà que je capte bien l'alloc'.

Qu'est-ce que tu ne comprends pas à ce niveau-là?

Ben j'ai fait que d'lire pour l'instant. J'aurais besoin du sizeof ?

" J'aurais besoin du sizeof ? "

Ce n'est pas indispensable mais plus pratique. C'est simplement une fonction qui renvoie la taille en octets du type en question et vu qu'il faut fournir la taille du bloque de mémoire avec "malloc" il faut connaître la taille du type d’éléments qu'il va contenir.

malloc(5*sizeof(int));

Par exemple alloue de la place pour 5 entiers, sizeof renvoie ici la taille d'un int (en général 4 octets) et on alloue donc 5 fois 4 octets.
Au lieu de mettre "sizeof(int)" on aurait pu mettre directement "4" si on sait qu'un int vaut 4 octets (mais ça peut varier selon les implémentations) ou on aurait encore pu mettre juste "malloc(20);".

A noter que sizeof est particulièrement pratique pour connaître la taille d'un type défini par l'utilisateur (struct ou class par exemple). A noter aussi qu'en C++ avec l’opérateur "new" la taille de l'objet est fourni automatiquement et implicitement.

Yep ça j'ai lu ! Et donc ça servirait donc à s'adapter à la machine sur laquelle le programme tourne surtout ?

Mais comme moi je veux donner la taille de mon sprite, je dois mettre la taille de mon .bmp ?

" Et donc ça servirait donc à s'adapter à la machine sur laquelle le programme tourne surtout ? "

Non, pas spécialement.

" Mais comme moi je veux donner la taille de mon sprite "

Pour? Si tu utilises la SDL les fonctions SDL_LoadBMP ou IMG_Load iront chercher la taille automatiquement.

Ouais d'accord

Et pour le lier à un tableau de pointeurs ?

J'vois pas trop comment faire.. Je donne quoi comme paramètre à mon tableau ? Et comment les mallocs vont se stocker dedans ?

La fonction malloc renvoie un pointeur void, (pointeur de type non défini, on l'utilise en général avec une conversion de type explicite (casting)).

Truc *trucs;
trucs = (Truc*) malloc(10*sizeof(Truc));

Alloue de l'espace pour 10 "Truc" dans un emplacement libre en mémoire et renvoie l'adresse de cet emplacement (concrètement l'adresse du premier octet de tous les octets occupés par nos 10 Truc, a noter aussi la conversion de type (Truc*) nécessaire car comme je l'ai dit plus haut malloc renvoie un pointeur void).

Après tu peux utiliser ton pointeur comme un tableau, par exemple trucs[2] pointe vers le troisième Truc, c'est pareil que "trucs+2", en imaginant que la taille d'un truc est de 50 octets on ajoute donc 100 a l'adresse contenu dans le pointeur "trucs" pour pointer sur le troisième Truc.

Merci Pocolo pour les explications

J'ai suffisamment de réponses sur ce topic pour pouvoir faire quelque chose !

Bon voilà, j'ai tenté quelque chose..

http://pastebin.com/qWNZRP77

M'alors ça tourne tout ça, mais rien de spécial ne se passe !

Je pense que ce doit être un problème de sélection du tir..En tout cas de position du tir ou de déplacement. Bref.

J'espère que vous arriverez à lire le code ! Tout en haut je déclare un typedef struct, vers le haut du main je déclare le tableau de cette structure, et dans la gestion collision, lorsque j'appuie sur t, y'a tout c'qui devrait se passer !

Merci d'avance !

C'est ok !

En fait, dans SDLK_t, après les trois lignes

tableautesttir[i].postirtest.x = posperso.x;
tableautesttir[i].postirtest.y = posperso.y;
tableautesttir[i].remplis = 1;

Il faut tout simplement mettre un break ! Sinon y'a booltirright = 1; (ce petit booléen qui me dit quand je dois avancer ou non mon sprite tir), il continue son chemin sans se soucier d'autre chose..

Bref, en fait pour en arriver à ça faut quand même réfléchir..
Quelle satisfaction d'en arriver à tirer plusieurs fois mes missiles là

J'ai pas tout regarder en détail mais sache que c'est quand même assez moche comme code et il y a beaucoup de fautes (mais c'est normal quand on débute), notamment (et ça pourtant été répété au moins TROIS fois par différentes personnes sur ce topic, tu n'écoutes pas ce que les autres te disent) le fait qu'il ne faut pas (vraiment pas) mettre plusieurs fois la même image en mémoire, ton programme est rempli de memory leaks (fuites de mémoires), c'est très mauvais ça.

Ben c'déjà pas mal comme ça

Mais l'image se charge seulement lorsqu'on appuie sur t non ?

Sinon j'dois aller sur la méthode realloc, c'pas mon fort ça..