#include "filtres.h"

//Ces fonctions lisent dans les fichiers .c pour en ressortir et afficher dans hdcImage2
//le résultat.

void LitBmp16(int i)		{
	FILE *f;
	int x,y,c,j,z;
	unsigned char r,v,b;
	char *bloc=(char*)malloc(TAILLE_MAXIMUM);

	ChoisitFormatFichierExtension(elements[i].nom_fichier);
	f=fopen(elements[i].nom_fichier,"rb");
	if (!f)		{
		free(bloc);
		MessageBox(gblHDlg,"Le fichier bitmap 16 bits spécifié n'existe pas",elements[i].nom_fichier,MB_ICONERROR);
		return;
	}


	EffaceEcran(Bits2);

	ReinitSymTable();
	PrepareSymTable(1);

	taille_totale=fread(bloc,1,TAILLE_MAXIMUM,f);

	j=LitChaineFiltree(0,bloc,b16_declaration,f);
	if (j>taille_totale)
		return;

	RedimDIB(tailleX,tailleY,FALSE);

	for (y=0;y<tailleY;y++)			{
		for (x=0;x<tailleX;x++)		{
			if (*b16_fin_ligne)
				z=x;
			else
				z=x+y*tailleX;
			if (b16_nbChaqueX>0 && z>0 && z%b16_nbChaqueX==0)
				j=LitChaineFiltree(j,bloc,b16_chaque_x,f);

			j=LitValeur(j,bloc,b16_chaque_valeur,f,&c);

			r=c&0x1F;
			v=(c&0x3E0)>>5;
			b=(c&0x7C00)>>10;
			DessPix(Bits2,x,y,RGB(r<<3,v<<3,b<<3));

/*			k=0;
			sscanf(chaque_valeur,&fuck);
			while(!feof(f))		{
				c=fgetc(f);
				if (c=='x')
					break;
				str[k++]=c;
			}
			c=atox(str);
			r=c&0x1F;
			v=(c&0x3E0)>>5;
			b=(c&0x7C00)>>10;
			DessPix(Bits2,x,y,RGB(r<<3,v<<3,b<<3));*/
		}
		j=LitChaineFiltree(j,bloc,b16_fin_ligne,f);
	}

	fclose(f);

	c=LitChaineFiltree(0,bloc,b16_fin_declaration,f);


/*	if (strcmp(str,"//Converti avec GBA Graphics par Brünni\n"))		{
		MessageBox(gblHDlg,"Le format n'est pas celui de GBA Graphics",elements[i].nom_fichier,MB_ICONERROR);
		fclose(f);
		return;
	}
	fgets(str,1000,f);
	if (strcmp(str,"//Bitmap 16 bits\n"))		{
		MessageBox(gblHDlg,"Cela ne semble pas être une bitmap 16 bits",elements[i].nom_fichier,MB_ICONERROR);
		fclose(f);
		return;
	}
	fgets(str,1000,f);
	if (strncmp(str,"//Taille: ",10))		{
		MessageBox(gblHDlg,"La taille n'a pas l'air définie correctement","Erreur fatale",MB_ICONERROR);
		fclose(f);
		return;
	}*/

/*	tailleX=tailleY=0;
	ptr=str+10;
	tailleX=atoi(ptr);
	while(*ptr!='*' && *ptr)
		ptr++;
	ptr++;
	tailleY=atoi(ptr);*/
/*
	while(!feof(f) && fgetc(f)!='{');
	while(!feof(f) && fgetc(f)!='x');
//	RedimDIB(tailleX,tailleY);

	for (y=0;y<tailleY;y++)
		for (x=0;x<tailleX;x++)		{
			k=0;
			while(!feof(f))		{
				c=fgetc(f);
				if (c=='x')
					break;
				str[k++]=c;
			}
			c=atox(str);
			r=c&0x1F;
			v=(c&0x3E0)>>5;
			b=(c&0x7C00)>>10;
			DessPix(Bits2,x,y,RGB(r<<3,v<<3,b<<3));
		}
	fclose(f);*/
	free(bloc);
}

