Zen

Translation

English
## Finding Filenames
I told a lie of omission about the archive header – there’s more than just the magic integer section! If you scroll down past the magic integers, there’s another section the same length as the previous section and then a section past that which didn’t have a clearly-defined length but whose entries did seem tantalizingly patterned. For basically the entire development of the Chokuretsu utilities, I ignored these two sections entirely – literally skipping over them in the code.
513/5030 · 503

Insufficient privileges for saving translations.

English Italian Actions
![A Discord message reading Custom Filesystem](/images/blog/0005/01_custom_filesystem_blunder.png)
![Un messaggio su Discord con scritto Custom Filesystem](/images/blog/0005/01_custom_filesystem_blunder.png)
It wasn’t until [Ermii](https://www.ermiisoft.net/) politely asked if they were archives that I realized that…yeah, that’s exactly what they were.
Fu così fino a quando [Ermii](https://www.ermiisoft.net/) chiese gentilmente se erano file di archivio, e lì realizzai che... sì, erano proprio quelli.
## The File Length
Something I left out of the archive post was the fact that I didn’t reverse-engineer the whole archive at once. The code was written ad-hoc as I figured out particular things here and there. I figured out the offsets before I even realized that the rest of the magic integers encoded for length, so I was replacing files in the archives without changing their lengths accordingly. This resulted in beautiful things like this:
## La Lunghezza dei File
Qualcosa di cui non parlai nel post sugli archivi era il fatto che non ho fatto tutto il reverse-engineer dell'intero archivio in una sola volta. Il codice che ho scritto era ad-hoc mentre scoprivo svariate cose qua e là. Ho scoperto gli offset prima ancora di capire che il resto degli interi magici codificavano la lunghezza, quindi stavo rimpiazzando i file negli archivi senza cambiarne la lunghezza. Questo risultò in cose stupende come questa:
![The Chokuretsu main screen with significant corruption across multiple UI elements](/images/blog/0005/02_haruohno.png)
![La schermata principale di Chokuretsu con una significante corruzione sparsi su molteplici elementi della UI](/images/blog/0005/02_haruohno.png)
Trying to replace the graphics files led to corruption because my compression routine was less efficient than the one the devs used, which meant that the compressed files I was reinserting into the game were longer than expected. I spent a lot of time trying to figure out what was going on before I finally determined the [file length encoding](/blog/2022-11-02-chokuretsu-archives#the-unhinged-file-length-routine).
Provare a rimpiazzare i file della grafica portava alla corruzione perché la mia routine di compressione risultava meno efficace rispetto a quella che gli sviluppatori avevano utilizzato, il che significa che i file compressi che stavo reinserendo nel gioco erano più lunghi del previsto. Ho passato molto tempo a provare a capire cosa stava succedendo finco a quando non determinai la [codificazione della lunghezza dei file](/it/blog/2022-11-02-chokuretsu-archives#the-unhinged-file-length-routine).
![The Chokuretsu main screen without any corruption and with haruhi cool written over Haruhi's face](/images/blog/0005/03_haruhi_cool.png)
![La schermata principale di Chokuretsu senza corruzioni e con haruhi cool scritto sulla faccia di Haruhi](/images/blog/0005/03_haruhi_cool.png)
Much better!
Molto meglio!
## Writing Tests
So there was a lot of trial and error, which meant that I needed to be able to verify that things like the compression routine or archive reinsertion programs were working in a consistent way. A fantastic way to go about this is _writing tests_ and that’s exactly what I did. See a test for the compression implementation I wrote below:
## Scrivendo le Prove
Quindi ci furono moltissime prove e moltissimi errori, il che significa che dovevo essere in grado di verificare che cose come i programmi della routine di compressione o il reinserimento dell'archivio funzionassero in maniera consistente. Un modo fantastico di farlo è _scrivendo le prove_ ed è esattamente quello che ho fatto. Ecco una prova per l'implementazione della compressione che ho scritto sotto:
```csharp
[Test]
[TestCase("evt_000", TestVariables.EVT_000_DECOMPRESSED, TestVariables.EVT_000_COMPRESSED)]
[TestCase("evt_66", TestVariables.EVT_66_DECOMPRESSED, TestVariables.EVT_66_COMPRESSED)]
[TestCase("evt_memorycard", TestVariables.EVT_MEMORYCARD_DECOMPRESSED, TestVariables.EVT_MEMORYCARD_COMPRESSED, false)]
[TestCase("grp_c1a", TestVariables.GRP_C1A_DECOMPRESSED, TestVariables.GRP_C1A_COMPRESSED, false)]
[TestCase("evt_test", TestVariables.EVT_TEST_DECOMPRESSED, TestVariables.GRP_TEST_COMPRESSED)]
[TestCase("grp_test", TestVariables.GRP_TEST_DECOMPRESSED, TestVariables.GRP_TEST_COMPRESSED)]
public void CompressionMethodTest(string filePrefix, string decompressedFile, string originalCompressedFile)
{
byte[] decompressedDataOnDisk = File.ReadAllBytes(decompressedFile);
byte[] compressedData = Helpers.CompressData(decompressedDataOnDisk);
File.WriteAllBytes($".\\inputs\\{filePrefix}_prog_comp.bin", compressedData);
```csharp
[Test]
[TestCase("evt_000", TestVariables.EVT_000_DECOMPRESSED, TestVariables.EVT_000_COMPRESSED)]
[TestCase("evt_66", TestVariables.EVT_66_DECOMPRESSED, TestVariables.EVT_66_COMPRESSED)]
[TestCase("evt_memorycard", TestVariables.EVT_MEMORYCARD_DECOMPRESSED, TestVariables.EVT_MEMORYCARD_COMPRESSED, false)]
[TestCase("grp_c1a", TestVariables.GRP_C1A_DECOMPRESSED, TestVariables.GRP_C1A_COMPRESSED, false)]
[TestCase("evt_test", TestVariables.EVT_TEST_DECOMPRESSED, TestVariables.GRP_TEST_COMPRESSED)]
[TestCase("grp_test", TestVariables.GRP_TEST_DECOMPRESSED, TestVariables.GRP_TEST_COMPRESSED)]
public void CompressionMethodTest(string filePrefix, string decompressedFile, string originalCompressedFile)
{
byte[] decompressedDataOnDisk = File.ReadAllBytes(decompressedFile);
byte[] compressedData = Helpers.CompressData(decompressedDataOnDisk);
File.WriteAllBytes($".\\inputs\\{filePrefix}_prog_comp.bin", compressedData);
if (!string.IsNullOrEmpty(originalCompressedFile))
{
Console.WriteLine($"Original compression ratio: {(double)File.ReadAllBytes(originalCompressedFile).Length / decompressedDataOnDisk.Length * 100}%");
}
Console.WriteLine($"Our compression ratio: {(double)compressedData.Length / decompressedDataOnDisk.Length * 100}%");
if (!string.IsNullOrEmpty(originalCompressedFile))
{
Console.WriteLine($"Criterio Originale di Compressione: {(double)File.ReadAllBytes(originalCompressedFile).Length / decompressedDataOnDisk.Length * 100}%");
}
Console.WriteLine($"Il Nostro Criterio di Compressione: {(double)compressedData.Length / decompressedDataOnDisk.Length * 100}%");
byte[] decompressedDataInMemory = Helpers.DecompressData(compressedData);
File.WriteAllBytes($".\\inputs\\{filePrefix}_prog_decomp.bin", decompressedDataInMemory);
Assert.AreEqual(StripZeroes(decompressedDataOnDisk), StripZeroes(decompressedDataInMemory), message: "Failed in implementation.");
}
```
byte[] decompressedDataInMemory = Helpers.DecompressData(compressedData);
File.WriteAllBytes($".\\inputs\\{filePrefix}_prog_decomp.bin", decompressedDataInMemory);
Assert.AreEqual(StripZeroes(decompressedDataOnDisk), StripZeroes(decompressedDataInMemory), message: "Implementazione Fallita.");
}
```
This test compresses some data and then decompresses it to validate that the decompressed file is identical to the original one. This was used repeatedly while debugging the compression routine to ensure it was working as I implemented each part of it. Speaking of which…
Questo test comprime un po' di dati e poi li decomprime per validare che la decompressione dei file è identica a quella originale. Questo fu usato ripetutamente durante il debug della routine di compressione per assicurare che funzionasse mentre ne implementavo ogni parte. A proposito di quello…
## The Compression Routine
I had a number of questions about how I actually implemented the compression routine, so I thought I’d delve into that a bit here.
## La Routine di compressione
Ho avuto un bel po' di domande su come ho implementato la routine di compressione, quindi ho pensato di parlarne un po' qui.
I think the core process is actually pretty easy to understand: essentially, we’re just reversing what the decompression routine does. For example, when decompressing a file, we might first encounter a byte with the top bit cleared and the second bit set (i.e. `0b01xxxxxx`), which according to [the algorithm we reverse-engineered](/blog/2022-10-19-chokuretsu-compression) means that we take the lower 6 bits and add 4, then repeat the following byte that number of times (e.g., if we encounter `43 05` in the compressed buffer, we would write seven `05` bytes to the decompressed buffer). So, when compressing, we look for four or more repeated bytes in a row – if we encounter that repetition, then we encode the control byte followed by the repeated byte (e.g., if we encounter `05 05 05 05 05 05 05` in the decompressed buffer, we would write `43 05` to the compressed buffer).
Penso che il processo di base sia semplice da capire: in pratica, stiamo solamente facendo il reverse-engineering di quello che la routine di decompressione fa. Ad esempio, quando decomprimiamo un file, potremmo incontrare un byte con il primo bit a zero ed il secondo impostato (es. `0b01xxxxxx`), che stando all'algoritmo [del quale abbiamo effettuato il reverse-engineer](/blog/2022-10-19-chokuretsu-compression) significa che prendiamo gli ultimi 6 bit e gli aggiungiamo 4, per poi ripetere quel numero un po' di volte (ad esempio, se dovessimo incontrare `43 05` nel buffer di compressione, dovremmo scrivere sette byte `05` nel buffer di decompressione). Quindi, quando lo comprimiamo, dobbiamo cercare per almeno quattro byte ripetuti di fila – se dovessimo incontrare quella ripetizione, allora codifichiamo il byte di controllo seguito dal byte ripeturo (es. se dovessimo incontrare `05 05 05 05 05 05 05` nel buffer decompresso dovremmo scrivere `43 05` nel buffer compresso).
That’s basically the whole process. It gets quite complicated for the “sliding dictionary” that’s characteristic of [LZ compression](https://en.wikipedia.org/wiki/LZ77_and_LZ78) (which I call `lookback`s in my code). For those, I essentially keep a running dictionary of every four byte sequence in the file and check to see if the current four byte sequence is in that dictionary. If it is, I insert the control code for the lookback sequence into the compressed buffer.
Questo è praticamente l'intero processo. Diventa al quanto complicato per il "dizionario che scivola", una caratteristica della [compressione LZ](https://it.wikipedia.org/wiki/LZ77_e_LZ78) (che io chiamo le `retrospezioni` nel mio codice). Per quelli, tengo praticamente un dizionario che contiene ogni sequenza di quattro byte nel file e controllo se l'attuale sequenza di quattro byte è nel dizionario. Se lo è, lo inserisco nel codice di controllo per la sequenza della retrospezione nel buffer compresso.
## Finding Filenames
I told a lie of omission about the archive header – there’s more than just the magic integer section! If you scroll down past the magic integers, there’s another section the same length as the previous section and then a section past that which didn’t have a clearly-defined length but whose entries did seem tantalizingly patterned. For basically the entire development of the Chokuretsu utilities, I ignored these two sections entirely – literally skipping over them in the code.
## Trovare i Nomi dei File
Ho trascurato un dettaglio importante riguardo l'header dell'archivio – c'è altro oltre alla sezione dell'intero magico! Scorrendo sotto gli interi magici, c'è un'altra sezione della stessa lunghezza di quella precedente e poi un'altra sezione che non aveva una lunghezza ben definita ma i quali elementi sembravano seguire un pattern. Per praticamente l'intero sviluppo degli strumenti
per Chokuretsu, ho completamente ignorato queste due sezioni – saltandole letteralmente nel codice.
![A hex editor showing a section of a bin archive file with tons of incomprehensible ASCII text in it](/images/blog/0005/04_filenames_section.png)
![Un editor esadecimale che mostra la sezione di un archivio bin con molto testo incomprensibile in ASCII](/images/blog/0005/04_filenames_section.png)
As I was writing the previous post, I took another look at the latter of these two sections as I found it fascinating. Clearly there was something here – early on, I had commented that these could be filenames, but obviously they appeared to be nonsense…right?
Mentre stato scrivendo l'ultimo post, stato dando un'altra occhiata a queste due sezioni che ho trovato affascinanti. C'era sicuramente qualcosa qui – all'inizio, commentai che potessero essere i nomi dei file, ma ovviamente non sembravano avere un senso…giusto?
Now that I was pretty far into the project, though, I had a lot of knowledge at my disposal. I recalled that some of the event files had titles in them like `EV1_000`.
Ora che avevo fatto molti progressi nel progetto, però, avevo molta conoscenza a mia disposizione, ricordai che i file degli eventi avevano dei titoli come `EV1_000`.
![A hex editor showing a portion of an event file with the text EV1_001](/images/blog/0005/05_filename.png)
![Un editor esadecimale che mostra una porzione di un file di evento con il testo EV1_001](/images/blog/0005/05_filename.png)
So, on a whim, I took all of the “filenames” out and started doing a find/replace in VS Code one letter at at time. Pretty quickly, it became apparent that these were in fact filenames, just ciphered. I wrote a quick routine to decode them and suddenly, browsing through files got a bit easier!
Quindi, decisi di prendere tutti i "nomi dei file" e iniziai a fare un trova/sostituisci in VS Code una lettera per volta. In poco tempo, divenne apparente che questi erano infatti i nomi, semplicemente cifrati. Scrissi velocemente una routine per decifrarli e improvvisamente, navigare tra i file divenne un po' più facile!
![An editor with all of the files in dat.bin listed alongside their filenames](/images/blog/0005/06_deciphered_filenames.png)
![Un editor con tutti i file in dat.bin messi in lista insieme ai loro nomi](/images/blog/0005/06_deciphered_filenames.png)
## Other Random Things
## Altre Cose Casuali
### The Unhinged File Length Routine Revealed
Something else fun: after the second blog post, a person named Ethanol dropped into the Haroohie Discord server and dropped the bomb on what the unhinged file length routine actually does:
### La Pazza Routine Della Lunghezza Dei File Rivelata
Un'altra cosa divertente: dopo il secondo post del blog, una persona chiamata Ethanol è entrata nel server Discord di Haroohie e ha buttato una bomba su quello che la routine della lunghezza dei file fa veramente:
![A Discord message from a user named Ethanol; the message contents are reproduced below this image](/images/blog/0005/07_ethanol_division.png)
![Un messaggio su Discord da un utente chiamato Ethanol; i contenuti del messaggio sono riprodotti al di sotto di questa immagine](/images/blog/0005/07_ethanol_division.png)
> Yup! But I noticed something that I’m not sure it’s been brought up before about the “unhinged file length routine”
>
> And I wanted to mention it
>
> Jonko just remade division with his implementation \:P
>
> The unhinged function is just a fast integer division function the compiler did
> Già! Ma ho notato qualcosa del quale non credo sia stata menzionata prima riguardo la “pazza routine della lunghezza dei file”
>
> E ne volevo parlare
>
> Jonko ha semplicemente rifatto una divisione con la sua implementazione \:P
>
> La funzione pazza è solo una funzione veloce per dividere gli interi che ha fatto il compilatore
That’s right, it’s just division. 🙃 I’ve tested this since then and indeed, that’s what it is. A bit faster to just divide than to do my weird thing haha.
Esatto, è solo una divisione. 🙃 L'ho provata da quella volta ed effettivamente, è proprio quella. Dividere sarebbe stato un po' più veloce rispetto alla mia cosa strana haha.
![A Google Docs comment from my editor, Gordon Ramsay, reading Would you like to apologize to the devs, who you thought were fucking with you specifically](/images/blog/0005/08_apology.png)
![Un commento su Documenti Google dal mio editore, Gordon Ramsay, che legge "Would you like to apologize to the devs, who you thought were fucking with you specifically" (Ti piacerebbe scusarti con gli sviluppatori che pensavi che stessero prendendo per il culo a te in particolare)](/images/blog/0005/08_apology.png)
At the recommendation of my editor, I’d like to take this opportunity to apologize to the Chokuretsu devs, who were not, in fact, fucking with me specifically in this particular instance.
Seguendo il consiglio del mio editore, vorrei prendere quest'opportunità per scusarmi con gli sviluppatori di Chokuretsu, i quali non stavano, infatti, prendendo per il culo proprio a me questa particolare volta.
### Hardcoded Max File Length
One problem we ran into soon after we had the archive decoded was that the game started crashing when attempting to load one of the earliest event files. As we’ll get into in later posts, the event files necessarily become longer after we edit them. After a lot of investigation, it turned out that we were running into a problem where the game had a hardcoded max file length that we were exceeding. This is something that was outside of the archive entirely and coded as a constant in the actual game code. There were four places where it was coded, but here’s one:
### Lunghezza Massima Dei File Fissa
Un problema che abbiamo riscontrato subito dopo che abbiamo decodificato l'archivio era che il gioco crashava quando provava a caricare uno dei primi file degli eventi. Come diremo nei prossimi post, i file degli eventi diventeranno sempre più lunghi dopo che li modifichiamo. Dopo molta investigazione, abbiamo scoperto che ci eravamo imbattuti in un problema dove il gioco aveva un valore cablato per la lunghezza massima dei file, che noi stavamo superando. Questa è una cosa completamente al di fuori dell'archivio e codificata come valore costante nel codice del gioco. C'erano quattro posti dov'era codificato, ma eccone uno:
```arm
RAM:02033F00 MOV R0, #0x12000
RAM:02033F04 BL sub_202E1C8
```
```arm
RAM:02033F00 MOV R0, #0x12000
RAM:02033F04 BL sub_202E1C8
```
English Italian Actions
### Hardcoded Max File Length
One problem we ran into soon after we had the archive decoded was that the game started crashing when attempting to load one of the earliest event files. As we’ll get into in later posts, the event files necessarily become longer after we edit them. After a lot of investigation, it turned out that we were running into a problem where the game had a hardcoded max file length that we were exceeding. This is something that was outside of the archive entirely and coded as a constant in the actual game code. There were four places where it was coded, but here’s one:
### Lunghezza Massima Dei File Fissa
Un problema che abbiamo riscontrato subito dopo che abbiamo decodificato l'archivio era che il gioco crashava quando provava a caricare uno dei primi file degli eventi. Come diremo nei prossimi post, i file degli eventi diventeranno sempre più lunghi dopo che li modifichiamo. Dopo molta investigazione, abbiamo scoperto che ci eravamo imbattuti in un problema dove il gioco aveva un valore cablato per la lunghezza massima dei file, che noi stavamo superando. Questa è una cosa completamente al di fuori dell'archivio e codificata come valore costante nel codice del gioco. C'erano quattro posti dov'era codificato, ma eccone uno:
All this does is change that max length from 0x12000 to 0x16000. An easy fix, but nonetheless an annoying problem to have to find!
Tutto quello che fa è cambiare la lunghezza massima da 0x12000 a 0x16000. Una risoluzione facile, ma allo stesso tempo fastidiosa da trovare!
That’s right, it’s just division. 🙃 I’ve tested this since then and indeed, that’s what it is. A bit faster to just divide than to do my weird thing haha.
Esatto, è solo una divisione. 🙃 L'ho provata da quella volta ed effettivamente, è proprio quella. Dividere sarebbe stato un po' più veloce rispetto alla mia cosa strana haha.
I feel like the previous blog post might have given the impression that things went perfectly from the start and I want to emphasize that they super did not. This is a process of trial and error and constant learning for me – I didn’t even put together that these were archives while I was in the process of reverse-engineering them and was instead calling them “custom filesystems.”
Credo che il post precedente possa aver dato l'impressione che le cose andarono perfettamente dall'inizio e volevo evidenziare che non è stato assolutamente così. Questo è un processo di prova dopo prova e un insegnamento costante per me – non avevo neanche capito che questi erano archivi mentre ne stavo facendo il reverse-engineering e i stavo invece chiamando "filesystem personalizzati"
![The Chokuretsu main screen with significant corruption across multiple UI elements](/images/blog/0005/02_haruohno.png)
![La schermata principale di Chokuretsu con una significante corruzione sparsi su molteplici elementi della UI](/images/blog/0005/02_haruohno.png)
Much better!
Molto meglio!
This test compresses some data and then decompresses it to validate that the decompressed file is identical to the original one. This was used repeatedly while debugging the compression routine to ensure it was working as I implemented each part of it. Speaking of which…
Questo test comprime un po' di dati e poi li decomprime per validare che la decompressione dei file è identica a quella originale. Questo fu usato ripetutamente durante il debug della routine di compressione per assicurare che funzionasse mentre ne implementavo ogni parte. A proposito di quello…
> Yup! But I noticed something that I’m not sure it’s been brought up before about the “unhinged file length routine”
>
> And I wanted to mention it
>
> Jonko just remade division with his implementation \:P
>
> The unhinged function is just a fast integer division function the compiler did
> Già! Ma ho notato qualcosa del quale non credo sia stata menzionata prima riguardo la “pazza routine della lunghezza dei file”
>
> E ne volevo parlare
>
> Jonko ha semplicemente rifatto una divisione con la sua implementazione \:P
>
> La funzione pazza è solo una funzione veloce per dividere gli interi che ha fatto il compilatore
At the recommendation of my editor, I’d like to take this opportunity to apologize to the Chokuretsu devs, who were not, in fact, fucking with me specifically in this particular instance.
Seguendo il consiglio del mio editore, vorrei prendere quest'opportunità per scusarmi con gli sviluppatori di Chokuretsu, i quali non stavano, infatti, prendendo per il culo proprio a me questa particolare volta.
```arm
RAM:02033F00 MOV R0, #0x12000
RAM:02033F04 BL sub_202E1C8
```
```arm
RAM:02033F00 MOV R0, #0x12000
RAM:02033F04 BL sub_202E1C8
```
In a later post, we’ll cover how we do assembly hacking, but in short this required an assembly hack to fix as we had to patch in a new file length:
In un prossimo post, parleremo di come modifichiamo l'assembly, ma in sintesi questo problema richiedeva una hack di assembly per aggiustarlo poiché abbiamo dovuto modificarlo in una nuova lunghezza massima:
```arm
ahook_02033F00:
mov r0, #0x16000
bx lr
```
```arm
ahook_02033F00:
mov r0, #0x16000
bx lr
```
## See You Soon!
This is a shorter post, but I wanted to make sure I addressed some of the stuff that I left unsaid in the previous posts. Please look forward to the next posts in the series that will delve into how I reverse-engineered specific game files!
## Ci Vediamo Presto!
Questo è un post più corto, ma volevo assicurarmi di aver parlato di alcune cose che non avevo detto negli scorsi post. Perfavore aspettate il prossimo post della serie che parlerà di come ho fatto il reverse-engineering su certi file di gioco!
## Writing Tests
So there was a lot of trial and error, which meant that I needed to be able to verify that things like the compression routine or archive reinsertion programs were working in a consistent way. A fantastic way to go about this is _writing tests_ and that’s exactly what I did. See a test for the compression implementation I wrote below:
## Scrivendo le Prove
Quindi ci furono moltissime prove e moltissimi errori, il che significa che dovevo essere in grado di verificare che cose come i programmi della routine di compressione o il reinserimento dell'archivio funzionassero in maniera consistente. Un modo fantastico di farlo è _scrivendo le prove_ ed è esattamente quello che ho fatto. Ecco una prova per l'implementazione della compressione che ho scritto sotto:
My initial draft of the blog post covering the Shade bin archive files in Chokuretsu was long. Like, really long. There was a lot of stuff I necessarily had to cut in the final version in order to convey how I reverse-engineered the structure of the archive and got file reinsertion working. What’s more, a number of common questions came up in response to the first two posts and I hope to use this post to catalog my answers to some of them.
La mia bozza iniziale del post sui file di archivio bin Shade era lungo. Tipo, molto lungo. C'era molta roba che ho dovuto necessariamente tagliare nella versione finale per poter parlare di come ho eseguito il reverse-engineering della struttira dell'archivio e far funzionare il reinserimento dei file. Inoltre, un bel po' di domande chieste frequentemente arrivarono in risposta ai primi due post e spero di poter usare questo post per catalogare le mie risposte ad alcune di esse.
## No One Knows What They’re Doing
When I started writing the archive code, I did so simply wanting to extract files and not understanding the actual structure of the bin archives at all. Thus, I wrote code that simply looked for spacing between files to identify their offsets. Even as I learned more about the archive structure, reverse-engineered the magic integers, and worked on file replacement and eventually file insertion, I kept this very flawed architecture. Impressively, this code actually stuck around _until I wrote the previous blog post_ (lol). It caused a number of bugs – notably, I managed to corrupt a file in the graphics archive because it didn’t have spacing between it and its previous file (i.e. the previous file ended at something like 0x7F8 and it started at 0x800).
## Nessuno Sa Quello Che Fa
Quando iniziai a scrivere il codice sull'archivio, l'ho fatto volendo semplicemente estrarre i file e senza capire nulla della struttura dell archivio bin. Quindi, scrissi del codice che cercava semplicemente per gli spazi tra un file e l'altro per identificare i loro offset. Anche mentre imparavo sempre di più sulla struttura degli archivi, il reverse-engineer degli interi magici, e lavorando nella sostituzione dei file ed eventualmente il loro inserimento, continuai quest'architettura piena di problemi. Impressivamente, questo codice rimase tale _fino a quando scrissi il post precedente_ (lol). Ha causato un bel numero di bug, fui pure in grado di corrompere un file nell'archivio della grafica perché non aveva spazi intorno a sé ed il file precedente (il file precedente finiva circa in 0x7F8 e l'altro iniziava in 0x800).
It wasn’t until [Ermii](https://www.ermiisoft.net/) politely asked if they were archives that I realized that…yeah, that’s exactly what they were.
Fu così fino a quando [Ermii](https://www.ermiisoft.net/) chiese gentilmente se erano file di archivio, e lì realizzai che... sì, erano proprio quelli.
![A Discord message reading Custom Filesystem](/images/blog/0005/01_custom_filesystem_blunder.png)
![Un messaggio su Discord con scritto Custom Filesystem](/images/blog/0005/01_custom_filesystem_blunder.png)
I think the core process is actually pretty easy to understand: essentially, we’re just reversing what the decompression routine does. For example, when decompressing a file, we might first encounter a byte with the top bit cleared and the second bit set (i.e. `0b01xxxxxx`), which according to [the algorithm we reverse-engineered](/blog/2022-10-19-chokuretsu-compression) means that we take the lower 6 bits and add 4, then repeat the following byte that number of times (e.g., if we encounter `43 05` in the compressed buffer, we would write seven `05` bytes to the decompressed buffer). So, when compressing, we look for four or more repeated bytes in a row – if we encounter that repetition, then we encode the control byte followed by the repeated byte (e.g., if we encounter `05 05 05 05 05 05 05` in the decompressed buffer, we would write `43 05` to the compressed buffer).
Penso che il processo di base sia semplice da capire: in pratica, stiamo solamente facendo il reverse-engineering di quello che la routine di decompressione fa. Ad esempio, quando decomprimiamo un file, potremmo incontrare un byte con il primo bit a zero ed il secondo impostato (es. `0b01xxxxxx`), che stando all'algoritmo [del quale abbiamo effettuato il reverse-engineer](/blog/2022-10-19-chokuretsu-compression) significa che prendiamo gli ultimi 6 bit e gli aggiungiamo 4, per poi ripetere quel numero un po' di volte (ad esempio, se dovessimo incontrare `43 05` nel buffer di compressione, dovremmo scrivere sette byte `05` nel buffer di decompressione). Quindi, quando lo comprimiamo, dobbiamo cercare per almeno quattro byte ripetuti di fila – se dovessimo incontrare quella ripetizione, allora codifichiamo il byte di controllo seguito dal byte ripeturo (es. se dovessimo incontrare `05 05 05 05 05 05 05` nel buffer decompresso dovremmo scrivere `43 05` nel buffer compresso).
## Finding Filenames
I told a lie of omission about the archive header – there’s more than just the magic integer section! If you scroll down past the magic integers, there’s another section the same length as the previous section and then a section past that which didn’t have a clearly-defined length but whose entries did seem tantalizingly patterned. For basically the entire development of the Chokuretsu utilities, I ignored these two sections entirely – literally skipping over them in the code.
## Trovare i Nomi dei File
Ho trascurato un dettaglio importante riguardo l'header dell'archivio – c'è altro oltre alla sezione dell'intero magico! Scorrendo sotto gli interi magici, c'è un'altra sezione della stessa lunghezza di quella precedente e poi un'altra sezione che non aveva una lunghezza ben definita ma i quali elementi sembravano seguire un pattern. Per praticamente l'intero sviluppo degli strumenti
per Chokuretsu, ho completamente ignorato queste due sezioni – saltandole letteralmente nel codice.
As I was writing the previous post, I took another look at the latter of these two sections as I found it fascinating. Clearly there was something here – early on, I had commented that these could be filenames, but obviously they appeared to be nonsense…right?
Mentre stato scrivendo l'ultimo post, stato dando un'altra occhiata a queste due sezioni che ho trovato affascinanti. C'era sicuramente qualcosa qui – all'inizio, commentai che potessero essere i nomi dei file, ma ovviamente non sembravano avere un senso…giusto?
![A hex editor showing a portion of an event file with the text EV1_001](/images/blog/0005/05_filename.png)
![Un editor esadecimale che mostra una porzione di un file di evento con il testo EV1_001](/images/blog/0005/05_filename.png)
So, on a whim, I took all of the “filenames” out and started doing a find/replace in VS Code one letter at at time. Pretty quickly, it became apparent that these were in fact filenames, just ciphered. I wrote a quick routine to decode them and suddenly, browsing through files got a bit easier!
Quindi, decisi di prendere tutti i "nomi dei file" e iniziai a fare un trova/sostituisci in VS Code una lettera per volta. In poco tempo, divenne apparente che questi erano infatti i nomi, semplicemente cifrati. Scrissi velocemente una routine per decifrarli e improvvisamente, navigare tra i file divenne un po' più facile!

Loading…

User avatar FUYUME

Translation changed

  1. Haroohie Site
  2. content/blog/: 5.2023-03-10-chokuretsu-compression-archive-followup
  3. Italian
## Finding Filenames
I told a lie of omission about the archive header – there’s more than just the magic integer section! If you scroll down past the magic integers, there’s another section the same length as the previous section and then a section past that which didn’t have a clearly-defined length but whose entries did seem tantalizingly patterned. For basically the entire development of the Chokuretsu utilities, I ignored these two sections entirely – literally skipping over them in the code.
## Trovare i Nomi dei File↵
Ho trascurato un dettaglio importante riguardo l'header dell'archivio – c'è altro oltre alla sezione dell'intero magico! Scorrendo sotto gli interi magici, c'è un'altra sezione della stessa lunghezza di quella precedente e poi un'altra sezione che non aveva una lunghezza ben definita ma i quali elementi sembravano seguire un pattern. Per praticamente l'intero sviluppo degli strumenti
per Chokuretsu, ho completamente ignorato queste due sezioni – saltandole letteralmente nel codice.
a month ago
User avatar FUYUME

Translation added

  1. Haroohie Site
  2. content/blog/: 5.2023-03-10-chokuretsu-compression-archive-followup
  3. Italian
## Finding Filenames
I told a lie of omission about the archive header – there’s more than just the magic integer section! If you scroll down past the magic integers, there’s another section the same length as the previous section and then a section past that which didn’t have a clearly-defined length but whose entries did seem tantalizingly patterned. For basically the entire development of the Chokuretsu utilities, I ignored these two sections entirely – literally skipping over them in the code.
## Trovare i Nomi dei File↵
Ho trascurato un dettaglio importante riguardo l'header dell'archivio – c'è altro oltre alla sezione dell'intero magico! Scorrendo sotto gli interi magici, c'è un'altra sezione della stessa lunghezza di quella precedente e poi un'altra sezione che non aveva una lunghezza ben definita ma i quali elementi sembravano seguire un pattern. Per praticamente l'intero sviluppo degli strumenti
per Chokuretsu, ho completamente ignorato queste due sezioni – saltandole letteralmente nel codice.
4 months ago
User avatar None

String updated in the repository

  1. Haroohie Site
  2. content/blog/: 5.2023-03-10-chokuretsu-compression-archive-followup
  3. Italian
## Finding Filenames
I told a lie of omission about the archive header – there’s more than just the magic integer section! If you scroll down past the magic integers, there’s another section the same length as the previous section and then a section past that which didn’t have a clearly-defined length but whose entries did seem tantalizingly patterned. For basically the entire development of the Chokuretsu utilities, I ignored these two sections entirely – literally skipping over them in the code.
 
7 months ago
Browse all string changes

Things to check

Trailing space

Source and translation do not both end with a space

Fix string

Reset

Mismatched full stop

Source and translation do not both end with a full stop

Reset

Mismatching line breaks

Number of new lines in translation does not match source

Reset

Glossary

English Italian
No related strings found in the glossary.

String information

Source string location
:100
String age
7 months ago
Last updated
7 months ago
Source string age
7 months ago
Translation file
content/blog/5.2023-03-10-chokuretsu-compression-archive-followup/it.md, string 20