[Dreamcast] Portage Traduction Grandia 2 PC sur Dreamcast

[dragoncity]

C'est bon on a reussi mais c'etait un peu plus complique sachant que le logiciel dreamcast movie est compatible win98 lol

Du coup on a reussi autrement avec 3 logiciels.

Bon... on verifie et la beta devrait pas tarder

[cloud]

Ok pas de soucis, ça plaisir que vous réussissez à avancer.

[corrigo]

Du coup on a reussi autrement avec 3 logiciels.

Lesquels ?

[dragoncity]

Avec Demux pour extraire le SFD en 2 parties : Audio (sfa) et Video (m1v)

On a du modifié le script en récupérant que cette partie :

Code : Tout sélectionner

@ECHO OFF

cd in
for %%1 in (*.sfd) do ..\demux %%1 ..\out\%%~n1
cd ..\out
ren *.m2v *.m1v
ren *.m2a *.sfa

ECHO.
ECHO DONE!
ECHO.

pause

Ensuite ouvrir le fichier m1v avec Virtual Dub pour insérer les sous titres .SRT

Puis enregistrer en AVI (full compression).

Puis convertir en m1v avec TMPGEnc.

Puis finir par recompiler le m1v et notre sfa

avec ce code :

Code : Tout sélectionner

sfdmux -V=CG13_e0 -A=CG13_c0 -S=CG13.sfd

Bref pas du simple mais ça marche

De toute façon RIEN est simple depuis le début.. et la encore une phrase qui passe en anglais mais pas en FR en recompilant avec gr2dump9 ..

<portrait num="0036"/>So that's a Geohound...
>
<portrait num="0036"/>Alors c'est ça, un Geohound...

Pourquoi ça c'est la question !

Donc encore du boulot car je pensais que les 51% était finit mais si ça bloque sur des choses comme ça..

[BahaBulle]

Peut-être que c'est à cause de la longueur de la phrase FR qui est plus longue que la version US, surtout si vous ne gérez pas les pointeurs.

[dragoncity]

Justement on gere les pointeurs avec l'outil des italiens gr2dump9... ça fonctionnait mais la je sais pas pourquoi sur ce fichier non..

[dragoncity]

