Discussion :

[slobodan93]

Bonjour,

Dans le cadre du tilemaping je vais devoir utiliser un tableau contenant les textures ( je n'utilise pas de tileset parce que j'ai déjà un dossier blindé de ptites tuiles hexagonales correspondants parfaitement à ce que je veux faire :3 ) mais également un tableau 2D contenant la représentation de la carte avec des chiffres.

Malheureusement ça ne fonctionne pas très bien, et je ne trouve que des guides SDL 1.2 sur internet qui parle de ça ( il y a un bon tuto sur le tile mapping sur ce site mais comme on est sensé avoir un très bon niveau en C et SDL les explications sur ce qui m'intéresse sont peu nombreuses ), et j'avoue que je galère un peu à comprendre comment ça fonctionne en n'utilisant que la doc, le but n'étant pas de faire du copier-coller mais de savoir ce que je fais un minimum hein ;D j'ai déjà toutes les formules d'écrites pour le placement des tiles, sur quelle tile j'ai cliqué etc c'est vraiment la gestion avancée des tableaux qui m'embête :/

Je vous passe donc mon ptit morceau de code, merci d'avance pour vos explications sur mes erreurs le debuggeur est utile mais c'est pas ça qui va m'aider pour le coup





La structure :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
typedef unsigned char tilecarte;                         //raccourci pratique
 
typedef struct Terrain Terrain;                           
{
 
    char nombretile, largeur, hauteur;                 //variable contenant le nombre de tiles différents utiliser dans le niveau, la largeur et la hauteur du monde
 
    tilecarte** carte;                                        //création du tableau 2D carte,
 
    SDL_Texture** tile;                                    //création du tableau 1D contenant une texture ( un tile différent ) par valeur donc
 
}

La fonction pour mettre les textures dans le tableau :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
Terrain terrain;                                                                                       //déclaration de la structure en dehors de la fonction pour que tout le .c puisse l'utiliser         [/COLOR]
 
void Chargement(FILE* fichier)                                                                     //la fonction, je récupère un fichier texte contenant les détails du niveau
{
    char cache[CACHESIZE];                                                                        //un cache pour des infos temporaires, le CACHESIZE vaut 1000 caractères je suis tranquille[/COLOR]
    unsigned char i;                                                                                    //je déclare la variable i
 
    fscanf(fichier, "%d", &terrain.nombretile);                                               //je lis la ligne contenant le nombre de tiles différents ( 1 seul pour le moment c'est juste du test )
    terrain.tile = malloc(terrain.nombretile*sizeof(SDL_Texture*));                    //j'alloue de la mémoire au tableau, le nombre de tiles différents x l'espace qu'utilise un SDL_Texture )
 
    for ( i=0; i<terrain.nombretile; i++ )                                                      //la boucle de remplissage
    {
        fgets(cache,CACHESIZE,fichier);                                                         //je prends l'adresse de la tile en question ( image/espace/stars.png ) que je met dans le cache
        terrain.tile[i] = loadTextureImage(cache);                                           //loadTextureImage fait la conversion adresse => surface => texture, il fonctionne déjà très bien j'ai fais le menu principal avec ^^
 
        if ( terrain.tile[i] == NULL )                                                              //petite vérif d'erreur...
        {
            exit(4);                                                                                    //qui éteint le programme et me renvoie 4 dans la figure à chaque fois que je lance le programme
        }
    }
}

La fonction permettant de mettre le tableau du fichier texte ( que des 0 séparés par des espaces, 14 en large et 10 en hauteur ) :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
void Carte(FILE* fichier)
{
    char cache[CACHESIZE];
    unsigned char i, j;
 
    fscanf(fichier,"%d %d",&terrain.largeur,&terrain.hauteur);                             //j'ai une ligne dans le .txt contenant la largeur et la hauteur du monde en tile
    terrain.carte = malloc(terrain.largeur*sizeof(tilecarte));                                //j'alloue de la mémoire au tableau en fonction de la largeur du monde x la place que prendre tilecarte
 
    for(i=0;i<terrain.largeur;i++)                                                                    
    {
        terrain.carte[i] = malloc(terrain.hauteur*sizeof(tilecarte));                        //j'alloue de la mémoire au tableau en fonction de la hauteur du monde x la place que prends tilecarte
    }
 
    for (j=0; j<terrain.hauteur; j++)                                                              //boucle pour le remplissage
    {
        for (i=0; i<terrain.largeur; i++)
        {
            unsigned char num;                                                                        //la ptite variable contenant le numéro de la tile à coller ( il n'y a que des 0 de toute manière )
            fscanf(fichier, "%d", &num);                                                             //récupération
            if ( num >= terrain.nombretile )                                                        //si je dois coller la tile 5 alors qu'il n'y en a que 3 différentes ça ne va pas le faire...
            {
                exit(6);                                                                                   //on quitte si c'est le cas
            }
            terrain.carte[i][j] = num;                                                               //on fout le chiffre aux bonnes coordonnées et c'est reparti jusqu'à ce qu'il n'y en ai plus
        }
    }
 
}

Voili voilou, j'espère avoir été clair ( j'ai sans doute mis trop de commentaires mais ça me permet de m'y retrouver, moi et tout ceux qui tomberont sur cette discussion ^^ )
Révélez moi mes bourdes :p

PS1 : Les 2 fonctions sont sur la même pas .c, comme j'ai déclarer la structure sur cette même page en dehors des fonctions pas besoin d'utiliser des pointeurs, tant mieux les -> partout je trouve ça peu lisible mais bon ~

PS2 : le programme s'éteint et me renvoie 4 à la figure mais il n'y peut-être pas que la qu'il y a des erreurs

[Kannagi]

Alors pense a mettre les balises code , sinon ça devient illisible.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

 Terrain terrain; //déclaration de la structure en dehors de la fonction pour que tout le .c puisse l'utiliser

Ouais c'est ce qu'on appelle un variable global et donc tu ne dois pas en faire (sauf a des rares exception et quand tu sera bon en C).

J'imagine que le forum a enlevé l'indentation , sinon si tu code sans indenter ton code même chose , l'indentation c'est très important.

Un autre point la variable i , c'est un int et non un unsigned char , deja en général le compilo te met en warning et 2 ça me semble plus logique de faire un int (mais tu comprendra ça quand tu comprendra comment fonction les adresse/ pointeur et que la variable int et faite pour les manipuler pas le char).
Mon avis personnel je n'aime pas ton FILE* fichier en argument , pas que cela ne se fait pas mais en général ce genre de pratique est faite pour manipuler un fichier , non faire chargement ou autre dedans.
Je préfère même que tu ouvre/ferme ton fichier plusieurs fois.

PS2 : le programme s'éteint et me renvoie 4 à la figure mais il n'y peut-être pas que la qu'il y a des erreurs

Exact donc dit nous l'erreur exact + le reste du code.

Dans le cadre du tilemaping je vais devoir utiliser un tableau contenant les textures ( je n'utilise pas de tileset parce que j'ai déjà un dossier blindé de ptites tuiles hexagonales correspondants parfaitement à ce que je veux faire :3 ) mais également un tableau 2D contenant la représentation de la carte avec des chiffres.

Le principe est simple et le code aussi , un chiffre == afficher mon image[chiffre] (c'est pas vraiment un code hein juste le principe général).
Je vois juste que comme beaucoup de débutant tu complexifie le probleme , du coup soit tu réfléchi pour simplifier ton probleme soit tu continu a essayer avec ce que t'as fait de faire un truc qui tient la route.

[slobodan93]

Merci pour ta réponse ^^ Balises code ? Ha okay je comprends à quoi ça sert, effectivement je le ferai la prochaine fois !

Alors les variables globales, il y a une raison particulière de ne pas les utiliser ? Ma structure ne sera utile que dans le terrain.c en gros.

Quand tu parles d'indentation tu parles de faire des décalages ( avec tab par exemple ) pour rendre le code plus lisible ? Je l'utilise énormément et effectivement le forum m'empêche de le faire, je fais également plusieurs fonctions sur plusieurs pages j'essaye d'être le plus organisé possible

Utiliser plutôt un int ? D'accord je note, je pensais qu'utiliser des chars me ferai gagner un peu de place mais comme c'est négligeable de toute manière :p

Beh ça me renvoie ça dans le build log, la texture n'a donc pas été charger dans le tableau :
Process terminated with status 4 (0 minute(s), 2 second(s))

Le debuger et le buildmessage sont RAS, statut 0 pour le premier et rien dans build message même pas un warning, je m'acharne à les faire disparaitre

Mon code est conséquent avec tous mes .c et .h... :o comme c'est la partie chargement du terrain qui fait nawak je vais donner tout ce qui s'en approche .. ^^





prototypes dans Proto.h :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
 
#ifndef PROTO
#define PROTO
 
#include "Struc.h"
 
//DESSIN
extern void drawTerrain();
 
//INIT
extern void initTerrain();
extern void Chargement(FILE* fichier);
extern void Carte(FILE* fichier);
 
 
//CLEAN
extern void cleanup();
extern void cleanMenu();
extern void cleanParametre();
 
//CHARGEMENT
extern SDL_Texture *loadTextureImage(char *name);
 
#endif

Structures dans Struc.h :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
 
#ifndef STRUC
#define STRUC
 
#include "Def.h"
 
 
typedef unsigned char tilecarte;
 
typedef struct Terrain
{
 
    char nombretile, largeur, hauteur;
 
    tilecarte** carte;
 
    SDL_Texture** tile;
 
}Terrain;
 
#endif

Les Defines dans Def.h

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
 
#ifndef DEF
#define DEF
 
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <math.h>
#include <SDL.h>
 
#include <SDL2/SDL_image.h>
#include <SDL2/SDL_ttf.h>
#include <SDL2/SDL_mixer.h>
 
#define LARGEUR 1024
#define HAUTEUR 768
 
#define LARGEURTILE 72
#define HAUTEURTILE 72
 
#define CACHESIZE 5000
 
 
#endif

le terrain.c réservé au chargement et au dessin du terrain ( la fonction drawTerrain est vide pour le moment, logique faudrait déjà que j'arrive à le charger xD ) :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
 
#include "Proto.h"
 
 
 
Terrain terrain;
 
 
 
void initTerrain()
{
 
FILE* fichier;
char cache[CACHESIZE];
 
fichier = fopen("map/test.txt", "r");
if (!fichier)
{
    exit(1);
}
 
fgets(cache,CACHESIZE,fichier);
if (strstr(cache, "StratR 1.0")==NULL)
{
    exit(2);
}
 
do
{
    fgets(cache,CACHESIZE,fichier);
 
    if (strstr(cache, "#chargement"))
    {
        Chargement(fichier);
    }
 
    if (strstr(cache, "#carte"))
    {
        Carte(fichier);
    }
} while (strstr(cache,"#fin")==NULL);
 
fclose(fichier);
 
}
 
 
 
 
void Chargement(FILE* fichier)
{
    char cache[CACHESIZE];
    unsigned char i;
 
    fscanf(fichier, "%d", &terrain.nombretile);
    terrain.tile = malloc(terrain.nombretile*sizeof(SDL_Texture*));
 
    for ( i=0; i<terrain.nombretile; i++ )
    {
 
        fgets(cache,CACHESIZE,fichier);
        terrain.tile[i] = loadTextureImage(cache);
 
        if ( terrain.tile[i] == NULL )
        {
            exit(4);
        }
 
    }
 
}
 
 
 
 
 
 
 
void Carte(FILE* fichier)
{
    char cache[CACHESIZE];
    unsigned char i, j;
 
    fscanf(fichier,"%d %d",&terrain.largeur,&terrain.hauteur);
    terrain.carte = malloc(terrain.largeur*sizeof(tilecarte));
 
    for(i=0;i<terrain.largeur;i++)
    {
        terrain.carte[i] = malloc(terrain.hauteur*sizeof(tilecarte));
    }
 
    for (j=0; j<terrain.hauteur; j++)
    {
        for (i=0; i<terrain.largeur; i++)
        {
            unsigned char num;
            fscanf(fichier, "%d", &num);
            if ( num >= terrain.nombretile )
            {
                exit(6);
            }
            terrain.carte[i][j] = num;
        }
    }
 
}
 
void drawTerrain()
{
 
}
 
void cleanTerrain()
{
 
    int i, j;
    for (j=0; j<terrain.nombretile; j++)
        free(terrain.tile[j]);
    for(i=0;i<terrain.hauteur; i++)
        free(terrain.carte[i]);
    free(terrain.carte);
 
}

Je reprécise, j'ai vraiment du mal à comprendre et utiliser les tableaux "avancées" donc il y a peut-être des énormités qui vous brûleront les yeux et l'âme, j'en suis navré d'avance '-'

Merci encore pour tes conseils. ~

EDIT : ce que contient le fichier texte

StratR 1.0
#chargement
1
image/espace/stars.png
#carte
14 10
0 0 0 0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0 0 0 0
#end

[Kannagi]

Alors les variables globales, il y a une raison particulière de ne pas les utiliser ? Ma structure ne sera utile que dans le terrain.c en gros.

Le but d'une fonction c'est qu'elle soit modulaire , et d'éviter les effets de bord.

Je n'ai pas eu trop le temps de lire ton code source , mais je vois pas ou est la difficulté :
en gros l'algo ressemble a ceci :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
 
    for(i = 0; i < bgdata.size;i++)
    {
        x = i%bgdata.largeur;
        y = i%bgdata.largeur;
        select = bgdata.tile[i];
        dessiner(tile[select],x,y);
    }
 
    /*
        bgdata.size
        La taille de ton tableau de tes donner de tile ( genre 0 = herbe , 1 = mur ect)
        
        bgdata.largeur
        La largeur de ta map tout simplement ;)
        
        bgdata.tile
        Les donners de tes tiles , par exemple si tile[0] == 0 donc c'est de l'herbe
        
        tile[select]
        Un tableau de Texture tout simplement :)
    */

[slobodan93]

D'accord merci beaucoup pour tes conseils
J'ai pu en plus de ça régler les autres soucis, sujet résolu donc ^^