int LitPalette(unsigned char *palette, char *nom_fichier)		{
	FILE *f;
	int c,j, nbCouleurs;
	char *bloc=(char*)malloc(TAILLE_MAXIMUM);

	ChoisitFormatFichierExtension(nom_fichier);
	f=fopen(nom_fichier,"rb");
	if (!f)		{
		free(bloc);
		MessageBox(gblHDlg,"Le fichier palette spécifié n'existe pas.", nom_fichier, MB_ICONERROR);
		return 0;
	}

	ReinitSymTable();
	PrepareSymTable(1);

	InitSymbole(6,gblcPal);							//%link%

	taille_totale=fread(bloc,1,TAILLE_MAXIMUM,f);

	j=LitChaineFiltree(0,bloc,pal_declaration,f);
	if (j>taille_totale)
		return 0;


	nbCouleurs=0;
//	palette+=3;
	memset(palette,0,256*3);

	while(1)		{
		j=LitValeur(j,bloc,pal_chaque_valeur,f,&c);
		if (j>taille_totale)
			break;

		*palette++=((c&0x7C00)>>10)<<3;
		*palette++=((c&0x3E0)>>5)<<3;
		*palette++=(c&0x1F)<<3;
		nbCouleurs++;

		if (pal_nbChaqueX>0 && nbCouleurs>0 && nbCouleurs%pal_nbChaqueX==0)
			j=LitChaineFiltree(j,bloc,pal_chaque_x,f);

		if (nbCouleurs>=256)
			break;
	}

	fclose(f);
	free(bloc);

	return nbCouleurs;
}

void LitBmp8(int i)		{
	FILE *f;
	int x,y,c,j,z, nbCouleurs;
	unsigned char *palette;
	char *bloc=(char*)malloc(TAILLE_MAXIMUM);

	ChoisitFormatFichierExtension(elements[i].nom_fichier);
	f=fopen(elements[i].nom_fichier,"rb");
	if (!f)		{
		free(bloc);
		MessageBox(gblHDlg,"Le fichier bitmap 8 bits spécifié n'existe pas",elements[i].nom_fichier,MB_ICONERROR);
		return;
	}

	EffaceEcran(Bits2);

	ReinitSymTable();
	PrepareSymTable(1);

	InitSymbole(6,gblcPal);							//%link%

	taille_totale=fread(bloc,1,TAILLE_MAXIMUM,f);

	j=LitChaineFiltree(0,bloc,b8_declaration,f);
	if (j>taille_totale)
		return;

	palette=(unsigned char*)malloc(3*256);

	nbCouleurs=LitPalette(palette,gblcPal);
	if (!nbCouleurs)		{
		free(bloc);
		fclose(f);
		return;
	}

	RedimDIB(tailleX,tailleY,FALSE);
	for (y=0;y<tailleY;y++)			{
		for (x=0;x<tailleX;x++)		{
			if (*b8_fin_ligne)
				z=x;
			else
				z=x+y*tailleX;

			if (b8_nbChaqueX>0 && z>0 && z%b8_nbChaqueX==0)
				j=LitChaineFiltree(j,bloc,b8_chaque_x,f);

			j=LitValeur(j,bloc,b8_chaque_valeur,f,&c);

			if (c>=0 || c<nbCouleurs)
				DessPix(Bits2,x,y,RGB(palette[3*c+2],palette[3*c+1],palette[3*c]));
		}
		j=LitChaineFiltree(j,bloc,b8_fin_ligne,f);
	}

	fclose(f);
	free(bloc);
	free(palette);
}


