If you’re looking to make a totally new chapter (instead of being limited to the old game’s exact same scenes with exact same events) then read on, because I’m going to hack events next!

Chapter 49: Event Assembler Basics

There’s two main ways to do events. You can do them straight in hex with a hex editor, or with the Event Assembler. The Event Assembler is much easier, so I’m going to cover this.

First, some things to start you off:

• EA = Event Assembler

• STLB = Standard Library = the standard definitions included with the EA

• EALF = Event Assembler Language file = the text file with all the EA codes you can use.

• Assemble = use the Event Assembler to interpret the codes in a text file and turn it into hex that the game comprehends.

• Disassemble = Opposite of assemble, take the game’s events and put it into a text file with codes that you can understand.

You should of course know what pointers and offsets are. While knowledge of programming languages can be useful, it is not by any means necessary.

Download the Event Assembler and extract its files as you would any other program. I’m now going to tell you about the basics of event assembling.

The program itself isn’t going to be used much. Open it up and see for yourself.

The input is either where you put the text file (for assembling) or the ROM (for disassembling). You put the opposite thing in the output (so for assembling, you’re going to output a ROM, and for disassembling, you will output a text file).

Obviously you have to choose which game you want. When disassembling, you need to input an offset. The offset can either be an offset a pointer in the event reference table, or it can be the actual ‘header’ of the events. The header is a list of pointers saying what event data is where. If you are going to point to the latter, you need to select the appropriate checkbox.

I would just always add end guards since it’s not something you need to worry about too much.

Of course, when you have your correct input and settings, click “assemble” to assemble or “disassemble” to disassemble. This is how you work the EA. You’ll likely reference this part of the tutorial later because you’re not actually going to do any assembling for a while.

Your event assembler folder should look like this, but without the NewMacros file or template file.

“Language raws” is a folder of the EA assembler language raws… as in, it defines what code is what/it’s hex equivalent and the format of the code, as well as some other stuff. You can change it if you want.

EAstdlib is a library of standard EA definitions. You can edit it if you want, but since it’s the standard definitions, it’s not exactly supposed to be edited. If you look at my icon, it shows a notepad in it. That’s because I have set .event files to open with Notepad so I can edit them. Yes, that’s right—to edit the file, just open it in notepad.

Now, what exactly are definitions? It defines stuff. It can define a name for a value—for example, Lyn’s character hex is 0x2D, but instead of typing 0x2D, you could type ‘Lyn’ in the event assembler. This is easier than remembering the hex for every character/having to look it up. Tutorial (i.e. Lyn’s mode) Lyn would be Lyn_t. As said, you can view the files and see the definitions for each game.

#ifdef _FE8_

#ifndef _NO_FE8_DEFINITIONS_

#define Eirika 0x01

#define Seth 0x02

#define Gilliam 0x03

… (more entries)

#endif

#endif

This is stolen from the STLB. #ifdef _FE8_ is an ‘if’ statement that see if it’s FE8. It also checks to see if _NO_FE8_DEFINITIONS is marked. That is, if you DON’T want to use the standard FE8 definitions but rather your own definitions, you could use _NO_FE8_DEFINITIONS in your code, and when the EA checks to see if it should use the definitions, it’d be like “no, this is marked, so I can’t do it”.

For each #ifdef/#ifndef there has to be an #endif. Thus after all the definitions for characters, classes, and items, is an endif.

There are also these ‘shortcuts’ called macros. Macros simplify otherwise long processes. Let’s look at a few macros as well as other definitions in the STLB.

//Backwards compability

#ifdef _FE7_

#define IFEV IFEF

#endif

This defines one code as another code, so if a person had used an older verison and used one spelling, their code would still work.

#ifdef _FE8_

#define GotoPrepScreen "GOTO $591FD8; ENDA"

#endif

This macro makes a code “GotoPrepScreen” that the EA interprets as the code in quotes next to it. Instead of remembering that offset and the whole code, you can just type something easy to remember. Much better, huh? While we’re at it, do you see the semi-colon after the 8? A semi-colon is like a way of signifying a line break (a new line) without actually making it. Thus the EA knows that “GOTO” and “ENDA” are separate codes.

#define Village(eventID,offset,X,Y) "VILL eventID offset [X,Y] 0xE; LOCA eventID [X,Y-1] 0x1D"

While you still don’t know how to actually use macros and codes in your events, you should understand how they work. Everything inside of the parantheses, separated by commas, is a paremeter. eventID is a parameter—we know what event IDs are, of course. So is the offset of the village, as is the X and Y co-ordinates. However, that small code on the left comes out to be the code on the right—it’s much easier for us to use the code on the left. Make sure you get the connection—the input ‘X’ and ‘Y’ is the same input on the right for the ‘X’ and ‘Y’ there. However, we’re avoiding all the other codes and bytes by using our little shortcut. It’s why macros are so useful.

I think we’ve covered macros well enough that we can move on to the next file in the folder.

The Event assembler language file that I will be calling “EALF” is a list of all the codes you can use with the Event Assembler. It does not, however, include macros. It contains the “base codes”—the very codes that are defined in the language raws. It says what paremeters there are and explains the basics of each code.

I’m going to cover many codes (as well as some of my own macros) in another chapter. I will not cover every code, but I will cover enough that you will know what codes to use when and where and how they work in conjunction with the rest of the events.

The README should be read. Nothing else to say about that.

There’s also the template file Markyjoe1990 made. It has a base layout for codes. I’m going to give you a similar template in the next chapter.

The other file you saw me have was a custom file for my own macros. Don’t worry, I’ll share the macros with you in a couple chapters. :D