Haroohie Site/content/blog/: 12.2024-03-13-chokuretsu-event-files — English @ Weblate: In my first few posts, I explained how I figured …

Source string Source string

English

In my first few posts, I explained how I figured out how to extract files from the different Chokuretsu archives. This post is the start of the next series where we delve into how I reverse-engineered the contents of those files for the purpose of translating the game. Today, we’re covering the backbone of the game’s script – the _event files_. This is intended to serve as both an explanation of how I reverse-engineered these files and an introduction to trying to reverse-engineer files.

Needs editing

The string is read only.

Skip

	English	Actions
	--- title: &title "Chokuretsu ROM Hacking Challenges Part 4 – Event File Excavation" description: &desc "Jonko digs into the event files to figure out how to translate the game" locale: 'en' navigation: author: 'Jonko' year: 2024 month: 03 day: 13 tags: ['chokuretsu', 'romhacking'] image: '0012/00_thumbnail.png' head: meta: - property: 'og:title' content: title - property: 'og:description' content: desc - property: 'og:image' content: &img https://haroohie.club/images/blog/0012/00_thumbnail.png - property: 'og:image:alt' content: '' - property: 'og:url' content: 'https://haroohie.club/blog/2024-03-15-chokuretsu-event-files' - property: 'og:type' content: 'article' - name: 'twitter:title' value: title - name: 'twitter:description' value: desc - name: 'twitter:image' value: *img - name: 'twitter:site' value: '@haroohie' - name: 'twitter:card' value: 'summary_large_image' ---
	In my first few posts, I explained how I figured out how to extract files from the different Chokuretsu archives. This post is the start of the next series where we delve into how I reverse-engineered the contents of those files for the purpose of translating the game. Today, we’re covering the backbone of the game’s script – the _event files_. This is intended to serve as both an explanation of how I reverse-engineered these files and an introduction to trying to reverse-engineer files.
	## A Very Good Place to Start At the _very_ beginning of my work on the event files, I had cracked the compression algorithm, but not the archives. This meant I was able to view the files but not yet reinsert them into the game. That’s okay, though! A great place to start when looking at a file is to… well, look at it. Specifically, let's crack open the hex editor and see what we can find.
	So this is the first event file in the game (technically it’s the second chronologically and the 360th in the archive, but don’t worry about that right now):
	::image-gallery ---- images: [ {url: '/images/blog/0012/01_file01.png', alt: 'Event file part 1'}, {url: '/images/blog/0012/02_file02.png', alt: 'Event file part 2'}, {url: '/images/blog/0012/03_file03.png', alt: 'Event file part 3'}, {url: '/images/blog/0012/04_file04.png', alt: 'Event file part 4'}, {url: '/images/blog/0012/05_file05.png', alt: 'Event file part 5'}, {url: '/images/blog/0012/06_file06.png', alt: 'Event file part 6'}, {url: '/images/blog/0012/07_file07.png', alt: 'Event file part 7'}, ] ---- ::
	That’s it in all its 7.06 KiB of glory. I’m reproducing the entire file here for two reasons – one, so we can reference these images in context (I’ll make sure to mention the number you see above each screenshot when referencing something in that image), but also two, so that you can see how intimidating a file like this can look at first glance. That’s a lot of data! But not to worry – we can figure it out!
	As I mentioned, the above images are screenshots of a hex editor. In case you’ve forgotten how hexadecimal works, here’s a quick summary from the [compression blog post](/blog/2022-10-19-chokuretsu-compression):
	> Hexadecimal is also called base 16 – while we normally use decimal (base 10 – i.e. 0, 1, 2, 3, 4, 5, 6, 7, 8, 9) and computers use binary (base 2 – i.e. 0, 1), programmers often use hexadecimal because it allows us to represent a single byte in two characters. When writing numbers, to distinguish the base we often use 0x as a prefix for hex numbers (0x17 is 23 in decimal) and 0b to represent binary numbers (0b0000_0100 is 4 in decimal).
	A hex editor, therefore, is a program to view and edit the hexadecimal representation of files, meaning it allows us to take a peek and and even modify the raw file data. Neat!
	It’s also worth noting that in the past few posts, I’ve used CrystalTile2 for screenshots. I’ve since discovered [ImHex](https://imhex.werwolv.net/) which I think is fantastic. While it’s not what I used while working on this, I’m going to use it for screenshots anyway. I mention this in part because you might have noticed that there’s two columns of text to the right of the hexadecimal – one in gray/white and one in red/blue/gold. The gray/white one is the hexadecimal interpreted through the ASCII encoding while the red/blue/gold column is interpreted through the Shift-JIS encoding. If you recall from the compression blog post:
	> You might be familiar with ASCII, the most basic of encodings – each letter in the alphabet is represented by a single byte. This game uses an encoding called Shift-JIS, which is how Japanese was represented prior to the advent of Unicode.
	So ImHex allows us to see both encodings at once in addition to a bunch of other great features, which is why I made the switch!
	## Pointers Point the Way When you’re lost, you might ask someone for a pointer, and indeed that’s also what we’re going to look for here. In case you’re not following, I’ve copied this passage from the [archives blog post](/blog/2022-11-02-chokuretsu-archives):
	> An address is the absolute location of data in memory. When we set memory breakpoints in the debugger, we use addresses. > > An offset is the relative location of data in a file. When we have a single file open in the hex editor, we talk about offsets. > > A pointer is a value that points to an address or offset. A pointer to an address might look like an integer with the value 0x0220B4A8, while a pointer to an offset might be as simple as 0x3800. Addresses are used by the program when accessing memory, while offsets are used in files (since they can be loaded into arbitrary locations in memory), so it’s up to the program itself to convert those offsets into addresses.
	Why do we want to look for pointers? All files have to have some sort of consistent structure and logic – otherwise, computers won’t be able to read them. Pointers are the way that we imbue that structure into a file – a common pattern is to have a header section at the top of the file that has pointers to important places throughout the file. So let’s start at the top.
	First of all, we can see pretty clearly from the spacing of the numbers at the top of the first image (#1) that these are a series of 32-bit integers. How do I know? Well, it’s the spacing. We’ve got one or two bytes of numbers followed by two or three bytes of zeros repeating over and over again. Since a 32-bit integer is four bytes in length, this suggests that we’re looking at a sequence of that type.
	![The file header in the hex editor](/images/blog/0012/08_header.png)

	English	Actions
	Specifically, we’re going to again focus on pointers and see if we can find any that point to the dialogue lines. So let’s scroll down and find the first dialogue line (image #2) and then search for its offset in the file.
	Our third integer here is 0xA4, but at that offset, there’s nothing! It is, however, the first offset after the last integer of the `FrontPointers`. So maybe let’s rename it to `DataStartPointer`.
	```cs public class DialogueLine { public byte[] Data => Encoding.GetEncoding("Shift-JIS").GetBytes(Dialogue); public int Length => Data.Length; } ```
	And then we’ll add a new method to our `EventFile` class for editing dialogue lines:
	In my first few posts, I explained how I figured out how to extract files from the different Chokuretsu archives. This post is the start of the next series where we delve into how I reverse-engineered the contents of those files for the purpose of translating the game. Today, we’re covering the backbone of the game’s script – the _event files_. This is intended to serve as both an explanation of how I reverse-engineered these files and an introduction to trying to reverse-engineer files.
	## Pointers Point the Way When you’re lost, you might ask someone for a pointer, and indeed that’s also what we’re going to look for here. In case you’re not following, I’ve copied this passage from the [archives blog post](/blog/2022-11-02-chokuretsu-archives):
	We’ll get back to those – for now let’s return to the top of the file.
	The next integer we’re looking at is 0xE4 – this definitely looks like a pointer as well. If we follow it, we can see that it leads us straight to a string: `EV1_000`.
	This kind of looks like the title of the file, maybe! Something to keep in mind for later on. Perhaps this second pointer points to the title of the file?
	Look at that – we have a reference to it in the `FrontPointers` at the top of the file! This is getting interesting. For now, let’s jump back to the structures we found and see if we can analyze it to figure out what the other values are.
	\| `Unknown00` \| `Unknown04` \| `DialoguePointer` \| \|-------------\|-------------\|-------------------\| \| 0x02 \| 0x20C \| 0x47C \| \| 0x18 \| 0x214 \| 0x49C \| \| 0x02 \| 0x20C \| 0x4D0 \| \| 0x02 \| 0x20C \| 0x514 \| \| 0x02 \| 0x20C \| 0x534 \| \| 0x02 \| 0x20C \| 0x574 \| \| 0x02 \| 0x20C \| 0x00 \| \| 0x01 \| 0x21C \| 0x5F8 \| \| 0x04 \| 0x224 \| 0x630 \| \| 0x04 \| 0x224 \| 0x664 \|
	```cs public class DialogueLine { public int Speaker { get; set; } public int SpeakerNamePointer { get; set; } public int DialogueLinePointer { get; set; }
	public string SpeakerName { get; set; } public string Dialogue { get; set; } } ```
	First up, let’s take a look at the `TitlePointer`. Our hypothesis was that the third integer in the header points to the “title” of the file – but let’s open up another file to check.
	Nope, still 長門. Huh! It turns out, the nameplates are all images and not text, so I’m not really sure what these values are for. After several years of working on this game, my best guess is they were used by whatever script editors the devs used as an internal helper.
	![Instead, we try changing the speaker integer to 0x03](/images/blog/0012/22_change_speaker.png)
	```cs public enum SpeakerEnum { KYON = 0x01, HARUHI = 0x02, MIKURU = 0x03, NAGATO = 0x04, KOIZUMI = 0x05, KYON_SIS = 0x06, TSURUYA = 0x07, TANIGUCHI = 0x08, KUNIKIDA = 0x09, CLUB_PRES = 0x0A, CLUB_MEM_A = 0x0B, CLUB_MEM_B = 0x0C, CLUB_MEM_C = 0x0D, CLUB_MEM_D = 0x0E, OKABE = 0x0F, BASEBALL_CAPTAIN = 0x10, GROCER = 0x11, GIRL = 0x12, OLD_LADY = 0x13, FAKE_HARUHI = 0x14, STRAY_CAT = 0x15, UNKNOWN = 0x16, INFO = 0x17, MONOLOGUE = 0x18, MAIL = 0x19, } ```
	If you’ve ever been in a science class, you’ll notice that this process is essentially just the scientific method: create a hypothesis and then design an experiment to prove or disprove it. In a couple of cases above, we were able to disprove our hypotheses in ways that required revising them. We also managed to thoroughly confirm the speaker integer hypothesis and even gather a bunch of data. This is at the core of reverse-engineering data files. Investigation and looking for patterns in the hex editor will only get you so far – eventually, you have to crack open the game and see what happens as you start changing things.
	```cs public class DialogueLine { // Switching the speaker to the enum we defined before public SpeakerEnum Speaker { get; set; } public int SpeakerNamePointer { get; set; } public int DialogueLinePointer { get; set; }
	public DialogueLine(byte[] data) { Speaker = (SpeakerEnum)IO.ReadInt(data, 0x00); SpeakerNamePointer = IO.ReadInt(data, 0x04); DialogueLinePointer = IO.ReadInt(data, 0x08);
	Then we’ll use that to do the same for the event file as a whole
	// The first number in the end pointers was their count int numEndPointers = IO.ReadInt(data, EndPointersPointer); // We can loop using this as well for (int i = 0; i < numEndPointers; i++) { EndPointers.Add(IO.ReadInt(data, EndPointersPointer + i * 4 + 0x04)); }
	```cs bool reachedCharacterNames = false; for (int i = 0; i < FrontPointers.Count; i++) { uint pointerValue = IO.ReadUInt(data, FrontPointers[i]); if (pointerValue > 0x10000000 \|\| pointerValue == 0x8596) // 0x8596 is 妹 which is a valid character name, sadly lol { reachedCharacterNames = true; } else if (reachedCharacterNames) { DialogueSectionPointer = FrontPointers[i]; break; } } ```
	![A basic WPF GUI for editing dialogue lines](/images/blog/0012/24_dialogue_editor.png)
	![Translated text in the game!](/images/blog/0012/25_edited_text.png)

Loading…

None

String updated in the repository

English

In my first few posts, I explained how I figured out how to extract files from the different Chokuretsu archives. This post is the start of the next series where we delve into how I reverse-engineered the contents of those files for the purpose of translating the game. Today, we’re covering the backbone of the game’s script – the _event files_. This is intended to serve as both an explanation of how I reverse-engineered these files and an introduction to trying to reverse-engineer files.

English 0 characters edited Current translation Read only

a month ago

None

String updated in the repository

English

English 492 characters edited Current translation Translated

5 months ago

Browse all string changes

Things to check

Multiple failing checks

Following checks are failing:
Unchanged translation: German, Italian, Portuguese (Brazil), Chinese (Simplified)

Reset

Glossary

English	English
No related strings found in the glossary.

String information

Flags

read-only

Source string location

:39

String age

5 months ago

Last updated

a month ago

Source string age

5 months ago

Translation file

content/blog/12.2024-03-13-chokuretsu-event-files/en.md, string 2