Taille d'un BGS - Page 1

comment calculer la taille (en octets) que va faire un BGS de dimensions connues (ex 48 de haut et 32 de large)?

heu, il utilise des multiples de 8 pour la largeur, une hauteur qcq, donc je suppose que c'est sizeof(char) * largeur/8 * hauteur

mais je peux me tromper

-fo pas multiplier par 2 vu ke y a du nvg?
-les infos hauteur et largeur sont stoké il me semble (d'apres la structure)

typedef struct
{
 char	Height; 		// In pixel
 char	Weight; 		// In pixel /16 (in word)
 short	Data[1];		// Should be []
} BGS;

c arrete pas de planter en tout cas!
je voulai mettre les BGS du perso de super metroid dans un fichier externe

Taille = Height * Weight * 2 * 2 + 2 (en octets)

raaaahhh! je comprends pas ça arrete pas de planter!
voila ce ke je fais:
-pour créer mon fichier contenant les BGS:

	section ".data"
	xdef	face
	xdef	cote
	xdef	haut
...

face:	dc.b 48,2
	dc.w $0000,$0001,$0000,$E000
	dc.w $0663,$0663,$3198,$F198
	dc.w $0597,$07F7,$3A68,$FBF8
...

Dans un fichier BGS.asm

extern BGS face, cote, haut;
BGS *BGS_Liste[3] = {&face, &cote, &haut};

void _main(void)
{
	int Compteur;
	FILE *fp = fopen ("metgfx", "wb");
	if (fp == NULL) return;
	fputc (3, fp);//Nombre de BGS
	for (Compteur = 0; Compteur < 3; Compteur++)
		{
			fwrite (BGS_Liste[Compteur], sizeof(char), 48 * 2 * 2 * 2 + 2,fp);
		}

	
	fputc (0, fp);
	fputs ("GFX", fp);
	fputc (0, fp);
	fputc (OTH_TAG, fp);
	fclose (fp);
}

Je compile et tout va bien, j'execute sur VTI et j'obtiens bien un fichier dont la taille semble correcte.

Par contre à la lecture du fichier au meilleur des cas G des morceaux de sprite qui apparaissent a la place du perso, au pire G des adresses error et autres ecran noirs qui bloquent tout!

Pour les adress error, vérifie bien que tous tes words sont à des adresses paires.
Normalement, ton fichier doit faire 1166 octets dans le VAR-LINK, c'est le cas ?
Dans le VAR-LINK, l'extension du fichier est-elle bien 'GFX' ?

Tu le lis comment, le fichier ?

1167 octets
pour la lecture:
je definie

BGS face, cote, haut;
BGS *BGS_Liste[3] = {&face, &cote, &haut};

int Lecture_BGS(void)
{
	int Nombre, Hauteur, Largeur, Compteur;
	FILE *fp = fopen ("metgfx", "rb");
	if (fp == NULL) return 0;//Impossible de lire le fichier
	Nombre = fgetc (fp);

	for (Compteur = 0; Compteur < Nombre; Compteur++)
		{
			fread (BGS_Liste[Compteur], sizeof(char), 48 * 2 * 2 * 2 + 2, fp);			
		}

	fclose (fp);
	
	return 1;//Aucun problème
}

Ah oui, 1167 octets. J'avais oublié le premier fputc
OK, ce qui ne va pas, c'est qu'une variable de type BGS contient l'adresse des données, alors que toi, tu recopies les données elles-mêmes dans tes variables.
Il faut que soit tu recopies le fichier en RAM le fichier (pour plus de rapidité), soit tu le laisses en ROM. Et pour remplir tes variables BGS (face, cote et haut), tu recopies le champ Height et Weight puis tu mets l'adresse de la suite du BGS dans le champ data.

G pas tout compris la
donc short Data[1]; dans la structure contient l'adresse de mon image?
par contre je ne voi pas trop ce que tu ve dire par "recopies le fichier en RAM"

C'est juste pour que ce soit plus rapide, mais ce n'est pas obligatoire (sauf si tu écris sur le sprite).
Et en fait, je me suis trompé. C'est une structure qui contient un tableau (je m'étais embrouillé car je croyais que le champ data contenait l'adresse des données), donc les datas doivent être recopiées.
Par contre, vu que la taille des datas est variable, tu ne peux pas déclarer des variables BGS sans les initialiser, parce que TIGCC ne sait pas combien d'espace il doit leur allouer (ce sera 2 octets dans ton cas, car les seuls champ de taille fixe sont deux char).
Finalement, la bonne technique c'est : au lieu de recopier quoique ce soit dans une variable BGS dans ton prog, tu n'as qu'à simplement prendre ton tableau de pointeurs sur les GBS et les faire pointer directement sur le fichier externe qui contient les GBS.

Par contre, je pense que tes données risquent d'être alignées sur des adresses impaires, vu que tu intercales un octet qui contient le nombre de sprites entre le début du fichier et le début des données. Tu devrais mettre ce nombre sur un short.

c bon la taille du fichier est pair maintenant. mais G jamais appris a faire pointer une variable sur un fichier externe

Il faut utiliser les fonction de vat.h
Mais peut-être que tu peux avec les fonction du style fopen, etc... (mais je ne les connais absolument pas).

donc il fo
-ke je chope l'adresse de mon fichier
-ke pour pour la liste de BGS je mette adresse_du_fichier + Compteur*(48*2*2*2+2) au lieu de mes fread(...);

je V essayer

Oui, enfin adresse_du_fichier + taille_checksum (2 octets) + nombre_sprt (2 octets) + compteur*(48*2*2*2+2)

Pour récupérer l'adresse d'un fichier, tu dois d'abord obtenir un pointeur vers sa structure SYM_ENTRY dans la VAT avec SymFindPtr (cherche cette fonction dans la doc, tu comprendras comment elle marche) et tu dois déréférencer son handle avec HeapDeref.

bon voila ce ke G mis:

SYM_ENTRY *Adresse = DerefSym(SymFind($("metgfx")));

et dans ma boucle de lecture G
BGS_Liste[Compteur] = HeapDeref(Adresse->handle) + 2 + 2 + Compteur*(48*2*2*2+2);

résultat : aucune erreur lors de la compilation (pas meme un warning) mais le prog plante totalement! je sens pourtant ke C proche de but!

Ta BGS_Liste semble pointer directement sur les Data dechaque BGS. (+2+2)
Si tu utilises des fonctions qui ont besoin de la taille etc, elles peuvent prendre les 2 premiers mots de tes datas pour les dimensions et provoquer n'importe quoi!

donc il fa ke je change ma liste et definir plutot

BGS *face, *cote, *haut;
BGS *BGS_Liste[3] = {face, cote, haut};

??

IroS a écrit :
short Data[1]; // Should be []

Pourquoi ne pas mettre Data[] directement, sachant que GCC comprend parfaitement?

Ca plante toujours et je commence a devenir dingue

voila ce que je fais:

BGS *face, *cote, *haut;


int Init_BGS_Samus(void)
{
	BGS *BGS_Liste[3] = {face, cote, haut};
	short Nombre, Compteur;
	FILE *fp = fopen ("metgfx", "rb");
	SYM_ENTRY *Adresse = DerefSym(SymFind($("metgfx")));
	//Retourne si le fichier n'est pas trouvé
	if (fp == NULL) return 0;
	//Récupère le nombre de BGS
	Nombre = fgetc (fp)*256;
	Nombre = Nombre + fgetc (fp);

	//Assigne les pointeurs vers le fichier externe
	for (Compteur = 0; Compteur < Nombre; Compteur++)
		{
			BGS_Liste[Compteur] = HeapDeref(Adresse->handle) + 2 + 2 + Compteur*(48*2*2*2+2);
48*2*2*2+2, fp);
		}
	fclose (fp);
	return 1;
}

