Fichier externes, avec fwrite et fread - Page 2

Pas grave

Bon pour ceux qui ont déjà utilisé ça : Est-ce que les modulo sont lents, en gros est-ce que je peux en caser partout sans trop ralentir ou bien est-ce qu'il faut que j'oublie tout de suite cette idée saugrenue ?

Quand tu peux les remplacer par des divisions et des multiplications, fait le.

Bah la je pense pas pouvoir. En fait j'aimerais ré-utiliser le système de CMS, mais c'était du Ti-Basic...

Les matrices étaient composées comme ça :
[5005,5015,5015,5015,5015...]
[5025,1001,1001,1001,1001...]
[5025,1001,1001,1001,1001...]
[5025,1001,1001,1001,1001...]
[...............................]

Chaque case contient 2 informations : le sprite à afficher et la valeur de la case.
- On a le sprite à afficher en faisant #("tile_"&string(int(mat[x,y]/10)))
- On a la valeur de la case en faisant mod(mat[x,y],10)

5025 devient donc "tile_502" et 5. "tile_502" c'est le nom du PIC à afficher, et 5 ça indique que la case est un mur.

En C, mettre des modulo partout comme ça, ça va ralentir j'imagine ?

Doit y avoir moyen de faire plus simple et plus efficace. A moin avis, vo mieux utiliser 2 tableaux, ça ira plus vite...

Oui, guilc a raison !!!

déjà en C : 5002 => tu dois donc utiliser une variable de type int, donc 2 octets

alors qu'en BASIC, 5002 => 6 octets !

et j'ai pris un exemple : [[5002,5002,5002][5002,5002,5002]] en BASIC = 32 octets !

alors qu'en C, ce truc vaut 2 octet *6 + 4 octets = 16 octets ! (4 octets pour le pointeur).
=> ça c'est pour le tab des numéro de sprites à afficher, quand tu as plus de 255 sprites dans un niveau (car si tu en as moins de 255, tu déclare ton tableau en "unsigned char", et tu éconnomises encore + de place !).

Donc tu peux te permettres de prendre encore un autre tableau de "unsigned char" (1 octet) pour le type de tes sprites, et tu perdras presque rien par rapport au BASIC niveau taille ...

Vertyos
a écrit : C'est une grosse contrainte, vu que le tableau est utilisé pendant toute l'execution du prog...

Alors:
if (fichier non valable) {
// message d'erreur
return;
}
// déclaration des tableaux
// reste du programme

Si tu veux passer le tableau en paramètre à une fonction, tu peux faire ça:
void func(int dimy;char (*tableau)[dimy],int dimx,int dimy) {
}
à appeler comme ça:
func(tab_xxx,int_dmx,int_dmy);
Mais je ne suis pas sûr s'il ne faut pas GCC 3.1 (et donc TIGCC 0.94 beta 14) minimum pour ça. À vérifier.

je sens que je vais le laisser en var globale ce tableau, ça va m'éviter beaucoup de complications

A moin avis, vo mieux utiliser 2 tableaux, ça ira plus vite...

Bah justement le but de la maneuvre, c'est de ne PAS utiliser 2 tableaux
Mais si je peux pas faire autrement, tant pis

Vertyos a écrit :
Bah justement le but de la maneuvre, c'est de ne PAS utiliser 2 tableaux
Mais si je peux pas faire autrement, tant pis

Erf, fo sortir de la logique TIBasic : C'est du C que tu utilises. La gestion des pointeurs est très évoluée, donc c'est plus performant que des artifices comme mélanger deux valeurs dans un tableau et de faire un % pour extraire une valeur !
Deux tableux, ça prendra pas franchement plus de place, et ça sera plus performant et plus maniable ! Et a mon avis, plus simple à implémenter...

Erf, fo sortir de la logique TIBasic : C'est du C que tu utilises

Aucun rapport... En Basic aussi, ça aurait été plus rapide de faire deux tableaux. Mais pour des raisons de place, j'ai pas envie.

Deux tableux, ça prendra pas franchement plus de place

À vue de nez, je dirais approximativement 2 fois plus

et ça sera plus performant

Bah si t'en es sûr à 100% alors tu a répondu à ma question

Et a mon avis, plus simple à implémenter...

Ça je m'en fiche pas mal... Je cherche à faire un truc rapide, que ce soit simple ou non.

Alors au lieu de coder le contenu de ton tableau en base 10, tu utilises la base 8 ou 16, comme ça tu peux utiliser des décalages et des ands au lieu des divisions et des modulos.

Ah bah ça c pas bête !
Sauf que j'ai jamais fait ça... En gros il faut procéder comment ?

Non, deux tableaux, ça prendra pas plus de place qu'un seul en basic : comme l'a dit Pim89, il suffit de choisir les bons types : en Basic, les tableaux sont très très gros : 6 octets au moins. Si tu fais deux tableaux en C : 2 octets par élément pour l'un (celui avec le numero des tiles), pour des unsigned short ça doit suffire : ça va jusqu'à 65536 , et pour le deuxième tableau : 1 octet par élément, soit des unsigned char.

Si je compte bien, ça fait un total de 3 octets contre 6 en basic... Donc la place est divisée par 2 par rapport au basic, et à peine plus qu'un seul tableau de shorts en C (quuoique, pour mélanger les deux tableaux, il vo mieux utiliser des longs (4 octets), sinon, la place rique d'être un peu limite).

Oui je sais que ça prends moins de place qu'en basic, mais 2 tableaux ça prendra toujours 2 fois plus de place qu'un seul

Pas 2 fois plus ! Ca dépend des types utilisés !!!

RRRAAAHHHH !!!
Deux tableaux de char prennent deux fois plus de place qu'un seul tableau de char
Deux tableaux de short prennent deux fois plus de place qu'un seul tableau de short
Deux tableaux de long prennent deux fois plus de place qu'un seul tableau de long
Etc...
Tu vas quand même pas me dire que t'arrive à faire deux tableaux qui prennent moins de place qu'un seul ?

Mais si c'est la meilleure solution, utilise-la.
Ils ont quelles dimentions, ces tableaux ?

Ben dans ton cas, je vois soit un seul tableau de long + ta méthode foireuse et lente, soit 1 tableau de short + un tableau de char.
Donc c'est plus petit avec 2 tableaux !

2 tableaux de char