int LitTileset(unsigned char *palette,unsigned long **motiv, const char *nom, int original)		{
	FILE *f;
	int x,c,k,j,z, nEcrits, realTileX, realTileY;
	unsigned long *motifs;
	char bits[100];
	char *bloc=(char*)malloc(TAILLE_MAXIMUM);

	motifs=*motiv;

	EffaceEcran(Bits2);

	ChoisitFormatFichierExtension(nom);
	f=fopen(nom,"rb");
	if (!f)		{
		free(bloc);
		MessageBox(gblHDlg,"Le fichier tileset spécifié n'existe pas",nom,MB_ICONERROR);
		return 0;
	}

	ReinitSymTable();
	PrepareSymTable(1);

	InitSymbole(6,gblcPal);							//%link%
	InitSymbole(12,bits);							//%bits%
	bits[0]=0;

	taille_totale=fread(bloc,1,TAILLE_MAXIMUM,f);

	k=LitChaineFiltree(0,bloc,til_declaration,f);
	if (k>taille_totale)
		return 0;

	taille=(int)symboles[3].donnees;

	b16coul=0, bTil32Bits=0;
	//Pour trouver la profondeur (bits)
	if ((int)symboles[9].donnees==0)	{					//%depth%
/*		if (!strcmp(bits,tileset4))							//%bits%
			b16coul=1;
		else if (!strcmp(bits,tileset16))					//%bits%
			bTil32Bits=1;*/
	}
	else if ((int)symboles[9].donnees==15)					//%depth%
		bTil32Bits=1;
	else if ((int)symboles[9].donnees==4)					//%depth%
		b16coul=1;

	if (palette && !bTil32Bits)			{
		if (!LitPalette(palette,gblcPal))		{
			free(bloc);
			fclose(f);
			return 0;
		}
	}

	//Toujours du 8x8!!!!
	taille*=(tileX/8)*(tileY/8);
//	tileX=tileY=8;

	vraieTaille=taille;

	if (!motifs)		{
/*		if (emul_gba)	{
			taille=1024;
			motifs=(unsigned long*)malloc(tileX*tileY*1024*sizeof(long));
		}
		else*/
			motifs=(unsigned long*)malloc(tileX*tileY*taille*sizeof(long));
		utilMemoire+=tileX*tileY*taille;
		*motiv=motifs;
	}


	nEcrits=0;

/*	for (j=0;j<taille;j++)		{
		if (j>=TILEMAX)		{
			MessageBox(gblHDlg,"Le nombre de tiles est supérieur à la mémoire. Le format serait-il faux?",nom,MB_ICONERROR);
			fclose(f);
			free(motifs);
			*motiv=NULL;
			taille=0;
			free(bloc);
			return taille-1;
		}

		for (x=0;x<tileY*tileX;x++)			{
			if (*til_fin_ligne)
				z=x;
			else
				z=nEcrits;

			if (til_nbChaqueX>0 && z>0 && z%til_nbChaqueX==0)
				k=LitChaineFiltree(k,bloc,til_chaque_x,f);

			if (bTil32Bits==1)
				k=LitValeur(k,bloc,til_chaque_valeur_3,f,&c);
			else if (b16coul)
				k=LitValeur(k,bloc,til_chaque_valeur_2,f,&c);
			else
				k=LitValeur(k,bloc,til_chaque_valeur_1,f,&c);

			if (bTil32Bits==1)		{
				if (!original)		{
					if (c == 0xffff)
						c = 0xff000000 | RGB(GetBValue(cFond), GetGValue(cFond), GetRValue(cFond));
					else
						c= RGB (((c&0x7C00)>>10)<<3, ((c&0x3E0)>>5)<<3, (c&0x1F)<<3);
				}
				motifs[(j*tileX*tileY)+x]=c;
			}
			else if (b16coul)		{
				motifs[(j*tileX*tileY)+x+1]=(c>>4)&0xf;
				motifs[(j*tileX*tileY)+x]=c&0xf;
				x++;
			}
			else
				motifs[(j*tileX*tileY)+x]=c;

			nEcrits++;
		}
		k=LitChaineFiltree(k,bloc,til_fin_ligne,f);
	}*/
	realTileX=tileX, realTileY=tileY;
	tileX=tileY=8;
	for (j=0;j<taille;j++)		{
		if (j>=TILEMAX)		{
			MessageBox(gblHDlg,"Le nombre de tiles est supérieur à la mémoire. Le format serait-il faux?",nom,MB_ICONERROR);
			fclose(f);
			free(motifs);
			*motiv=NULL;
			taille=0;
			free(bloc);
			return taille-1;
		}

		for (x=0;x<tileY*tileX;x++)			{
			if (*til_fin_ligne)
				z=x;
			else
				z=nEcrits;

			if (til_nbChaqueX>0 && z>0 && z%til_nbChaqueX==0)
				k=LitChaineFiltree(k,bloc,til_chaque_x,f);

			if (bTil32Bits==1)
				k=LitValeur(k,bloc,til_chaque_valeur_3,f,&c);
			else if (b16coul)
				k=LitValeur(k,bloc,til_chaque_valeur_2,f,&c);
			else
				k=LitValeur(k,bloc,til_chaque_valeur_1,f,&c);

			if (bTil32Bits==1)		{
				if (!original)		{
					if (c == 0xffff)
						c = 0xff000000 | RGB(GetBValue(cFond), GetGValue(cFond), GetRValue(cFond));
					else
						c= RGB (((c&0x7C00)>>10)<<3, ((c&0x3E0)>>5)<<3, (c&0x1F)<<3);
				}
				motifs[(j*tileX*tileY)+x]=c;
			}
			else if (b16coul)		{
				motifs[(j*tileX*tileY)+x+1]=(c>>4)&0xf;
				motifs[(j*tileX*tileY)+x]=c&0xf;
				x++;
			}
			else
				motifs[(j*tileX*tileY)+x]=c;

			LitValeur(k,bloc,til_chaque_valeur_3,f,&c);
			nEcrits++;
		}
		k=LitChaineFiltree(k,bloc,til_fin_ligne,f);
	}
	tileX=realTileX, tileY=realTileY;

	if (vraieTaille<taille)
		taille=vraieTaille;

	fclose(f);
	free(bloc);
	return taille;
}