franchement je vois pas ce qui ne va pas!
si ca se trouve il fo réallouer la mémoire de chaque BGS vu que Data est défini Data[1] alors qu'il devrait etre Data[48*2*2*2]!!

Attends, ce n'est pas la peine d'utiliser les fonction fopen, fgetc, etc... si tu utilises celles de vat.h, et puis Link t'a donné un mauvais conseil, je pense. L'ancienne solution était plus correcte : là, tu remplis ton BGS_Liste une fois au début, puis tu écrases ce que tu as mis la première fois pour mettre tes données.
Voici un code qui me paraît plus correct (mais j'ai la flemme de tester) :

BGS *BGS_Liste[3];

int Init_BGS_Samus(void)
{
	short Nombre, Compteur;
	SYM_ENTRY *Adresse = SymFindPtr($("metgfx"),NULL);
	//Retourne si le fichier n'est pas trouvé
	if (Adresse == NULL) return 0;
	unsigned char *Fileptr = HeapDeref(Adresse->handle);
	if(Fileptr == NULL) return 0;
	Fileptr+=2; // On saute les deux octets de taille
	//Récupère le nombre de BGS
	Nombre = *(unsigned short *)Fileptr;
	Fileptr+=2;
	//Assigne les pointeurs vers le fichier externe
	for (Compteur = 0; Compteur < Nombre; Compteur++)
		{
			BGS_Liste[Compteur] = Fileptr;
			Fileptr += 48*2*2*2+2;
		}
	return 1;
}

Et ensuite, tu peux utiliser BGS_Liste dans ton programme.

La taille d'un BGs est Height * Int(Width/16)*4.
Je sais plus si c'est Height ou Height+1.

Sinon met au début du fichier externe une table de pointeur relatifs vers les BGS :

section ".data"
xdef BGS_table
BGS_table:
dc.w face-BGS_table
dc.w debout-BGS_table
...
face: dc.b 48,2
dc.w $0000,$0001,$0000,$E000
dc.w $0663,$0663,$3198,$F198
dc.w $0597,$07F7,$3A68,$FBF8
...
Dans le code C, pour atteindre le BGS n tu fais :
extern short *BGS_table;
bgs = (BGS *) ((char *) BGS_table + BGS_table[n]);
Si mes souvenirs sont bons.

en fait je pense que ce qu'a mis jackiechan doit fonctionner mais SYM_ENTRY *Adresse = SymFindPtr($("metgfx"),NULL); me renvoie un pointeur NULL alors que le fichier est dans la calc! tres tres etrange!!!

$("metgfx") est faux. C'est soit $(metgfx), soit SYMSTR("metgfx").

vous allez rire: ca marche
merci Kevin pour cette fabuleuse réponse! si ca ce trouve ca marchait depuis le debut!

Ah oui, je me suis trompé. Désolé

il ne me reste plus qu'à mettre les map en fichier externe.
la aussi j'aurais besoin de savoir comment savoir la place que ca va prendre sachant que je part des .bin et .lvl de plane.
En attendant je V a mon entrainement, je verrai si je suis pas fatigué pour m'y remettre ce soir.

Entrainement de quoi ?
Sinon, pour la taille, ça dépend, il faut voir dans les structures de genlib comment elles sont foutues...

de kendo, la coupe des alpes et le tournoi inter-region kiusha arrive tres bien tot en plus.

G réussi a mettre un plan dans un fichier externe puis a le recupérer comme on a fait juste avant mais... LA PLACE QUE CA PREND!!! arrrggghhh. je croi que je V chercher une autre methode

C bon G trouvé comment faire. en fait ca prend bcp de place parce que dans certaines map il peut y avoir bcp de tiles. vu que 1 tile prend 16*8=128 octets et qu'une de mes map en demande pres de 150 + la matrice de tiles + ma matrice concernant les objets (+ celle des evenements) + quelques infos = ... bcp

je V laisser le jeu en stand-by le temps d'optimiser mes dump avec sensconv afin de créer un tableau de tile contenant vraiment ce qui est necessaire.

Compresse-le (si ce n'est déjà fait)