Structurer un programme en C avec SDL

[AmigaOS]

Bonjour

Je suis en train d’essayer de faire un mini-jeu en SDL, mais le main commence à atteindre 400 lignes de code ! Je voulais alors créer des fonctions et les mettre dans d’autres fichiers (avec les .h...).
Mais ça m’a l’aire compliqué... Je voulais par exemple faire un deuxième fichier en y plaçant tout les chargements d’images. Mais pour faire cela il faudrait alors que je fasse des variables de type : SDL_Surface*, SDL_Rect, SDL_FillRect... en "externe". Pour faire toute les autres fonctions qui vont servir pour assembler un bonhomme par exemple, ça va être pareil... Mais d’après ce qui parait les variables externes ne sont pas trop utilisé et rendent la lecture du programme difficile.
Je me demande comment font alors les autre programmeurs, qui doivent faire des programmes beaucoup plus gros.
Quelqu’un peut me dire comment on fait ?

Merci
-----

[bzh_nicolas]

Qu'entends-tu exactement par variables externes ? Des variables globales ?
En général quand tu veux structurer un programme, tu le découpes en fonctions et en méthodes, si tu ne veux pas de variables globales (et c'est mieux de les éviter), il faut déclarer les variables dans ta fonctions main et ensuite les passer en paramètres de tes fonctions et méthodes.
Pour la création de tes fonctions, tu peux créer des fonctions qui font des tâches répétitives, ou qui font des taches bien particulières : initialisation du programme, des variables en allocation dynamique, etc...
Après pour la lisibilité du programme il y a quelques points à ne pas négliger (même s'ils semblent tomber sous le sens) : l'indentation correcte du code, les commentaires et surtout les noms de variables (et de fonctions/méthodes) qui veulent dire quelque chose (pas de a, b, c, variable2, etc...)

[AmigaOS]

Mais n’est t’il pas possible de faire la chose suivante :
Le programme multiplie une fonction autant de fois que l’utilisateur en a besoin.
Et ça sans détruire ses variables, car ils vont être réutilisés.

Par exemple si on fait un jeu où les niveaux sont enregistré dans des fichiers.
Quand le jeu démarre, il doit alors lire le fichier contenant les niveaux, et s'il lit par exemple qu’il y a 5 ennemies à donc 5 positions différentes, il doit alors créé 5 SDL_Surface* et 5 SDL_Rect.
Comme l’ennemie bouge il doit alors pouvoir recalculer les positions de l’ennemie à chaque tour de boucle (la boucle principale d’un jeu en SDL).
Et comme le programme doit être structuré alors il faut que ces fonctions soient écrites dans d’autres fichiers que celui du main.
Ce serait tan l'idéal

[bzh_nicolas]

Oui c'est bien sur possible, c'est là l'intérêt de passer tout ça en paramètres des fonctions que tu vas créé en créant les variables nécessaires dans ton main (ou alors en variables globales mais c'est le MAL en programmation).

[A voir en vidéo sur Futura]

[invite447c3273]

et s'il lit par exemple qu’il y a 5 ennemies à donc 5 positions différentes, il doit alors créé 5 SDL_Surface* et 5 SDL_Rect.

tu n'est pas obliger de créer autant de SDL_Surface* que d'ennemis. En effet tu peut afficher plusieurs fois le même surface à des emplacements différents.

Pour imager mon propro, voit les SDL_Suface comme un tampon encreur, et que je chaque coup de tampon imprime le dessin .

Cela est vrai que si tes ennemis sont tous les mêmes bien sure.

[AmigaOS]

Ok, ça devient plus claire pour moi.
Mais j’ai encore une question.
Pour mon joueur principal, je vais faire une fonction qui servira pour assembler le joueur à chaque tour de boucle (en fonction de si il marche, saute, tire ...) :

SDL_Surface MONTAGE_PLAYER (direction, ... + quelques variables ... ) ;

Est ce qu’il vaux mieux déclarer tout les autres SDL_Surface qui vont contenir les membres du joueur, dans la fonction, et donc obliger le programme de recharger tout les graphismes à chaque tour de boucle ?
Ou, c’est mieux de les déclarer et charger une fois dans le main, et les faire passer en arguments dans la fonction ?

[invite447c3273]

Dans tous les cas je dirai qu'il faut que le maximun de SDL_surface soit créer au début. Car chaque création prend quelques nanoseconde mais multiplié par le nombre de passage dans la boucle principal ça peut devenir enorme.

Aprées entre variable globale ou paramètre, ça se discute, car ça doit revenir au même au niveau temps de traitement.

[AmigaOS]

J’ai alors essayé avec passements de paramètres, mais j’obtiens le message d’erreur :

incompatible types in assignment

Voici quelques extraits de mon code :

Dans main.c, player.c, player.h :

SDL_Surface MONT_PLAYER
(
    char last_dir,
    int c_ar,
    float c_pl, 
    SDL_Surface *player,
    SDL_Surface *bn,
    SDL_Surface *bn_l,
    SDL_Surface *bn_r,
    SDL_Surface *br,
    SDL_Surface *br_n_l,
    SDL_Surface *br_n_r,
    SDL_Surface *br_t_l,
    SDL_Surface *br_t_r,
    SDL_Surface *jb,
    SDL_Surface *jb_1_l,
    SDL_Surface *jb_2_l,
    SDL_Surface *jb_3_l,
    SDL_Surface *jb_1_r,
    SDL_Surface *jb_2_r,
    SDL_Surface *jb_3_r,
    SDL_Surface *pg,
    SDL_Surface *pg_1,
    SDL_Surface *pg_2,
    SDL_Surface *ar,
    SDL_Surface *ar_6_n_l,
    SDL_Surface *ar_6_t_l,
    SDL_Surface *ar_6_n_r,
    SDL_Surface *ar_6_t_r,
    SDL_Rect pos_bn,
    SDL_Rect pos_br,
    SDL_Rect pos_jb,
    SDL_Rect pos_pg,
    SDL_Rect pos_ar
) ;

Dans main.c :

    player = MONT_PLAYER ( last_dir, c_ar, c_pl, player, bn, bn_l, bn_r, br, br_n_l, br_n_r, br_t_l, br_t_r, jb, jb_1_l, jb_2_l, jb_3_l, jb_1_r, jb_2_r, jb_3_r, pg, pg_1, pg_2, ar, ar_6_n_l, ar_6_t_l, ar_6_n_r, ar_6_t_r, pos_bn, pos_br, pos_jb, pos_pg, pos_ar ) ;

          SDL_BlitSurface (player, NULL, ecran, &pos_player) ;

[AmigaOS]

Problème résolut.
player était un pointeur !

[doul11]

Bonsoir,

ça ne va pas du tout.

voila un exemple simple :

Mafonction.h

#ifndef MAFONCTION
#define MAFONCTION

void MaFonction(int);

#endif

le if protège des inclusions multiples.

MaFonction.c

#include "MaFonction.h"

void MaFonction(int z)
{
z++;
}

main.c

#include "MaFonction.h"

int main(void)
{
int i;

MaFonction(i);

return 0;
}

tu compile séparément main.c et MaFonction.c, l'éditeur de lien donnera le programme avec le code de main et MaFonction, en faisant comme ça si tu modifie que le main.c tu n'a besoin que compiler main.c, tu n'est pas obligé de tout recompiler a chaque fois, car sur un gros programme ça prends du temps.

[doul11]

autre chose, au lieu d'écrire n fois une liste interminable de variables fait une structure, ensuite tu utilise la structure, en cas de modification elle est répercuté partout automatiquement, sinon c'est des bugs a coup sur.