void DessinePalette(unsigned char *palette, int nbCoul)		{
	int x,y,i;

//	EffaceEcran();
//	RedimDIB(256,256);
	ColoreCadre(Bits2,0,0,LARG,HAUT,cFond);
	i=nbCoul/16;
	if (nbCoul%16)
		i++;
	RedimDIB(16,i,FALSE);
	i=0;
	for (y=0;y<16;y++)		{
		for (x=0;x<16;x++)		{
			if (i>=nbCoul)
				goto fin;
			DessPix(Bits2,x,y,RGB(palette[3*i+2],palette[3*i+1],palette[3*i]));
			i++;
		}
	}
fin:
	tailleX=16;
	if (x<16)
		y++;
	tailleY=y;
}

void DessineTileset(unsigned char *palette,unsigned long *motifs)			{
	int x,y,i, xx, yy;
//	EffaceEcran();
	ColoreCadre(Bits2,0,0,LARG,HAUT,cFond);
	palette[0]=(cFond&0x00ff0000)>>16;
	palette[1]=(cFond&0x0000ff00)>>8;
	palette[2]=cFond&0x000000ff;
//	RedimDIB(256,1024);


	//Calcule la hauteur du tileset
	i = tileY * ((taille/((tileX*tileY)/64))/tileX);
	if ((taille/((tileX*tileY)/64))%tileX > 0)
		i += tileY;

/*	i = tileY*(taille/(256/tileX));
	i=taille/32;
	if (taille%32)
		i++;*/
	RedimDIB(256,i,FALSE);

	i=0;
	taille/=(tileX*tileY)/64;
	for (y=0;y<HAUT;y+=tileY)		{
		for (x=0;x<256;x+=tileX)		{
			if (i>=taille)
				goto fin;
			for (yy=0;yy<tileX;yy+=8)
				for (xx=0;xx<tileX;xx+=8)
					SpritePalSansMasque(Bits2,x+xx,y+yy,8,8,motifs+(i*tileX*tileY)+64*(tileX/8)*(yy/8)+64*(xx/8),palette);
//			ColoreCadre(x,y,16,16,RGB(255,0,0));
			i++;
		}
	}
fin:
	tailleX=256;
	tailleY=y+tileY;
}


//Types de variables: voir types_objets dans le fichier "definitions.h"
/*
void *variables[][3]=	{
	//Rajoutez vos variables selon le format suivant (entiers seulement)
	//{"nom (dans le fichier)", &variable (pointeur sur la variable int), (void*)type (TYPE_ENTIER seulement)},
};
*/

char *ProchArgEntier(char *ptr)		{
	int compteParentheses=0;

	while(1)		{
		if (*ptr==0)
			break;
		if (*ptr=='(')
			compteParentheses++;
		if (compteParentheses==0)		{
			if (*ptr==',' || *ptr==' ' || *ptr==')')		{
				ptr++;
				break;
			}
		}
		if (*ptr==')')
			compteParentheses--;
		ptr++;
	}
	while(*ptr==' ' || *ptr=='	')
		ptr++;
	return ptr;
}

int EstUnNombre(char *valeur)			{
	BOOL bHexa=FALSE;
	if (*valeur==0)
		return FALSE;
	if (*valeur=='0')		{
		valeur++;
		if (*valeur=='x')
			valeur++, bHexa=TRUE;
		else if (*valeur=='b')
			valeur++;
		else
			return FALSE;
	}
	while(*valeur)		{
		//Digit hexa?
		if ((*valeur>='A' && *valeur<='F') || (*valeur>='a' && *valeur<='f'))		{
			if (!bHexa)
				return FALSE;
			else		{
				//En mode hexa -> ok
				valeur++;
				continue;
			}
		}
		if (*valeur<'0' || *valeur>'9')
			return FALSE;
		valeur++;
	}
	return TRUE;
}