A titre info voilà comment sont gérés les pointeurs (c'est une usine à gaz ...)

On a simplement compris la partie table pour y rajouter les accents manquant au début.

Code : Tout sélectionner

/*
03-3
04-1
05-2
06-3
07-5
08-3
09-4
0A-6 ?
0B-2
0C-1 ?
0D-1
0E-3
0F-1
10-7 ?
11-3
14-5
15-4
16-2 ?
17-1/3
18-2
1C-1
1D-2/3
1E-1
*/

/*
Info su beta5 by chop:
Ho semplicente modificato alla meno peggio le routine di estrazione/inserimento
per gestire direttamente gli archivi anzichè la singola parte del testo
Il programma si occupa anche dell'aggiornamento dei puntatori dei file che seguono
il testo in modo da poter permettere una evntuale espansione del testo.
NOTA BENE: questa funzionalità è stata testata solo parzialmente, quindi potrebbero
esserci dei casi in cui non funzioni correttamente.

Info su Beta6b by chop:
- Modificato opcode 1D: Ha 2 parametri se il primo è FF altrimenti ne ha 3

Beta7
- Lettere accentate
- Risolto loop su caratteri non validi
- Messaggi di debug vari

Beta8
- aggiunto opcode 1E con 1 parametro
- aggiungi 2 parametri all'opcode 17 quando è seguito da 40 (in pratica 17 40 xx xx)

Beta8l
- scrittura file log

Beta9 (nuovi opcode scoperti da chop)
 07 - 5 parametri
 0E - 3 parametri
 16 - 2 parametri (?)
 Sull'opcode 16 non sono molto sicuro, comunque da quello che ho visto lo si trova solo nei tutorial.

*/

#include <stdlib.h>
#include <stdio.h>
#include <string.h>

FILE *logs;
char op_usati[256] = {0};

int GRA2_dumpa(FILE *orig, FILE *dest);

int GRA2_inserisci(FILE *orig, char *dest);		//<---Modificato!

int GRA2_strCompare(char *expr, char *string, unsigned char *value);

int GRA2_inserisciStanza(unsigned char *origine, int *posOrig, unsigned char *destinazione, int *offset, unsigned char *label);

char *tbl[280] = {"{00}", "{01}", "{02}", "{03}", "{04}", "{05}", "{06}", "{07}", "{08}", "{09}", "{0A}", "{0B}", "{0C}", "{0D}", "{0E}", "{0F}", 
                  "{10}", "{11}", "{12}", "{13}", "{14}", "{15}", "{16}", "{17}", "{18}", "{19}", "\n<new/>", "\n<wait/>", "{1C}", "{1D}", "{1E}", "\n", 
                  " ", "!", "”", "#", "$", "%", "&", "'", "(", ")", "*", "+", ",", "-", ".", "/", 
                  "0", "1", "2", "3", "4", "5", "6", "7", "8", "9", ":", ";", "<;", "=", ">", "?", 
                  "@", "A", "B", "C", "D", "E", "F", "G", "H", "I", "J", "K", "L", "M", "N", "O", 
                  "P", "Q", "R", "S", "T", "U", "V", "W", "X", "Y", "Z", "[", "\\", "]", "^", "_", 
                  "`", "a", "b", "c", "d", "e", "f", "g", "h", "i", "j", "k", "l", "m", "n", "o", 
                  "p", "q", "r", "s", "t", "u", "v", "w", "x", "y", "z", "{{", "|", "}}", "~", "{7F}", 
                  "{80}", "{81}", "{82}", "{83}", "{84}", "{85}", "{86}", "{87}", "{88}", "{89}", "{8A}", "{8B}", "{8C}", "{8D}", "{8E}", "{8F}", 
                  "{90}", "{91}", "{92}", "{93}", "ô", "{95}", "{96}", "{97}", "{98}", "ù", "{9A}", "û", "{9C}", "{9D}", "{9E}", "{9F}", 
                  "{A0}", "{A1}", "{A2}", "{A3}", "{A4}", "{A5}", "{A6}", "{A7}", "{A8}", "{A9}", "{AA}", "{AB}", "{AC}", "{AD}", "{AE}", "{AF}", 
                  "{B0}", "{B1}", "{B2}", "{B3}", "{B4}", "{B5}", "{B6}", "{B7}", "{B8}", "{B9}", "{BA}", "{BB}", "{BC}", "{BD}", "{BE}", "{BF}", 
                  "À", "{C1}", "Â", "{C3}", "{C4}", "{C5}", "{C6}", "Ç", "È", "É", "Ê", "{CB}", "{CC}", "{CD}", "{CE}", "{CF}", 
                  "{D0}", "{D1}", "{D2}", "{D3}", "Ô", "{D5}", "{D6}", "{D7}", "{D8}", "{D9}", "{DA}", "{DB}", "{DC}", "{DD}", "{DE}", "{DF}", 
                  "à", "{E1}", "â", "{E3}", "ä", "{E5}", "{E6}", "ç", "è", "é", "ê", "ë", "{EC}", "{ED}", "î", "ï", 
                  "{F0}", "{F1}", "{F2}", "{F3}", "{F4}", "{F5}", "{F6}", "{F7}", "{F8}", "{F9}", "{FA}", "{FB}", "{FC}", "{FD}", "{FE}", "{FF}"};

int main(int argc, char *argv[]) {
   FILE *letto, *scritto;
   int err;
   for(err=0; err<256; ++err) op_usati[err] = 0;
   
   if(argc == 4) {  // 4 argomenti richiesti
      if(!(strcmpi(argv[1], "-e"))) {  // opzioni supportate
         char nomelog[256];
         if((letto = fopen(argv[2], "rb")) == NULL) {  // apre il file in lettura
            printf("Impossibile aprire %s\n", argv[2]);
            exit(2);  // uscita con errore
         }
         if((scritto = fopen(argv[3], "wt")) == NULL) {  // apre il file in scrittura
            printf("Impossibile aprire %s\n", argv[3]);
            fclose(letto);
            exit(2);  // uscita con errore
         }
         sprintf(nomelog, "%s.log", argv[2]);
         if((logs = fopen(nomelog, "wt")) == NULL) {  // apre il file in scrittura
            printf("Impossibile aprire %s\n", nomelog);
            fclose(scritto);
            fclose(letto);
            exit(2);  // uscita con errore
         }
         err = GRA2_dumpa(letto, scritto);
      }
      if(!(strcmpi(argv[1], "-c"))) {  // opzioni supportate
         if((letto = fopen(argv[2], "rt")) == NULL) {  // apre il file in lettura
            printf("Impossibile aprire %s\n", argv[2]);
            exit(2);  // uscita con errore
         }
         if((scritto = fopen(argv[3], "rb")) == NULL) {  // apre il file in scrittura
            printf("Impossibile aprire %s\n", argv[3]);
            fclose(letto);
            exit(2);  // uscita con errore
         }
		 fclose(scritto);
         err = GRA2_inserisci(letto, argv[3]);
      }
      fclose(letto);  // chiude i file

         
      if(err) {  // se c'e' un errore
         //unlink(argv[3]);  // elimina il file destinazione
         if(err == -1) printf("Errore nell'allocazione della memoria");
         else if(err == 2) printf("Impossibile leggere il file %s", argv[2]);
         else if(err == 3) printf("Il file %s non \212 un dump di questa versione", argv[2]);
         else printf("%d Impossibile scrivere il file %s", err, argv[3]);
         printf(" - Operazione non riuscita\n");
         exit(2);  // uscita con errore
      }
      printf("Grandia 2 text dumper/inserter 0.1Beta9a by Mat - Operazione riuscita\n");
      exit(0);  // uscita corretta
   }      
   printf("Grandia 2 text dumper/inserter 0.1Beta9a by Mat - USO:\nGR2dump -e origine.dat destinazione.txt\nGR2dump -c origine.txt destinazione.dat (file originale non tradotto)\n\nStudio degli opcode by Chop\n\nMat - 11/10/2004\nE-mail:\tmattia.d.r@libero.it\nSito:\thttp://www.matzone.altervista.org\nMembro dei SadNES cITy: http://www.sadnescity.it\n");
   exit(1);  // // uscita con errore per mancanza di parameti
}

int GRA2_dumpa(FILE *orig, FILE *dest) {
   unsigned char *origine;  // conterra' i dati del file da dumpare
   int filesize;  // grandezza dei file da dumpare
   unsigned char *inizioTesto;
   int dimHeader;
   int i;
   int posIniz;
   int posFine;
   
   int numPtr = 0;
   unsigned short ptr[1000];
   unsigned char type[1000];

   //Leggi lunghezza e posizione del testo nell'archivio
   unsigned long txt_pos=0;

   if(fseek(orig, 0x78, SEEK_SET)) return 2;  
   fread(&filesize, 4, 1, orig);
   if(fseek(orig, 0x7C, SEEK_SET)) return 2; 
   fread(&txt_pos, 4, 1, orig);   

   if(fseek(orig, txt_pos, SEEK_SET)) return 2;  // ritorna all'inizio
   if(!(origine = malloc(filesize))) return -1;  // alloca la memoria necessaria per il file
   if(fread(origine, filesize, 1, orig) != 1) { free(origine); return 2; };  // legge il contenuto del file
   
   dimHeader = *((int*)origine);
   inizioTesto = origine + dimHeader;
   for(i = 4; i < dimHeader - 4; i += 4) {
      posIniz = 0;
      posFine = 0;
      memcpy(&posIniz, origine + i + 2, 2);
      posIniz <<= 3;
      memcpy(&posFine, origine + i + 6, 2);
      posFine <<= 3;
      if(posFine > filesize) posFine = filesize - dimHeader;
      GRA2_analisiTesto(inizioTesto, posIniz, posFine, ptr, type, &numPtr);
   }
   
   fprintf(logs, "GR2dump 0.1b9 - Opcode sospetti:\n");

   dimHeader = *((int*)origine);
   inizioTesto = origine + dimHeader;
   fprintf(dest, "<grandiaDump version=\"0.1b9\" numStanze=\"%.4X\">", (dimHeader - 8) / 4);
   for(i = 4; i < dimHeader - 4; i += 4) {
      posIniz = 0;
      posFine = 0;
      memcpy(&posIniz, origine + i + 2, 2);
      posIniz <<= 3;
      memcpy(&posFine, origine + i + 6, 2);
      posFine <<= 3;
      if(posFine > filesize) posFine = filesize - dimHeader;
      GRA2_dumpaTesto(dest, inizioTesto, posIniz, posFine, origine + i, ptr, type, numPtr);
   }
   fprintf(dest, "\n</grandiaDump>");
   fprintf(logs, "Operatori sconosciuti:");
   // salto 00 01 02 0A 0B 0F
   for(i = 0x03; i <= 0x19; ++i) if(op_usati[i] != 0) fprintf(logs, " %.2X", i);
   for(i = 0x1C; i <= 0x1E; ++i) if(op_usati[i] != 0) fprintf(logs, " %.2X", i);
   fprintf(logs, "\nCodici non visualizabili usati:");
   for(i = 0x8C; i < 256; ++i) if(op_usati[i] != 0) fprintf(logs, " %.2X", i);
   fprintf(logs, "\n");
   return 0;
}

int GRA2_dumpaTesto(FILE *dump, unsigned char *orig, int i, int dim,  unsigned char *label, unsigned short *ptr, unsigned char *type, int numPtr) {
   int j;
   static int localPtr = 0;
   
   fprintf(dump, "\n<stanza label=\"%.2X%.2X\">", label[0], label[1]);
   while(i < dim) {
      for(j = 0; j < numPtr; ++j) {
         if(ptr[j] == i) fprintf(dump, "\n<ref type=\"%.2X\" num=\"%.4X\"/>", type[j], j);
      }
      switch(orig[i]) {
         case 0x03: if((orig[i + 1] == 0x10) || (orig[i + 1] == 0x20)) {
                        fprintf(dump, "\n<ptr type=\"%.2X\" num=\"%.4X\"/>", orig[i + 1], localPtr);
                        ++localPtr;
                     }
                     else {
                        fprintf(dump, "\n<op03 value=\"%.2X%.2X%.2X\"/>", orig[i + 1], orig[i + 2], orig[i + 3]);
                        fprintf(logs, "<op03 value=\"%.2X%.2X%.2X\"/>\n", orig[i + 1], orig[i + 2], orig[i + 3]);
                     }
                     i += 4; break;
         case 0x04: fprintf(dump, "\n<op04 value=\"%.2X\"/>", orig[i + 1]); i += 2; break;
         case 0x05: fprintf(dump, "\n<op05 value=\"%.2X%.2X\"/>", orig[i + 1], orig[i + 2]); i += 3; break;
         case 0x06: fprintf(dump, "\n<op06 value=\"%.2X%.2X%.2X\"/>", orig[i + 1], orig[i + 2], orig[i + 3]); i += 4; break;
         case 0x07: fprintf(dump, "\n<op07 value=\"%.2X%.2X%.2X%.2X%.2X\"/>", orig[i + 1], orig[i + 2], orig[i + 3], orig[i + 4], orig[i + 5]); i += 6; break;
         case 0x08: fprintf(dump, "\n<op08 value=\"%.2X%.2X%.2X\"/>", orig[i + 1], orig[i + 2], orig[i + 3]); i += 4; break;
         case 0x09: fprintf(dump, "\n<op09 value=\"%.2X%.2X%.2X%.2X\"/>", orig[i + 1], orig[i + 2], orig[i + 3], orig[i + 4]); i += 5; break;
/* ? */  case 0x0A: fprintf(dump, "\n<op0A value=\"%.2X%.2X%.2X%.2X%.2X%.2X\"/>", orig[i + 1], orig[i + 2], orig[i + 3], orig[i + 4], orig[i + 5], orig[i + 6]); i += 7; break;
         case 0x0B: fprintf(dump, "\n<op0B value=\"%.2X%.2X\"/>", orig[i + 1], orig[i + 2]); i += 3; break;
/* ? */  case 0x0C: fprintf(dump, "\n<op0C value=\"%.2X\"/>", orig[i + 1]); i += 2; break;
/* ? */  case 0x0D: fprintf(dump, "\n<op0D value=\"%.2X\"/>", orig[i + 1]); i += 2; break;
         case 0x0E: fprintf(dump, "\n<op0E value=\"%.2X%.2X%.2X\"/>", orig[i + 1], orig[i + 2], orig[i + 3]); i += 4; break;
         case 0x0F: fprintf(dump, "\n<op0F value=\"%.2X\"/>", orig[i + 1]); i += 2; break;
/* ? */  case 0x10: fprintf(dump, "\n<op10 value=\"%.2X%.2X%.2X%.2X%.2X%.2X%.2X\"/>", orig[i + 1], orig[i + 2], orig[i + 3], orig[i + 4], orig[i + 5], orig[i + 6], orig[i + 7]); i += 8; break;
         case 0x11: fprintf(dump, "\n<op11 value=\"%.2X%.2X%.2X\"/>", orig[i + 1], orig[i + 2], orig[i + 3]); i += 4; break;
         case 0x14: fprintf(dump, "\n<op14 value=\"%.2X%.2X%.2X%.2X%.2X\"/>", orig[i + 1], orig[i + 2], orig[i + 3], orig[i + 4], orig[i + 5]); i += 6; break;
         case 0x15: fprintf(dump, "\n<op15 value=\"%.2X%.2X%.2X%.2X\"/>", orig[i + 1], orig[i + 2], orig[i + 3], orig[i + 4]); i += 5; break;
/* ? */  case 0x16: fprintf(dump, "\n<op16 value=\"%.2X%.2X\"/>", orig[i + 1], orig[i + 2]); i += 3; break;
         case 0x17: switch(orig[i + 1]) {
                       case 0x01: fprintf(dump, "\n<text>"); i += 2; break;
                       case 0x20: fprintf(dump, "\n<unk value=\"%.2X%.2X\"/>", orig[i + 2], orig [i + 3]); i += 4; break;
                       case 0x40: fprintf(dump, "\n<selection value=\"%.2X%.2X\"/>", orig[i + 2], orig [i + 3]); i += 4; break;
                       case 0x80: fprintf(dump, "\n<item num=\"%.2X%.2X\"/>", orig[i + 2], orig [i + 3]); i += 4; break;
                       case 0x00: fprintf(dump, "\n</text>"); i += 2; break;
                       default: fprintf(dump, "%s", tbl[orig[i]]); ++i; op_usati[orig[i]] = 1;
                    } break;
         case 0x18: fprintf(dump, "\n<portrait num=\"%.2X%.2X\"/>", orig[i + 1], orig [i + 2]); i += 3; break;
         case 0x1C: fprintf(dump, "\n<op1C value=\"%.2X\"/>", orig[i + 1]); i += 2; break;
         case 0x1D: if(orig[i + 1] == 0xFF){
                       if(orig[i + 2] == 0x0F) fprintf(dump, "\n<pause/>");
                       else fprintf(dump, "\n<op1D value=\"%.2X%.2X\"/>", orig[i + 1], orig [i + 2]);
					   i += 3;
					}
					else {
					   fprintf(dump, "\n<op1D value=\"%.2X%.2X%.2X\"/>", orig[i + 1], orig [i + 2], orig[i + 3]);
					   i += 4;
					}
                    break;
         case 0x1E: fprintf(dump, "\n<op0F value=\"%.2X\"/>", orig[i + 1]); i += 2; break;
//         case 0x22: fprintf(dump, "\n<op22 num=\"%.2X\"/>\n", orig[i + 1]); i += 2; break;
         default: fprintf(dump, "%s", tbl[orig[i]]); op_usati[orig[i]] = 1; ++i;                  
      }
   }
   fprintf(dump, "\n</stanza>");
   return 0;
}

int GRA2_analisiTesto(unsigned char *orig, int i, int dim, unsigned short *ptr, unsigned char *type, int *curPtr) {

   while(i < dim) {
      switch(orig[i]) {
         case 0x03: if((orig[i + 1] == 0x10) || (orig[i + 1] == 0x20)) {
                        memcpy(ptr + *curPtr, orig + i + 2, 2); // copia l'offset del puntatore
                        memcpy(type + *curPtr, orig + i + 1, 1); // copia il tipo del puntatore
                        ++*curPtr;
                     }
                     i += 4; break;
         case 0x04: i += 2; break;
         case 0x05: i += 3; break;
         case 0x06: i += 4; break;
         case 0x07: i += 6; break;
         case 0x08: i += 4; break;
         case 0x09: i += 5; break;
/* ? */  case 0x0A: i += 7; break;
         case 0x0B: i += 3; break;
/* ? */  case 0x0C: i += 2; break;
/* ? */  case 0x0D: i += 2; break;
         case 0x0E: i += 4; break;
         case 0x0F: i += 2; break;
/* ? */  case 0x10: i += 8; break;
         case 0x11: i += 4; break;
         case 0x14: i += 6; break;
         case 0x15: i += 5; break;
/* ? */  case 0x16: i += 3; break;
         case 0x17: switch(orig[i + 1]) {
                       case 0x01: i += 2; break;
                       case 0x20: i += 4; break;
                       case 0x40: i += 4; break;
                       case 0x80: i += 4; break;
                       case 0x00: i += 2; break;
                       default: ++i;
                    } break;
         case 0x18: i += 3; break;
         case 0x1C: i += 2; break;
         case 0x1D: if(orig[i + 1] == 0xFF) {
					   i += 3;
					}
					else {
					   i += 4;
					}
                    break;
         case 0x1E: i += 2; break;
//         case 0x22: i += 2; break;
         default: if((orig[i] < 0x20) && (orig[i] != 0x00) && (orig[i] != 0x01) && (orig[i] != 0x02) && (orig[i] != 0x1A) && (orig[i] != 0x1B) && (orig[i] != 0x1F)) printf("Opcode sconoscito: %.2X\n", orig[i]);
		 ++i;
      }
   }
   return 0;
}

int GRA2_inserisci(FILE *orig, char *dest) {
   #define MAX_LINEA 100000
   unsigned char *origine;
   unsigned char *destinazione;
   unsigned char *stanze;
   unsigned char valori[20];
   int filesize;  // grandezza dei file da dumpare
   int numStanze;
   int dimHeader;
   int offset = 0;
   int posOrig;
   int tmp = 0xFFFFFFFF;
   int i;


   unsigned long txt_pos=0;
   unsigned long txt_len=0;
   unsigned long dst_len=0;
   unsigned char* tmp_buff;
   unsigned long temp=0;
   FILE* dst_file=NULL;

   if(fseek(orig, 0, SEEK_END)) return 2;  // fine del file
   if((filesize = ftell(orig)) == -1) return 2;  // dimensione del file
   if(fseek(orig, 0, SEEK_SET)) return 2;  // ritorna all'inizio
   if(!(origine = calloc(filesize+5050, 1))) return -1;  // alloca la memoria necessaria per il file
   if(!(destinazione = calloc(filesize+5050, 1))) return -1;  // alloca la memoria necessaria per il file
   filesize = fread(origine, 1, filesize+5050, orig);  // legge il con
   if((posOrig = GRA2_strCompare("<grandiaDump version=\"0.1b9\" numStanze=\"££\">", origine, valori)) == -1) return 3;

   numStanze = valori[1] + (valori[0] << 8);
   dimHeader = (numStanze * 4) + 8;
   stanze = destinazione + dimHeader;
   memcpy(destinazione, &dimHeader, 4);
   memcpy(destinazione + (dimHeader - 4), &tmp, 4);
   
   for(i = 0; i < numStanze; ++i) {
      if(offset & 7) offset = (offset | 7) + 1;
      tmp = offset >> 3;
      memcpy(destinazione + 6 + (i * 4), &tmp, 2);
      GRA2_inserisciStanza(origine, &posOrig, stanze, &offset, destinazione + 4 + (i * 4));
   }
   GRA2_aggiornaPtr(stanze);

   //inserisci il file al punto giusto
   
   if ((dst_file = fopen(dest, "rb"))==NULL) return 2;
   
   if(fseek(dst_file, 0, SEEK_END)) return 2;  // fine del file
   if((dst_len = ftell(dst_file)) == -1) return 2;  // dimensione del file

   
   if(fseek(dst_file, 0x78, SEEK_SET)) return 2;
   fread(&txt_len, 4, 1, dst_file);	//vecchia lunghezza testo

   if(fseek(dst_file, 0x7C, SEEK_SET)) return 2;
   fread(&txt_pos, 4, 1, dst_file); //posizione testo

   if(fseek(dst_file, 0, SEEK_SET)) return 2;
   
   //Alloca un altro buffer temporaneo per l'intero file
   tmp_buff = malloc((dst_len + offset+ dimHeader) - txt_len);

   fread(tmp_buff, txt_pos, 1, dst_file);
   memcpy(tmp_buff+txt_pos, destinazione, offset+dimHeader);
   fseek(dst_file, txt_pos+txt_len, SEEK_SET);
   fread(tmp_buff+txt_pos+offset+dimHeader, dst_len-(txt_pos+txt_len),1,dst_file);
   fclose(dst_file);


	//Modifica gli altri puntatori
   for(i=0; i<10; i++){
		memcpy(&temp, tmp_buff+0x84+8*i, 4);
		if (temp == 0) continue;	//se 0 non fare niente
		else {		//altrimenti aggiorna la poszione
			temp = (temp + offset+dimHeader) - txt_len;
			memcpy(tmp_buff+0x84+8*i,&temp, 4);
		}
   }

   memcpy(&temp, tmp_buff+0xE8, 4);
   temp = (temp + offset+dimHeader) - txt_len;
   memcpy(tmp_buff+0xE8,&temp, 4);
	
	//Modifica la lunghezza
   temp=offset+dimHeader;
   memcpy(tmp_buff+0x78, &temp, 4);

   if ((dst_file = fopen(dest, "wb"))==NULL) return 2;
   fwrite(tmp_buff, dst_len-txt_len+offset+dimHeader, 1, dst_file);
   fclose(dst_file);
   return 0;
}

int numPtr = 0;
int numRef = 0;
unsigned short ptr[5000]; // posizione in cui scrivere il puntatore
unsigned short ref[5000];
   
int GRA2_inserisciStanza(unsigned char *origine, int *posOrig, unsigned char *destinazione, int *offset, unsigned char *label) {
   unsigned char valori[20];
   int i;
   int n;
   
   if((n = GRA2_strCompare("\n<stanza label=\"££\">", origine + *posOrig, label)) == -1) {*posOrig += n; printf("g"); exit(1);return 0;}
   *posOrig += n;

   while(1) {
      if((n = GRA2_strCompare("\n</stanza>", origine + *posOrig, NULL)) != -1) {
         *posOrig += n;
         //padding a 8 byte, spazio sprecato ma almeno non devo pensarci
         if(*offset % 8) *offset += 8 - (*offset % 8);
         return 0;
      }
      else if((n = GRA2_strCompare("\n<ptr type=\"£\" num=\"££\"/>", origine + *posOrig, valori)) != -1) {
         destinazione[(*offset)++] = 0x03;
         destinazione[(*offset)++] = valori[0];
         ptr[(valori[1] << 8) + valori[2]] = *offset;
         ++numPtr;
         *offset += 2;
      }
      else if((n = GRA2_strCompare("\n<ref type=\"£\" num=\"££\"/>", origine + *posOrig, valori)) != -1) {
         ref[(valori[1] << 8) + valori[2]] = *offset;
         ++numRef;
      }
      else if((n = GRA2_strCompare("\n<op03 value=\"£££\"/>", origine + *posOrig, valori)) != -1) {
         destinazione[(*offset)++] = 0x03;
         destinazione[(*offset)++] = valori[0];
         destinazione[(*offset)++] = valori[1];
         destinazione[(*offset)++] = valori[2];
      }
      else if((n = GRA2_strCompare("\n<op04 value=\"£\"/>", origine + *posOrig, valori)) != -1) {
         destinazione[(*offset)++] = 0x04;
         destinazione[(*offset)++] = valori[0];
      }
      else if((n = GRA2_strCompare("\n<op05 value=\"££\"/>", origine + *posOrig, valori)) != -1) {
         destinazione[(*offset)++] = 0x05;
         destinazione[(*offset)++] = valori[0];
         destinazione[(*offset)++] = valori[1];
      }
      else if((n = GRA2_strCompare("\n<op06 value=\"£££\"/>", origine + *posOrig, valori)) != -1) {
         destinazione[(*offset)++] = 0x06;
         destinazione[(*offset)++] = valori[0];
         destinazione[(*offset)++] = valori[1];
         destinazione[(*offset)++] = valori[2];
      }
      else if((n = GRA2_strCompare("\n<op07 value=\"£££££\"/>", origine + *posOrig, valori)) != -1) {
         destinazione[(*offset)++] = 0x07;
         destinazione[(*offset)++] = valori[0];
         destinazione[(*offset)++] = valori[1];
         destinazione[(*offset)++] = valori[2];
         destinazione[(*offset)++] = valori[3];
         destinazione[(*offset)++] = valori[4];
      }
      else if((n = GRA2_strCompare("\n<op08 value=\"£££\"/>", origine + *posOrig, valori)) != -1) {
         destinazione[(*offset)++] = 0x08;
         destinazione[(*offset)++] = valori[0];
         destinazione[(*offset)++] = valori[1];
         destinazione[(*offset)++] = valori[2];  
      }
      else if((n = GRA2_strCompare("\n<op09 value=\"££££\"/>", origine + *posOrig, valori)) != -1) {
         destinazione[(*offset)++] = 0x09;
         destinazione[(*offset)++] = valori[0];
         destinazione[(*offset)++] = valori[1];
         destinazione[(*offset)++] = valori[2];
         destinazione[(*offset)++] = valori[3];
      }
      else if((n = GRA2_strCompare("\n<op0A value=\"££££££\"/>", origine + *posOrig, valori)) != -1) {
         destinazione[(*offset)++] = 0x0A;
         destinazione[(*offset)++] = valori[0];
         destinazione[(*offset)++] = valori[1];
         destinazione[(*offset)++] = valori[2];
         destinazione[(*offset)++] = valori[3];
         destinazione[(*offset)++] = valori[4];
         destinazione[(*offset)++] = valori[5];
      }
      else if((n = GRA2_strCompare("\n<op0B value=\"££\"/>", origine + *posOrig, valori)) != -1) {
         destinazione[(*offset)++] = 0x0B;
         destinazione[(*offset)++] = valori[0];
         destinazione[(*offset)++] = valori[1];
      }
      else if((n = GRA2_strCompare("\n<op0C value=\"£\"/>", origine + *posOrig, valori)) != -1) {
         destinazione[(*offset)++] = 0x0C;
         destinazione[(*offset)++] = valori[0];
      }
      else if((n = GRA2_strCompare("\n<op0D value=\"£\"/>", origine + *posOrig, valori)) != -1) {
         destinazione[(*offset)++] = 0x0D;
         destinazione[(*offset)++] = valori[0];
      }
      else if((n = GRA2_strCompare("\n<op0E value=\"£££\"/>", origine + *posOrig, valori)) != -1) {
         destinazione[(*offset)++] = 0x0E;
         destinazione[(*offset)++] = valori[0];
         destinazione[(*offset)++] = valori[1];
         destinazione[(*offset)++] = valori[2];
      }
      else if((n = GRA2_strCompare("\n<op0F value=\"£\"/>", origine + *posOrig, valori)) != -1) {
         destinazione[(*offset)++] = 0x0F;
         destinazione[(*offset)++] = valori[0];
      }
      else if((n = GRA2_strCompare("\n<op10 value=\"£££££££\"/>", origine + *posOrig, valori)) != -1) {
         destinazione[(*offset)++] = 0x10;
         destinazione[(*offset)++] = valori[0];
         destinazione[(*offset)++] = valori[1];
         destinazione[(*offset)++] = valori[2];
         destinazione[(*offset)++] = valori[3];
         destinazione[(*offset)++] = valori[4];
         destinazione[(*offset)++] = valori[5];
         destinazione[(*offset)++] = valori[6];
      }
      else if((n = GRA2_strCompare("\n<op11 value=\"£££\"/>", origine + *posOrig, valori)) != -1) {
         destinazione[(*offset)++] = 0x11;
         destinazione[(*offset)++] = valori[0];
         destinazione[(*offset)++] = valori[1];
         destinazione[(*offset)++] = valori[2];  
      }
      else if((n = GRA2_strCompare("\n<op14 value=\"£££££\"/>", origine + *posOrig, valori)) != -1) {
         destinazione[(*offset)++] = 0x14;
         destinazione[(*offset)++] = valori[0];
         destinazione[(*offset)++] = valori[1];
         destinazione[(*offset)++] = valori[2];
         destinazione[(*offset)++] = valori[3];
         destinazione[(*offset)++] = valori[4];
      }
      else if((n = GRA2_strCompare("\n<op15 value=\"££££\"/>", origine + *posOrig, valori)) != -1) {
         destinazione[(*offset)++] = 0x15;
         destinazione[(*offset)++] = valori[0];
         destinazione[(*offset)++] = valori[1];
         destinazione[(*offset)++] = valori[2];
         destinazione[(*offset)++] = valori[3];
      }
      else if((n = GRA2_strCompare("\n<op16 value=\"££\"/>", origine + *posOrig, valori)) != -1) {
         destinazione[(*offset)++] = 0x16;
         destinazione[(*offset)++] = valori[0];
         destinazione[(*offset)++] = valori[1];
      }
      else if((n = GRA2_strCompare("\n<text>", origine + *posOrig, NULL)) != -1) {
         destinazione[(*offset)++] = 0x17;
         destinazione[(*offset)++] = 0x01;
      }
      else if((n = GRA2_strCompare("\n<unk value=\"££\"/>", origine + *posOrig, valori)) != -1) {
         destinazione[(*offset)++] = 0x17;
         destinazione[(*offset)++] = 0x20;
         destinazione[(*offset)++] = valori[0];
         destinazione[(*offset)++] = valori[1];
      }
      else if((n = GRA2_strCompare("\n<selection value=\"££\"/>", origine + *posOrig, valori)) != -1) {
         destinazione[(*offset)++] = 0x17;
         destinazione[(*offset)++] = 0x40;
         destinazione[(*offset)++] = valori[0];
         destinazione[(*offset)++] = valori[1];
      }
      else if((n = GRA2_strCompare("\n<item num=\"££\"/>", origine + *posOrig, valori)) != -1) {
         destinazione[(*offset)++] = 0x17;
         destinazione[(*offset)++] = 0x80;
         destinazione[(*offset)++] = valori[0];
         destinazione[(*offset)++] = valori[1];
      }
      else if((n = GRA2_strCompare("\n</text>", origine + *posOrig, NULL)) != -1) {
         destinazione[(*offset)++] = 0x17;
         destinazione[(*offset)++] = 0x00;
      }
      else if((n = GRA2_strCompare("\n<portrait num=\"££\"/>", origine + *posOrig, valori)) != -1) {
         destinazione[(*offset)++] = 0x18;
         destinazione[(*offset)++] = valori[0];
         destinazione[(*offset)++] = valori[1];
      }
      else if((n = GRA2_strCompare("\n<op1C value=\"£\"/>", origine + *posOrig, valori)) != -1) {
         destinazione[(*offset)++] = 0x1C;
         destinazione[(*offset)++] = valori[0];
      }
      else if((n = GRA2_strCompare("\n<pause/>", origine + *posOrig, valori)) != -1) {
         destinazione[(*offset)++] = 0x1D;
         destinazione[(*offset)++] = 0xFF;
         destinazione[(*offset)++] = 0x0F;
      }
      else if((n = GRA2_strCompare("\n<op1D value=\"££\"/>", origine + *posOrig, valori)) != -1) {
         destinazione[(*offset)++] = 0x1D;
         destinazione[(*offset)++] = valori[0];
         destinazione[(*offset)++] = valori[1];
      }
      else if((n = GRA2_strCompare("\n<op1D value=\"£££\"/>", origine + *posOrig, valori)) != -1) {
         destinazione[(*offset)++] = 0x1D;
         destinazione[(*offset)++] = valori[0];
         destinazione[(*offset)++] = valori[1];
         destinazione[(*offset)++] = valori[2];
      }
      else if((n = GRA2_strCompare("\n<op1E value=\"£\"/>", origine + *posOrig, valori)) != -1) {
         destinazione[(*offset)++] = 0x1E;
         destinazione[(*offset)++] = valori[0];
      }
      else {
         for(i = 0; i < 256; ++i) {
            if((n = GRA2_strCompare(tbl[i], origine + *posOrig, NULL)) != -1) {
               destinazione[(*offset)++] = i;
               break;
            }
         }
         if(i == 256) {
            printf("Carattere non valido, impossibile inserire: %c\n", origine[*posOrig]);
            n = 1;
         }
      }
   *posOrig += n;
   }
   return 0;
}
int GRA2_aggiornaPtr(unsigned char *destinazione) {
    int i;
    
    if(numRef != numPtr) printf("Riferimenti e puntatori in numero diverso O___O\n");
    
    for(i = 0; i < numPtr; ++i) {
       memcpy(destinazione + ptr[i], ref + i, 2);
    }
}

int GRA2_strCompare(char *expr, char *string, unsigned char *value) {
   int i = 0;
   int j = 0;
   int v = 0;
   int tmp;
   char byte[3];
   byte[2] = '\0';
   
   while(expr[i] != '\0') {
      if(expr[i] == '£') {
         byte[0] = string[j];
         byte[1] = string[++j];
         sscanf(byte, "%x", &tmp);
         value[v++] = tmp;
      }
      else {
         if(expr[i] != string[j]) return -1;
      }
      ++i; ++j;
   }
   return j;
}

[dragoncity]

Alors encore une fois on est bloqué sur un AFS,alors que les 3/4 ne posent aucun soucis passés sous GDR2DUMP9.

Grâce à "yzb37859365" on a pu en avoir un qui fonctionne,il l'a "hack" comme il dit,ce mec est juste monstrueux !

1 first of all, the end of your file text is not aligned, causing the file to go wrong




2 text data can be put at the end of the file, the original address is changed to 00


Le soucis c'est que l'on arrive pas à comprendre exactement comment il fait,donc si vous avez 2minutes pour regarder ce qu'il nous a marqué,peut être avez-vous la réponse

https://assemblergames.com/threads/how- ... 554/page-6

[BahaBulle]

Qu'est-ce que vous ne comprenez pas ?

Les données du jeu doivent être "alignées". En gros, ça veut dire que la taille d'un bloc de données commence toujours à une adresse multiple de 4.

Comme on le voit dans le 2ème screen, votre texte se termine à l'adresse 0xC8CD.
Les données suivantes commencent donc à l'adresse 0xC8CE qui n'est pas un multiple de 4 (0xC8CE modulo 4 <> 0).
Il faut donc ajouter 2 0x00 à la fin de votre texte pour que la suite commence à une adresse "alignée".

[dragoncity]

Comment calculer la longueur..c'est la ou je bloque,j'ai compris comment définir "l'adresse" sois ou pointer le texte !

Déjà fallait comprendre qu'elle était inversé..tssss..ça aussi !

Mais voilà la maintenant que j'ai compris l'adresse,comment faire pour calculer cette longueur car c'est la ou je bloque !

Voilà le fichier qui correspond :
http://www59.zippyshare.com/v/D1C2aSYZ/file.html

[RyleFury]

Ça fait plusieurs fois qu'on vous le dit, lisez les tutos !

Déjà tu aurais su depuis longtemps que les pointeurs/valeurs étaient inversés si tu connaissais le "Little Endian" et le "Big Endian", deux notions essentielles dans le romhacking. Maintenant, si tu ne sais pas comment fonctionne la taille de ton texte, tu n'as qu'à effectuer des tests en changeant la valeur pour comprendre comment ça marche justement. Ça ne doit pas être si compliqué. Mettez-y un peu du vôtre, on est là pour vous montrer la voie, pas faire le travail à votre place.

[dragoncity]

Calme toi,pas besoin de gueuler jusqu'à présent si tu savais que je passe mes journées dessus,que j'ai fait des milliers de tests je pense pas que tu dirais ça !

Les AFS c'est rien par rapport a tout ce qu'on a du faire en OFF... mais bon..

La clairement j'ai déjà fait de changer le texte,de rajoute..pour voir comment la valeur évolue..mais sans y comprendre grand chose et fafadou non plus.

C'est pas parce que toi tu maitrises qui faut parler comme ça,la clairement ma question est simple "Comment calculer cette longueur?" ..je vois pas pas le problème de me répondre :

"Tu calcules la longueur comme ça : ..."

Enfin bon..je retourne a mes tests...

[RyleFury]

Ce n'est pas parce que j'utilise un point d'exclamation que je gueule

Je n'ai pas la réponse toute prête, donc je ne peux pas te répondre simplement. Rien n'est simple dans le romhacking, quelquefois rien que de trouver un ptit truc à la con bien vicelard peut même prendre des semaines voire des mois. Il faudrait que je cherche de mon côté et je n'ai pas le temps avec les projets que j'ai déjà sur le dos, comme presque tout le monde ici.

La seule chose qu'il faut que vous compreniez c'est que les bases du romhacking sont importantes avant de vous lancer dans quelque chose de ce genre. C'est tout simplement primordial, après le reste c'est du retro-enginnering, de la recherche pure et dure. Nous, nous sommes juste là pour vous guider.

[dragoncity]

On n'en demande pas plus d'ailleurs si on est arrivé a decoder les AFS,incruster les sous titres dans les videos.. changer les menus etc... c'est par nous meme.

Parfois on a eu des soucis et certains ont donné des idees ou autres ce qui nous a permis d'avancer mais jamais quelqu'un a mis les mains dedans et de toute façon on demandera jamais...

La clairement je me suis agacé car ça fait 3 jours non stop que je vois de l'hex partout.. que j'en bouffe que je decode comme je peux... donc surtout ne pas dire qu'on cherche pas

D'ailleurs faudrait que je fasse une pause car j'en ai mal au crane a force,la je suis content il y a 5minutes j'ai reussi a incruster le texte fr a la suite du en,en mettant l'adresse d'entree et de sortie.. et bien sur ça marche !

Il y a juste la longueur ou j'ai triché je l'ai recupere de la valeur du fichier FR passez sous gdrump9 (le fichier fr ne fonctionne pas mais il y avait la bonne longueur apparemment)

On bosse dessus parfois jusqu'a 5h du mat donc surtout ne pas dire qu'on cherche pas

Allez je retourne jouer vu que l'afs qui bloquait fonctionne.. j'espere que cela sera le dernier car les 3/4 passent mais la 2 qui merdé... pourquoi je n'en sais rien... et pas savoir ça énerve

[BahaBulle]

J'ai du mal à comprendre votre problème.

Si vous avez 4 octets qui donne la longueur du bloc, ben il suffit de compter le nombre d'octets à partir du début du bloc (adresse donné par le pointeur) et la fin du bloc.

Après vos modifications, il faut juste s'assurer que la taille soit un multiple de 4

[RyleFury]

En regardant je vois que votre archive est extrêmement simple. Pour donner plus de détails, 0xD7F0 est l'adresse du bloc en question pendant que 0x1B24 en est la taille exacte, il n'y a même pas d'opération à effectuer. Vous voyez quand même bien que si vous additionnez 0xD7F0 par 0x1B24 vous arrivez à la fin du fichier car le bloc en question est le dernier du fichier. Alors même question, où est le problème ?

[dragoncity]

Oki je vais allez droit au but avec 2 questions simple,qui pour nous sont très importante !

Car on ne comprends pas pourquoi la méthode d'incruster les textes provenant de la version PC dans la version Dreamcast fonctionne pour les 3/4 des afs.. car on en a 2 qui pour l'instant font un écran noir.. je m'en suis aperçu en testant le jeu.

Je vous partage 3 fichiers extrait de l'afs 2801 ( 01.l162c) : http://dragoncity17.free.fr/Grandia%202 ... R+HACK.zip

EN.dat : Fichier Original (provenant de la version Dreamcast)
FR.dat : Texte pris de la version PC et incrusté dans la version EN.dat via Gr2dump9
HACK.dat : Fichier créé par yzb,qui est en fait le fichier EN.dat suivi du texte en FR,avec modification de l'adresse de début,fin et la longueur.

Question 1 : Pouvez-vous nous dire pourquoi la version FR.dat ne fonctionne pas alors que la version EN.dat et HACK.dat fonctionne ?

Question 2 : Peut-on analyser rapidement tous les AFS (après avoir décompressé le 01.l162c mais ça j'ai créé mes BAT),pour savoir si il va y avoir un soucis,en gros si il va faire comme le FR.dat > Blackscreen lors de son chargement..?

N'hésitez pas à me dire si je dois encore plus détaillé,j'ai essayé de pas trop en dire,car derrière c'est une usine à gaz,on a 3 programmes pour faire tout ça ^^
extAFS.exe + extL62C.exe + GR2dump9.exe

Les 2 questions sont primordiales pour nous,car il faut qu'on puisse checker chacun des AFS afin de savoir si le gr2dump9 a bien fait son boulot sur TOUS les AFS.

Et on aimerait si il s'avère qu'un AFS ne va pas,pouvoir comme dans le cas du FR.dat le modifier directement.

Merci d'avance de votre aide

[RyleFury]

Essayez un alignement de blocs sur 8 octets eu lieu de 4 avec toujours une taille de bloc avec un alignement de 4 octets. Genre vous avez le bloc du fichier EN à l'adresse 0xD7F0, aligné sur 16 octets et donc sur 8 mais le bloc du fichier FR à l'adresse 0xADAC aligné sur 4 octets seulement. Il faudrait donc que son adresse se termine par 0 ou 8, comme 0xADB0 ou 0xADB8.

Effectivement, pour aligner le bloc sur 8 octets ici, vous n'avez pas d'autre choix que de le déplacer où de déplacer les blocs suivants en conséquence sans vous planter.

[fafadou]

Donc c'était une simple addition alors ? Ben tu vois on avais même pas vu tellement c'était évident. Merci à toi.

Donc la longueur l'adresse du début et la fin sont reliés. De plus la fin doit être divisible par 8. Merci on va pouvoir contrôler et réduire la fin de nos fichiers

D7F0 +1B24=f314 donc on doit avoir f318 donc faut rajouter 4 caractères à la fin de notre texte (soit des 00 soit des 20 mais je préfère des 00 je pense que c'es plus sur que des espaces).
Ici on al fin à C6A0 et c'est bien divisible par 8. -> ok mais ça colle pas avec le calcul donc le fichier est pas bon.
On va le corriger.

[RyleFury]

Ce qui est important ici est la valeur de l'adresse de début.

Ton bloc ici commence à l'adresse 0xADAC, mais il doit commencer à une adresse divisible par 8, donc tu dois bouger le bloc entier pour ça, par exemple à l'adresse 0xADB0. Enfin bon, aligne-le sur 16 octets pour être vraiment sûr, donc à une valeur qui finit forcément par 0.
Assure-toi d'aligner en même temps la taille du bloc à 4 octets, donc avec une taille divisible par 4.

Il y a d'autres blocs derrière à ne pas oublier, donc si tu changes l'adresse de ce bloc, change celle des autres derrière lui aussi. Inspire-toi des modifications effectuées entre les fichiers EN et FR dans les 0x200 octets pour comprendre comment ça marche. Chaque bloc est défini par 4 octets de taille suivis de 4 octets d'adresse dans cette table à partir je dirais de l'adresse 0x8.

Après c'est pas sûr que ça marche car ça vient peut-être pas de ça, mais il y a de grandes chances, je dirais.

[RyleFury]

Je viens de voir que la longueur des blocs se calcule différemment selon le type de bloc en question. Par exemple à l'adresse 0x8 le bloc a une taille de 0x04 est est placé à l'adresse 0x200. Pour obtenir la vraie taille pour ce bloc il faut multiplier le nombre par 0x20, donc la vraie taille du bloc sera 0x80. A l'adresse 0x18, la taille du bloc affichée est 0x10, mais il faut en fait la multiplier par 0x30 pour obtenir sa vraie taille.

Vous avez de la chance car la taille affichée des blocs contenant du texte est la taille exacte du bloc. Les adresses des blocs quant à elles semblent toujours être absolues dans le fichier lui-même. Avec ces infos vous devriez être capables de vous débrouiller.

[dragoncity]

Encore une fois on se retrouvé bloqué sur un AFS.. donc on le décortique pour voir d’où vient l'erreur..mais on ne voit rien..

- L'adresse OK
- La longueur OK
- Et on a l'adresse de fin avec le bon alignement !



Donc je fais encore appel à vous encore une fois..

http://dragoncity17.free.fr/Grandia%202 ... 0EN+FR.zip

Vous trouverez 2 fichiers :

- EN.l62c (fichier d'origine)
- FR.l62c (fichier avec les textes FR passés sous Gr2dump9)

Car la clairement comprendre qu'est-ce qui fait que ça bloque...

Merci d'avance

[fafadou]

et la longueur colle aussi :
0EB0 + 010B30= 0119E0

et 119E0 respecte l'alignement car divisble par 8 comme tu nous l'avais dit Ryle fury on a pu le corriger ailleurs merci à toi.

Mais ici c'est le grand mystère...

Merci pour votre aide.

[dragoncity]

Voici la version Beta V2

Je vous ai cité,encore merci déjà à tous ceux qui nous ont aidés jusqu'à présent !

https://dragoncity17.wordpress.com/2018 ... uction-fr/

Ps: Pour mon dernier post,yzb celui qui nous aide d'habitude n'a vu aucune différence,et pourtant ça plante sous Dreamcast..si jamais vous vous trouvez le pourquoi du comment n'hésitez pas à nous en faire part !

[RyleFury]

Je ne suis pas chez moi jusqu'à Samedi mais effectivement ça semble plus compliqué avec ce fichier. Le problème devrait toujours provenir d'un mauvais alignement en mémoire, mais au lieu que cela vienne du bloc lui-même, ce serait une donnée spécifique à l'intérieur de celui-ci qui serait mal alignée.