int GetEntier(char *valeur)		{
	int r,v,b;

	if (*valeur<'0' || *valeur>'9')		{
		if (*valeur=='t' || *valeur=='v')
			return 1;
		else if (*valeur=='f')
			return 0;
		else if (!strncmp(valeur,"rgb",3))		{
			valeur+=3;
			while(*valeur!='(' && *valeur)	valeur++;
			if (!(*valeur))
				return 0;
			valeur++;
			r=GetEntier(valeur);
			valeur=ProchArgEntier(valeur);
			v=atoi(valeur);
			valeur=ProchArgEntier(valeur);
			b=GetEntier(valeur);
			return RGB(r,v,b);
		}
		return 0;
	}
	if (*valeur=='0')		{
		valeur++;
		if (*valeur=='x')
			return atox(valeur+1);
		else if (*valeur=='b')		{
			return atob(valeur+1);
		}
		else
			return atoi(valeur);
	}
	return atoi(valeur);
}
/*
void AnalyseVariables(char *ptr)		{
	char *variable, *valeur;
	int Continue, i, type;

refait:
	while(*ptr==' ')	ptr++;
	if (*ptr==0 || *ptr=='\n')
		return;
	variable=ptr;
	while(*ptr && *ptr!='=')	ptr++;
	if (!(*ptr))
		return;
	*ptr++=0;
	valeur=ptr;
	while(*ptr && *ptr!='\n' && *ptr!=' ')	ptr++;
	if (!(*ptr))
		return;
	if (*ptr==' ')
		Continue=TRUE;
	else
		Continue=FALSE;
	*ptr++=0;


	for (i=0;i<sizeof(variables)/sizeof(variables[0]);i++)		{
		if (!strcmp(variable,(const char*)variables[i][0]))		{
			type=(int)variables[i][2];
			if (type==TYPE_ENTIER)
				*(int*)variables[i][1]=GetEntier(valeur);
		}
	}

	if (Continue)
		goto refait;
}

void InitVariables()		{
	//Mettez ici les variables à initialiser
}*/


int LitMap(unsigned char *palette, unsigned long **motifs, MAP **umap, int i)		{
	FILE *f;
	char temp[4096];
	int x,y,c, ii=i, j, tX, tY, z;
	MAP *map=*umap;
	char *bloc=(char*)malloc(TAILLE_MAXIMUM);
	char tempGblUserData[NB_MAX_USERDATA][TAILLE_MAX_CHAINES];

	EffaceEcran(Bits2);

	strcpy(gblcMap,elements[i].nom_fichier);

	ChoisitFormatFichierExtension(elements[i].nom_fichier);
	f=fopen(elements[i].nom_fichier,"rb");
	if (!f)		{
		free(bloc);
		MessageBox(gblHDlg,"Le fichier map spécifié n'existe pas",elements[i].nom_fichier,MB_ICONERROR);
		return 0;
	}

	ReinitSymTable();
	PrepareSymTable(1);
	InitSymbole(5,gblcNomC);						//%name%
	InitSymbole(6,gblcTil);							//%link%
	InitSymbole(10,temp);							//%type%
	gfxmask=0xffffffff;

	taille_totale=fread(bloc,1,TAILLE_MAXIMUM,f);
	ii=taille_totale;

	j=LitChaineFiltree(0,bloc,map_declaration,f);
	if (j>taille_totale)
		return 0;
	memcpy(tempGblUserData, gblUserData, sizeof(gblUserData));

	tX=tileX, tY=tileY;

//	RedimDIB(tailleX*tileX,tailleY*tileY);

//	InitVariables();					//Réinitialise le système de variables...
//	memset(chneVariables,0,sizeof(chneVariables));

	if ((int)symboles[9].donnees==0)	{					//%depth%
		if (!strcmp(temp,type32))							//%bits%
			ModeTexte=2;
		else if (!strcmp(temp,type8))							//%bits%
			ModeTexte=0;
		else
			ModeTexte=1;
	}
	else if ((int)symboles[9].donnees==32)					//%depth%
		ModeTexte=2;
	else if ((int)symboles[9].donnees==8)					//%depth%
		ModeTexte=0;
	else
		ModeTexte=1;


	if (*gblcTil)
		taille=LitTileset(palette,motifs,gblcTil,0);
	if (!taille)		{
		free(bloc);
		fclose(f);
		return 0;
	}

	if (!(*umap))		{
		map=(MAP*)malloc(tailleX*tailleY*sizeof(MAP));
		//Décommenter pour obtenir la consommation mémoire dans l'éditeur (il y en a ailleurs à décommenter encore)
//		utilMemoire+=tailleX*tailleY*2;
		memset(map,0,tailleX*tailleY*sizeof(MAP));
		*umap=map;
	}

	taille_totale=ii;

	tileX=tX, tileY=tY;

	taille/=(tileX*tileY)/64;

	for (y=0;y<tailleY;y++)			{
		for (x=0;x<tailleX;x++)		{
			if (*map_fin_ligne)
				z=x;
			else
				z=(y*tailleX)+x;

			if (map_nbChaqueX>0 && z>0 && z%map_nbChaqueX==0)
				j=LitChaineFiltree(j,bloc,map_chaque_x,f);

			if (ModeTexte==2)
				j=LitValeur(j,bloc,map_chaque_valeur_3,f,&c);
			else if (ModeTexte==1)
				j=LitValeur(j,bloc,map_chaque_valeur_1,f,&c);
			else
				j=LitValeur(j,bloc,map_chaque_valeur_2,f,&c);

			if (j>taille_totale)
				goto fin;

			map[tailleX*y+x]=c;
		}
		j=LitChaineFiltree(j,bloc,map_fin_ligne,f);
	}

fin:
	fclose(f);
	free(bloc);
	memcpy(gblUserData, tempGblUserData, sizeof(gblUserData));

	return 1;
}

int CalcSdSize(SD_PARAMS *p)			{
	if (p->sdNumParams<=0)
		return sizeof(SPRITE_DEF);
	else		{
		int i, r;
		r=0;
		for (i=0;i<p->sdNumParams;i++)		{
			r += p->sdTaillesParam[i];
		}
		return sizeof(SPRITE_DEF)+r;
	}
}

BOOL AppliqueSdModele(char *nomModele)			{
	int i;
	for (i=0;i<sdNbreModeles;i++)			{
		if (!strcmp(sdParams[i].sdNomModele, nomModele))
			break;
	}
	if (i>=sdNbreModeles)
		return FALSE;
	else			{
		sdParams[i].sizeofSD=CalcSdSize(&sdParams[i]);
		gblSdModele = i;
		return TRUE;
	}
}

int LitChaineTypes(int j, char *bloc, char *chaine, FILE *f, SPRITE_DEF *sd, int bPasErreur, char *fin_ligne);

int LitListe(unsigned char *palette,unsigned long **motifs, MAP **umap, int i)		{
	FILE *f;
	char temp[4096];
	int ii=i, j, tX, tY, lastJ;
	MAP *map=*umap;
	char *bloc=(char*)malloc(TAILLE_MAXIMUM);
	char nomModele[TAILLE_MAX_CHAINES];
	char tempGblUserData[NB_MAX_USERDATA][TAILLE_MAX_CHAINES];

	EffaceEcran(Bits2);

	strcpy(gblcMap,elements[i].nom_fichier);

	ChoisitFormatFichierExtension(elements[i].nom_fichier);
	f=fopen(elements[i].nom_fichier,"rb");
	if (!f)		{
		free(bloc);
		MessageBox(gblHDlg,"Le fichier map spécifié n'existe pas",elements[i].nom_fichier,MB_ICONERROR);
		return 0;
	}

	strcpy(nomModele, sdParams[gblSdModele].sdNomModele);
	ReinitSymTable();
	PrepareSymTable(1);
	InitSymbole(5,gblcNomC);						//%name%
	InitSymbole(6,gblcTil);							//%link%
	InitSymbole(10,gblTypeSd);						//%type%
	InitSymbole(15,nomModele);						//%model%
	gfxmask=0xffffffff;

	taille_totale=fread(bloc,1,TAILLE_MAXIMUM,f);
	ii=taille_totale;

	j=LitChaineFiltree(0,bloc,lst_declaration,f);
	if (j>taille_totale)
		return 0;

	memcpy(tempGblUserData, gblUserData, sizeof(gblUserData));
	if (!AppliqueSdModele(nomModele))			{
		sprintf(str, "Impossible de spécifier le modèle de paramètres spécifié: %s", nomModele);
		MessageBox(gblHDlg, str, "Erreur", MB_ICONEXCLAMATION);
		return 0;
	}

	MajFichierParams();

	//Initialisation de la liste
	gblSpriteListe.sizeofSD=sdParams[gblSdModele].sizeofSD;
	gblSpriteListe.sd=(SPRITE_DEF*)realloc(gblSpriteListe.sd, NB_MAX_ELE_LISTE*gblSpriteListe.sizeofSD);
	gblSpriteListe.nbSprites=(int)symboles[3].donnees;

	tX=tileX, tY=tileY;

//	RedimDIB(tailleX*tileX,tailleY*tileY);

//	InitVariables();					//Réinitialise le système de variables...
//	memset(chneVariables,0,sizeof(chneVariables));

	taille=LitTileset(palette,motifs,gblcTil,0);
	if (!taille)		{
		free(bloc);
		fclose(f);
		return 0;
	}

/*	if (!(*umap))		{
		map=(MAP*)malloc(tailleX*tailleY*sizeof(MAP));
		//Décommenter pour obtenir la consommation mémoire dans l'éditeur (il y en a ailleurs à décommenter encore)
//		utilMemoire+=tailleX*tailleY*2;
		memset(map,0,tailleX*tailleY*sizeof(MAP));
		*umap=map;
	}*/

	taille_totale=ii;
	tileX=tX, tileY=tY;
	tailleX/=tileX; tailleY/=tileY;
	taille/=(tileX*tileY)/64;

	if (gblSpriteListe.nbSprites>NB_MAX_ELE_LISTE)			{
		free(bloc);
		fclose(f);
		MessageBox(NULL, "Impossible de charger la liste car elle contient plus d'éléments qu'alloués. Modifiez le nombre maximal d'éléments par liste dans les options.", elements[i].nom_fichier, MB_ICONEXCLAMATION);
		return 0;
	}

	gblErrorFlag = 0;
	lastJ = j;
	for (i=0;i<gblSpriteListe.nbSprites;i++)		{
		if (lst_nbChaqueX>0)		{
			if (i%lst_nbChaqueX==0)
				j=LitChaineFiltree(j,bloc,lst_chaque_x,f);
		}

/*		j=LitValeur(j,bloc,lst_chaque_valeur_1,f,&c);


		map[tailleX*y+x]=c;*/

		j=LitChaineTypes(j,bloc,lst_chaque_valeur_ok,f,_SD(gblSpriteListe,i), 0, NULL);
		if (j>taille_totale)
			break;

//		Debug("ICI");

		j=LitChaineFiltree(j,bloc,lst_fin_ligne,f);
	}

	if (gblErrorFlag)		{
		SD_PARAMS *sdp=&sdParams[gblSdModele];
		memset(gblSpriteListe.sd, 0, NB_MAX_ELE_LISTE*gblSpriteListe.sizeofSD);
		if (MessageBox(gblHDlg, "Le format de la liste est incorrect, un algorithme plus souple et déductif va être tentée pour pouvoir récupérer le fichier malgré d'éventuels changements dans le modèle de paramètres. Cette opération peut échouer, vous devriez donc vérifier si la liste d'objets est bien correcte et ne l'enregistrer que si c'est le cas.", "Attention", MB_ICONEXCLAMATION|MB_OKCANCEL)!=IDOK)			{
			fclose(f);
			free(bloc);
			return 0;
		}
		for (j=0;j<gblSpriteListe.nbSprites;j++)		{
			SPRITE_DEF *sd=_SD(gblSpriteListe,j);
			for (i=0;i<sdp->sdNumParams;i++)			{
				if (sdp->sdTypeParam[i]==SDT_ENTIER)			{
					int *ptr;
					ptr= (int*)((char*)sd->params+GetParamOffset(i));
					*ptr = GetEntier(sdp->sdTexteDefaut[i]);
				}
				else if (sdp->sdTypeParam[i]==SDT_BRUT)			{
					char *cptr;
					cptr=(char*)sd->params+GetParamOffset(i);
					strcpy(cptr,sdp->sdTexteDefaut[i]);
				}
			}
		}
//		memset(gblSpriteListe.sd, 0, NB_MAX_ELE_LISTE*gblSpriteListe.sizeofSD);
		//Erreur -> tente de l'importer à la manière forte!
		gblErrorFlag = 0;
		j = lastJ;
		//Fin de ligne
		if (!lst_fin_ligne[0])		{
			//Depuis le dernier #
			for (i=strlen(lst_chaque_valeur_ok)-1;i>=0;i--)		{
				if (lst_chaque_valeur_ok[i]=='#')
					break;
			}
			if (i>=0)
				strcpy(temp, lst_chaque_valeur_ok+i+1);
		}
		else
			strcpy(temp, lst_fin_ligne);
		for (i=0;i<gblSpriteListe.nbSprites;i++)		{
			if (lst_nbChaqueX>0)		{
				if (i%lst_nbChaqueX==0)
					j=LitChaineFiltree(j,bloc,lst_chaque_x,f);
			}

	/*		j=LitValeur(j,bloc,lst_chaque_valeur_1,f,&c);


			map[tailleX*y+x]=c;*/

			j=LitChaineTypes(j,bloc,lst_chaque_valeur_ok,f,_SD(gblSpriteListe,i), 2, temp);
			if (j>taille_totale)
				break;

	//		Debug("ICI");

			j=LitChaineFiltree(j,bloc,lst_fin_ligne,f);
		}
	}

	fclose(f);
	free(bloc);
	memcpy(gblUserData, tempGblUserData, sizeof(gblUserData));

	return 1;
}



void DessineTile(unsigned char *Bits, int x, int y, PARAM *p, unsigned short tile, int alpha)		{
	if (p->b16coul)		{
		if (alpha)
			TransSpritePalMiroir(Bits,x,y,8,8,p->gblMotifs+(tile&1023)*64,p->gblPal+3*(((tile&0xf000)>>12)<<4),tile&0x400,tile&0x800,15,alpha);
		else
			SpritePalMiroir(Bits,x,y,8,8,p->gblMotifs+(tile&1023)*64,p->gblPal+3*(((tile&0xf000)>>12)<<4),tile&0x400,tile&0x800,15);
	}
	else		{
		if (alpha)
			TransSpritePalMiroir(Bits,x,y,8,8,p->gblMotifs+(tile&1023)*64,p->gblPal,tile&0x400,tile&0x800,255,alpha);
		else
			SpritePalMiroir(Bits,x,y,8,8,p->gblMotifs+(tile&1023)*64,p->gblPal,tile&0x400,tile&0x800,255);
	}
}

void DessineTileSansMasque(unsigned char *Bits, int x, int y, PARAM *p, unsigned short tile, int alpha)		{
	if (p->b16coul)		{
		if (alpha)
			TransSpritePalMiroirSansMasque(Bits,x,y,8,8,p->gblMotifs+(tile&1023)*64,p->gblPal+3*(((tile&0xf000)>>12)<<4),tile&0x400,tile&0x800,15,alpha);
		else
			SpritePalMiroirSansMasque(Bits,x,y,8,8,p->gblMotifs+(tile&1023)*64,p->gblPal+3*(((tile&0xf000)>>12)<<4),tile&0x400,tile&0x800,15);
	}
	else		{
		if (alpha)
			TransSpritePalMiroirSansMasque(Bits,x,y,8,8,p->gblMotifs+(tile&1023)*64,p->gblPal,tile&0x400,tile&0x800,255,alpha);
		else
			SpritePalMiroirSansMasque(Bits,x,y,8,8,p->gblMotifs+(tile&1023)*64,p->gblPal,tile&0x400,tile&0x800,255);
	}
}


void DessineMap(unsigned char *palette, unsigned long *motifs, MAP *map)			{
	int x,y,i, xx, yy;
	PARAM p;

	i=0;
	palette[0]=(cFond&0x00ff0000)>>16;
	palette[1]=(cFond&0x0000ff00)>>8;
	palette[2]=cFond&0x000000ff;

	p.gblMap=map;
	p.gblMotifs=motifs;
	p.gblPal=palette;
	p.b16coul=b16coul;

//	mX=scrlX%tileX;
//	mY=scrlY%tileY;

	RedimDIB(tailleX*tileX,tailleY*tileY,FALSE);
	for (y=0;y<tailleY;y++)		{
		for (x=0;x<tailleX;x++)		{
			if (x>=LARG/tileX)
				break;
			i=map[tailleX*y+x]+blocBase;
			i&=gfxmask;
			//Motif non-valide (ne devrait pas arriver)
//			if (!emul_gba)		{
				if ((i&gbatilmask)>=taille || i<0)
					continue;
//			}
			if (!Editer)		{
				for (yy=0;yy<tileY;yy+=8)
					for (xx=0;xx<tileX;xx+=8)		{
						if (emul_gba)
							DessineTile(Bits2,x*tileX+xx,y*tileY+yy,&p,(i*tileX*tileY)/64+(tileX/8)*(yy/8)+(xx/8),0);
						else
							SpritePalSansMasque(Bits2,x*tileX+xx,y*tileY+yy,8,8,motifs+(i*tileX*tileY)+64*(tileX/8)*(yy/8)+64*(xx/8),palette);
					}
			}
//			ColoreCadre(x,y,16,16,RGB(255,0,0));
		}
		if (y>=HAUT/tileY)
			break;
	}
	tailleX*=tileX;
	tailleY*=tileY;
}

