Modding > Event Editing

How to make a Story Mod (WIP Tutorial)

(1/25) > >>

Elric:
HOW TO MAKE EVENTS

Xifanie has recently gone through and documented every bit of info we could hope
to have on events. Being as such I figured it was time to update this Tutorial.

Some things will remain as they were with some updates. And I will be removing several
of the sections and linking straight to the Wiki, which is already organized better than I
could do here.

You can find all the most up to date EVENT INSTRUCTIONS HERE
You can find the most up to date CONFIG.INI HERE

The older portions of this tutorial will receive another update very soon to use the updates that Xifanie
made to the config.ini These updates are still coming, I PROMISE :P
To start Editing Events we will need the following things:

EVSP                 <--This link Ver 1.91
FFTP                 <--This link Ver .480
Attack.out Editor <--This link Ver 1.02
CD Mage B5       <--This link Ver 1.02.1 Beta

I made these 2 videos a while back, and my written instructions below will follow them for the most part,
tho I will try to explain a bit more about camera angles.

http://www.youtube.com/watch?v=yWHl0gRLZYk
http://www.youtube.com/watch?v=DQLI-yTVNRc

You can follow most of these steps in the videos, for any steps not in the videos, I will post pictures to go along with them
UPDATE!
Some people are having issues where their events are not being imported even though the timestamp does update on the TEST.EVT
if you have this error using the Compile function in EVSP, then simply copy/pate your entire event from EVSP into a notepad and name it
event.txt, once you do this (you will likely have to remove the event.txt that is in the folder by default) run the Event_Compiler program.
Once the timestamp updates, reimport your TEST.EVT and it should fix your issue.

Step 01:  Create New folder named FFT, In this folder place your Vanilla ISO/BIN/Img, (or whatever you are using) along with your EVSP Folder, CDMage and Attack.out.[/li][/list] 

Step 02:  Extract the FFTP Pack (Preferably into a separate folder within the first folder) Run Shishi.

Step 03:  Load your FFT image file into Shishi and have it restructure the image. (Idk if this is necessary, it's just something I always do)

Step 04:  Open CD Mage, open your FFT Image file using M2/2352 Track, you will get a warning about parsing errors, choose to proceed.

Step 05:  Navigate to the event folder and scroll down to TEST.EVT, Right click and extract TEST.EVT to your desktop. Do the same for the ATTACK.OUT File

Step 06:  (Differs from video) Open your FFT Folder and open the EVSP folder. Now move the TEST.EVT into this folder and overwrite the TEST.EVT that is present.

Step 07:  (PSXEvents.txt is already present in the current version of EVSP, so you will not need to decompile it as shown in the video.)

Step 08:  Open the EasyVent Editor Super Perfect v1.91.exe

Step 09:  Take a few moments to semi-familiarize yourself with the buttons and menus, as these too differ from the video, I will explain further in the next section.

Step 10:  Once you are ready, click the Open Event button you will see a list of event names, you will want to open EVT_002_002 Orbonne Prayer.txt

Step 11:  (Look at all that weird stuff O.o Don't worry, by the time I'm done with you, most of these commands should be a breeze.)

Step 12:  For now, go click on the Maps tab and scoll down to 101 - Tutorial (1), we will use this to pick our unit placement

Step 13:  Now minimize the Event Editor for a moment and open up the Attack.out folder we made earlier, now place the ATTACK.OUT file we extracted earlier into this folder.

Step 14:  Open up the attack.out Editor and change the map on both 001 and 002 to Tutorial (1) See picture below
Step 15:  Click Save and close the Attack.out GUI

Step 16:  Go into your FFTP Folder and Open FFTP

Step 17: Once FFTP is open load your Vanilla Image file

Step 18: Click the ENTD tab and go down to 100 - Beginning of the game inside orbonne

Step 19: Right click on one of the blank random unit's and clone it, then paste it over all the current units except for Ramza

Step 20: Change Ramza to UNIT ID 1 (the spriteset has to be a Type 1 Human sprite for this tutorial, tho it doesn't technically have to be Ramza)

Step 21: Also make sure to check the Always Present box for Ramza (or whatever sprite you are using, which will be referred to as Ramza in this tutorial)

Step 22: Now we set the Coordinates, Pull EasyVent back up and look at the map. We are going to use 1,5. So in FFTP set Ramza's Coordinates to X=1, Y=5

Step 23: Now set Ramza's Initial Direction to East. Once this is done, Click the PSX tab at the top of FFTP and then click Patch ISO, locate your FFT image and hit OK to apply
the changes to the ENTD

Step 24: Now pull EVSP back up again and delete the entire event, the only line you want to keep is Offset(x00004000) that's it.

Step 25: Copy THIS and paste it after the offset in EVSP. Your EVSP should look like the picture below (forget the fact that my pic shows 1.9, I don't use 1.91, but it still works fine)

Step 26: As for what these commands all do, I will cover that in Section 2

Step 27: Now, Alt+A to select everything in EVSP. Copy and Paste the event into a notepad document called event.txt (this needs to be in the same
folder as the compiler.) Double click the Event_Compiler_2.01b.exe

Step 28: Once this is complete, you should go into your EVSP folder and confirm that the last modified time of the TEST.EVT reflected the current time. Confirming that the TEST.EVT was indeed updated.

Step 29: At this point it's time to open CD Mage, do this using the same method as before, but this time, we want to right click on the TEST.EVT and click Import. Navigate to the TEST.EVT in the EVSP folder and import it. Once this is done, repeat the process with the ATTACK.OUT File that we edited as well. It's is important that you get both the ATTACK.OUT & TEST.EVT Files.

Step 30: Hooray Last step! Now go and load up your favorite emulator and run the FFT Image that we modified. If all was done correctly once the game starts, instead of being in the Monastery you should see Ramza walking in place in the tutorial level for ~ 10 seconds and then it will move on to the next event. IF this happened then Congratulations, you now have your Blank event template for all future events! If you got different results, go back and follow all steps exactly, or PM me if you continue to have an issue.

Ok, quite a few things to cover here, Camera commands can be a total pain in the
ass, but if you take your time and use a bit of trial and error you can master
them quite easily, I will list some general Rules about Camera's once I have
finished the basic explanation.

There are several Camera configurations you can use:


{63}(rC9)
Camera(+01000,+00000,+00615,+00302,+02560,+00000,+04096,+00001)
Camera(+01000,+00000,+00615,+00302,+02560,+00000,+04096,+00128)
{4D}(r78)
Camera(+01000,+00000,+00615,+00302,+02560,+00000,+04096,+00128)
WaitForInstruction(x04,x00)


Camera setup A Will make the Camera spin into position at the beginning of the
event, as is seem commonly in battles.

http://www.youtube.com/watch?v=nuy1yEL_Nhk
{63}(rC9)
Camera(+01000,+00000,+00615,+00302,+02560,+00000,+04096,+00001)
Camera(+01000,+00000,+00615,+00302,+02560,+00000,+04096,+00001)
{4D}(r78)
Camera(+01000,+00000,+00615,+00302,+02560,+00000,+04096,+00128)
WaitForInstruction(x04,x00)


Camera setup B will make the Camera Fade In rather then spin in, which look much
more proper for non-battle events. Notice the only difference between A and B is the
time is changed in the second camera command.

http://www.youtube.com/watch?v=HuQnyTVYyB0
Camera(+00000,-00460,+00504,+00302,+03584,+00000,+04096,+00001)
WaitForInstruction(x04,x00)
{63}(rA9)
Camera(+01144,-00460,+00504,+00302,+03584,+00000,+04096,+00256)
WaitForInstruction(x04,x00)
{4D}(r40)


Camera setup C is the type of setup you would use for a battle event, the reason
for this is that many battle effects in the game do not take kindly to certain
camera commands and you can literally have a barrel rolling camera and random
crashes doing it the other way. Until we can uncover more info about the {63}
and {4D} commands, it will pretty much remain this way.
This is the explanation for Camera's in EVSP, I will explain as much of it as I
can for you:

Camera(+XXXXX,+ZZZZZ,+YYYYY,+ANGLE,+MAPRT,+CAMRT,+ZOOM%,+TIMER)
Moves camera around the map, like a small helicopter.  The coordinates used are
the map's absolute coordinates, not relative ones to where the camera currently
is.  All entry fields can range from -32768 to 32767. Tiles are 28x28, and
Camera motion is 4x more precise, so 112 = 1 Tile.  1h is 12 pixels high, so 48
= 1h, and units are 3h.  If this is the Camera() Command opening your Event, it
must be preceded by {63}(rC9) and followed by {4D})(r78) to function correctly,
else your Event will remain as a black screen.

XXXXX = X-Coordinate
+00112: 20 pixels = 1 Tile
+00392: 98 pixels = 3.5 Tiles.
+00896: 224 pixels = 9 Tiles.

ZZZZZ = Z-Coordinate
+00048: 1h (Centers on 3h)
+00192: 4h (Centers on 6h)
+00384: 8h (Centers on 10h)

YYYYY = Y-Coordinate
+00112: 20 pixels = 1 Tile
+00392: 98 pixels = 3.5 Tiles.
+00896: 224 pixels = 9 Tiles.

ANGLE = Camera Angle
+00000: +00.00 Degrees.
+00302: +26.54 Degrees.
+00341: +30.33 Degrees.
+01024: +90.00 Degrees.

MAPRT = Map Rotation
-03584: -315.00 Degrees.
-02560: -225.00 Degrees.
-01536: -135.00 Degrees.
-00512: -045.00 Degrees.
+00000: +000.00 Degrees.
+00512: +045.00 Degrees.
+01536: +135.00 Degrees.
+02560: +225.00 Degrees.
+03584: +315.00 Degrees.
 
(It is recommended that you never do rotations above 180 degrees in either direction.)

CAMRT = Camera Rotation

-02048: -180.00 Degrees.
-01024: -090.00 Degrees.
-00512: -045.00 Degrees.
+00000: +000.00 Degrees.
+00512: +045.00 Degrees.
+01024: +090.00 Degrees.
+02048: +180.00 Degrees.

ZOOM% = Camera Zoom Percentage

+02048: 050%
+04096: 100%
+08192: 200%

TIMER = Time required to fulfill instruction.

+00050: 0.50 Seconds.
+00100: 1.00 Seconds.
+00300: 3.00 Seconds.Lets look at the camera setup from our Blank Template event,

{63}(rC9)
Camera(+00560,-00048,+00560,+00302,+03584,+00000,+04096,+00001)
Camera(+00560,-00048,+00560,+00302,+03584,+00000,+04096,+00128)
{4D}(r78)
Camera(+00560,-00048,+00560,+00302,+03584,+00000,+04096,+00128)

You can see here that based on the info I've provided above as well as what is
explained in EVSP:

-We have moved the camera ~ 4-5 panels in the X and Y axis,

-We have moved the Z axis up 1 (remember for Z + is down and - is up)-The ANGLE is set to 26.54 Degrees (this is the same as when you normally enter
a battle, if you were to press the R2 button and bring that map angle up then
you would be switching to 30.33 Degrees, always try to think of it this way, it
will help you)-We have the MAPRT set to 315.00 Degrees, this will go from the original
position of the map, so try to when in doubt you can always zero this out and do
some trial and error.

-Our CAMRT is set to zero, just pretend this doesn't exist, I cannot think of
any instance in which it would be useful unless you wanted to make someone dizzy
and disoriented. Avoid at all fucking costs.-Our ZOOM is set to 100%, this will always look the best in most circumstances,
tho it can be push a bit more or less, but you risk some funny look sprites.-And our TIMER is set to 00001, 00128 and 00128, being the only difference
between the 3 camera commands, remember the explanation from earlier and decide weither you
want your camera to spin in, or fade in.
Now that you can see the general idea of a camera, lets talk about some rules

RULES OF CAMERA CONTROL:

You only have 4 basic camera angles, imagine being in a battle in FFT, now hit
the R1 button 4 times. What happens? You go thru 3 different angles then back to
the original. Those numbers below represent those 4 angles for any given map.

+00512: +045.00 Degrees.
+01536: +135.00 Degrees.
+02560: +225.00 Degrees.
+03584: +315.00 Degrees.

If you try to stray to far in between 2 of these numbers such as something like
+01028 you will have very ugly results, it's always best to stick as close to
these base numbers as possible to avoid any graphic ugliness. It may be hard 
when trying to find that "perfect" camera angle, but sometimes it's more
productive to just change the event a bit to accommodate the camera. Love the
Camera and it will love you back.There is a reason that the ZOOM in vanilla is set to 100% in nearly every camera
instance, because it's not suppose to change, once you have a better
understanding of events and want to experiment a bit you may find use to change
this. But in most instances it's better to leave well enough alone.Of all the things I've learned in events, Camera commands are the hardest to
master, I've managed to pull off some rather unique camera work in certain
events, but others just get junked over and over. I have spent more then 3-4
hours alone just working on camera angles in events. Keep this in mind when you
are ready to RageQuit.
Like I said, Camera's are a pain, but just try to follow the 3 Rules listed
above and use the rest of the info to guide you and you should be just fine.
UnitAnim(xID,xAl,xSQ,xEV,x00)

You will likely use this A LOT in events.

UnitAnim(xID,xAl,xSQ,xEV,x00)

Calls a certain animation, and applies it to specified Unit(s).

ID = Unit ID
Target Unit's ID in ENTD.

Al = Affect All
x01: affects all units instead of just Unit ID.

SQ = SEQ ID
Loads corresponding animation from unit's SEQ file.

EV = EVTCHR Frame
x00: Uses SEQ Frames.
x01: Uses EVTCHR Block 1 Frames.
x02: Uses EVTCHR Block 2 Frames.

SEQ Frame List:
(Video of SEQ frames by Elric42 here: http://www.youtube.com/watch?v=nuy1yEL_Nhk)
Now these are used for both Normal and EVTCHR frames, but I will be explaining EVTCHR much later in the guide,
so For now we will just focus on the normal UnitAnim frames, which are listed in EVSP in the UnitAnim section.

You should know what this is by now. This would be x01 for Ramza (or whatever unit you would like to perform the animation.)Another easy one.
x00 means that it will only effect the unit ID that was input in the xID section.
x01 means it will effect everyone on the team of the used Unit ID.
(Alternatively you could put 00 for the unit ID and make it effect everyone on the field by using a command such as UnitAnim(x00,x00,xSQ,x00,x00)

So since we only want to effect Ramza right now we end up with:

UnitAnim(x01,x00,xSQ,xEV,x00)SEQ are the frames or animations that you would like to use for the character. You will notice that I made a video showing all these animations in the EVSP explanation or it can also be viewed here:
http://www.youtube.com/watch?v=nuy1yEL_Nhk

For right now, we are going to make Ramza stand still, so for that we will use SEQ 02
after which we end up with:

UnitAnim(x01,x00,x02,xEV,x00)Since I won't be explaining EVTCHR until later on, we will go ahead and turn the xEV into x00. So we now have:

UnitAnim(x01,x00,x02,x00,x00)
We are going to place this before the camera command so that by the time we see Ramza he will already be standing still.

So at this point our event should look like:

http://pastebin.com/QrJ5AY0uOffset(x00004000)

UnitAnim(x01,x00,x02,x00,x00)

{63}(rC9)
Camera(+00560,-00048,+00560,+00302,+03584,+00000,+04096,+00001)
Camera(+00560,-00048,+00560,+00302,+03584,+00000,+04096,+00128)
{4D}(r78)
Camera(+00560,-00048,+00560,+00302,+03584,+00000,+04096,+00128)


Wait(01000)
EventEnd()

//INSTRUCTION SECTION END -  TEXT START
//Message x01
{font:08}XXX{br}
{font:00}XXX{end}Focus is another fairly easy command. You will most likely use this for Battle Dialogue,
or if you are just to lazy to make a proper camera command.

Focus(xID,x00,xID,x00,x00)

Focuses the camera on the target unit.

ID = Unit ID.
Target Unit's ID in ENTD.
This is how you will see a focus command used.

{63}(rAA)
Focus(x01,x00,x01,x00,x00)
Camera(+00001,+01253,+04352,+00302,+00512,+00000,+04096,+00032)
WaitForInstruction(x04,x00)

Now look below at my camera command after the focus command. It looks a bit.. off
doesn't it? Well if you look at vanilla events that have battle dialogue you will
see most are like this.

This example is from Bariaus Hill and other maps won't always work with the same
camera setup when using focus.

For best results, look at battle dialogue events or focus commands in victory events.
This is another one you are likely to use a lot for Dialogue in events. I will also explain several other commands
that go with this as well.

DisplayMessage(x10,xDT,xMSG#,xID,x00,xPR,+XXXXX,+YYYYY,+ARPOS,xOT)

Now, looking at this, it looks like a lot more then what it really is:

To start we are going to assume you want to use this dialogue box to
make Ramza talk. Anytime the box is coming from a person standing in one place
(I will explain dialogue for moving Unit's and none unit specific Dialogue Boxes in Section 3)

I put zero's in the X,Y and ARPOS, this is because when using a dialogue box that has a unit ID in it, it will
automatically center over/under the character speaking.

So what we have now is:

DisplayMessage(x10,xDT,xMSG#,xID,x00,xPR,+00000,+00000,+00000,xOT)These are the Dialogue Type's from EVSP:

DT = Dialogue Type.
x01: Top of Screen
x02: Bottom of Screen
x04: Thinking
x08: No Arrow
x10: Dialogue Box
x20: Named Box ("Check" if x10=False, "Help" if True.)
x40: Independent Message Box
x80: Close with Instruction

One thing you need to keep in mind is that you add these together to get your
result for the DT section of the DisplayMessage command.

11 - Above speaking Unit                                 10+1
12 - Below speaking Unit                                 10+2
15 - Thinking bubbles above Unit                      10+1+4
16 - Thinking bubbles below unit                       10+2+4
91 - Above speaking Unit, Close with instruction  10+1+4+80
92 - Below speaking Unit, Close with instruction   10+2+4+80
So now we will just say we used 11, what we end up with so far is:

DisplayMessage(x10,x11,xMSG#,xID,x00,xPR,+00000,+00000,+00000,xOT)This one is easy, this is the number the matches the dialogue number at the bottom of the event. Keep in mind,
that these must do in order are they are in hex meaning 0-9 A-F 10-19 1A-1F etc.

Since this is our first message for the event we would use 0001, which brings us to:

DisplayMessage(x10,x11,x0001,xID,x00,xPR,+00000,+00000,+00000,xOT)Another simple one, this is the Unit ID who you want to display the message over, remember we switched Ramza to 01

in the first section, so that is what we will use here. Now we have:

DisplayMessage(x10,x11,x0001,x01,x00,xPR,+00000,+00000,+00000,xOT)
I will explain this one in another section, you can read the explanation in EVSP if you like.
Something like this will be used in more advanced situations, such as for EVTCHR Portriats and
things like that. This will be included in Section 3.

For now, we are going to make it 00. Now we have:

DisplayMessage(x10,x11,x0001,x01,x00,x00,+00000,+00000,+00000,xOT)The last part is OT which is your Dialogue Box Opening Type. I normally always set this to 03, but
I didn't notice a big different between different numbers I've seen used in vanilla.

So this would finish up the command at:

DisplayMessage(x10,x11,x0001,x01,x00,x00,+00000,+00000,+00000,x03)
Now, you would be done if you wanted the dialogue to play along with the event, but this is not normally the case,
so in most circumstances we will need a WaitForInstruction command to go after the dialogue command. If we look at
E5 WaitForInstruction in EVSP we see that x01 is used for ShowDialog. So in the end, what we have is.

DisplayMessage(x10,x11,x0001,x01,x00,x00,+00000,+00000,+00000,x03)
WaitForInstruction(x01,x00)

Now the command portion of this section is finished. Note that these instructions will remain the same for using a

xDT of x12, x15 and x16. x91 and x92 are used a bit differently and will be explained after the dialogue portion.

Now look near the bottom of the event, you will see the:

//INSTRUCTION SECTION END -  TEXT START

Everything after this will be will you will setup your actual dialogue, for example:

//Message x01
{font:08}{Ramza}{br}
{font:00}
Random dialogue here!{br}
{br}
More Random{br}
Dialogue!{end}

Anytime you want Ramza to speak always make sure to put in {Ramza} for the name, if you forget those {} then
the name won't change to whatever you set it to at the beginning of the game.

Font:08 tells the game that this font is to appear red, this is hw you make a name in FFT.
Font:00 tells the game that this font is to appear white, this is how you make normal Dialogue.

You get 3 lines per page, and the name counts on the first page, so you only really get 2 on that one
always make sure that your lines break with {br} and that the last line on a page is a bit shorter then
the lines before it. Otherwise the turn page icon will appear over your text in the event.

In the above example I set it up to show Ramza speaking one line, then going to the next page where he speaks 2

more then it ends. Also make sure to put {end} at the end of your dialogue otherwise the next dialogue will
become a part of it, cause very undesired results.

So now our event should look like:

ChangeDialog(xDD,xMSG#,xPR,x00)

Using x91 and x92:

Now that we have all the basic dialogue stuff down we can move to something else we will see alot in Vanilla. Take

this for example:

DisplayMessage(x10,x91,x0001,x01,x00,x00,+00000,+00000,+00000,x03)
WaitForInstruction(x01,x00)
ChangeDialog(x01,xFFFF,x00,x00)
WaitForInstruction(x01,x00)

Now you will see some familiar commands here, in fact the only new one is ChangeDialog. Now with ChangeDialog we
can do several things, most commonly this would be used for displaying a second message, making it possible to put
another command in between the 2 separate sets of dialogue for the same character without actually removeing the
box. Say you wanted a character to stop and turn to another unit during a conversation without the bubble closing,
that is one use that I will explain in Section 3. As for right now I'm just going to explain this basic setup.
xDD in this will either be x01 or x02. x01 will be used if the message type on the DisplayMessage was x91, x02
will be used if it was x92. this is why it only works with these 2 numbers since ChangeDialog doesn't go higher
then x02 in the xDD section.

In an instance such as the one shown above where we used either x91 or x92, the Dialogue will not close until it
is followed up by a ChangeDialog command with the xFFFF in the xMSG# section

the xPR in this is something I will explain in section 3 just as with the xPR in DisplayMessage

So the end result will be quite similar to the other display setup, which will look like:

WalkTo(xID,x00,XXX,YYY,xEL,x00,+SPD,x01)
WaitWalk(xID,x00)

These are another 2 very commonly used commands. In most normal circumstances, this is how you will move your character around the map during an event.

So now, lets take a look:

WalkTo(xID,x00,XXX,YYY,xEL,x00,+SPD,x01)

Walks unit to a chosen square, path taken affected by unit's Jump score.

ID = Unit ID.
Target Unit's ID in ENTD.

XXX = X-Coordinate
Target Panel's X-value.

YYY = Y-Coordinate
Target Panel's Y-value.

EL = Elevation
x00: Lower Elevation Tile
x01: Higher Elevation Tile

SPD = Speed
+008: Walk
+032: Run
A short Explanation on WaitWalk.

This one is very self explanatory, but in case I need to explain;
WaitWalk(xID,x00) is what we have, Anytime you want to walk you will likely
use a WaitWalk afterward, the xID would be the same ID as the unit that is walking.
This makes it so that the next action will not take place until this unit is done
walking (unless done in a block, which will be explained later).
Now onto Walkto

You should know by now that this will obviously be x01This would be the X and Y that you want to walk to on the map

Now we currently have Ramza standing still at 1,5, so lets have him walk around a bit shall we?

This map below marks the path we will make Ramza walk:


So you can see that we will go to 1,7 then 5,7 then 5,3 then 1,3 and finally back to 1,5 again.

I included a wait command to make sure the camera has enough time to start up before the walking takes place, For more info on Wait Commands,
look further down in Section 2.

So what we have now, including the Wait & Waitwalk commands will look like:

Wait(00200)

WalkTo(x01,x00,001,007,xEL,x00,+SPD,x01)
WaitWalk(x01,x00)

WalkTo(x01,x00,005,007,xEL,x00,+SPD,x01)
WaitWalk(x01,x00)

WalkTo(x01,x00,005,003,xEL,x00,+SPD,x01)
WaitWalk(x01,x00)

WalkTo(x01,x00,001,003,xEL,x00,+SPD,x01)
WaitWalk(x01,x00)

WalkTo(x01,x00,001,005,xEL,x00,+SPD,x01)
WaitWalk(x01,x00)

Now since we are done walking after this we are going to add another UnitAnim
to make Ramza stop walking, remember how we did that earlier?

Go grab the UnitAnim(x01,x00,x02,x00,x00)

that we made earlier and place it after the last Walkto command. And he will stop once the walking cycle has finished.xEL is your Elevation. Now YOU DO NOT have to increase this when going to higher platforms unless it is panel that you can be above or below.

An example would be the bridge in the Zirekile Falls map. You can be on the bridge or below the bridge.

For this since they would be the same panel number, you would have to use x01 in the xEL place to mark that
you wanted to use the higher elevation panel rather then the one below. As shown in the below picture:
Another rather simple one. This controls the speed at which you walk +028 being the normal vanilla
walking speed for events. You can play around with this a bit to see different results. Not much you can mess up here.
So now that all this is in place we should have an event that now looks like:

http://pastebin.com/Au5v0yktOffset(x00004000)

UnitAnim(x01,x00,x02,x00,x00)

{63}(rC9)
Camera(+00560,-00048,+00560,+00302,+03584,+00000,+04096,+00001)
Camera(+00560,-00048,+00560,+00302,+03584,+00000,+04096,+00128)
{4D}(r78)
Camera(+00560,-00048,+00560,+00302,+03584,+00000,+04096,+00128)

Wait(00200)

WalkTo(x01,x00,001,007,x00,x00,+028,x01)
WaitWalk(x01,x00)

WalkTo(x01,x00,005,007,x00,x00,+028,x01)
WaitWalk(x01,x00)

WalkTo(x01,x00,005,003,x00,x00,+028,x01)
WaitWalk(x01,x00)

WalkTo(x01,x00,001,003,x00,x00,+028,x01)
WaitWalk(x01,x00)

WalkTo(x01,x00,001,005,x00,x00,+028,x01)
WaitWalk(x01,x00)

UnitAnim(x01,x00,x02,x00,x00)

DisplayMessage(x10,x11,x0001,x01,x00,x00,+00000,+00000,+00000,x03)
WaitForInstruction(x01,x00)

Wait(01000)
EventEnd()

//INSTRUCTION SECTION END -  TEXT START

//Message x01
{font:08}{Ramza}{br}
{font:00}
Random dialogue here!{br}
{br}
More Random{br}
Dialogue!{end}The rest of Section 2 is all very easy, so go ahead and pat yourself on the back for making it this far.

Now Lets look at the next one

RotateUnit(xID,xNE,xDR,xCL,xRS,TIM)
WaitRotateUnit(xID,x00)

RotateUnit(xID,xNE,xDR,xCL,xRS,TIM)

Rotates target unit in specified direction.

ID = Unit ID
Target Unit's ID in ENTD. x00 Affects all units.

NE = No Enemies
x00: Affect Enemies.
x01: Do Not Affect Enemies.

DR = Direction Rotated To
(Using the Battle-Standing Frame, UnitAnim() 06, 07, 08.)
x00: South East
x01: South
x02: South
x03: South West
x04: South West
x05: West
x06: West
x07: North West
x08: North West
x09: North
x0A: North
x0B: North East
x0C: North East
x0D: East
x0E: East
x0F: South East

(Using proper Standing Frame, UnitAnim() 01, 02.)
x00: South
x01: Southwest
x02: Southwest
x03: West
x04: West
x05: Northwest
x06: Northwest
x07: North
x08: North
x09: Northeast
x0A: Northeast
x0B: East
x0C: East
x0D: Southeast
x0E: Southeast
x0F: South

CL = Clockwise or Counter Clockwise
x00: Automatic (shortest way)
x01: Clockwise
x02: Counter-clockwise

RS = Rotation Speed per 45 Degrees
x00: 3/8 seconds
x01: 1/4 seconds
x02: 1/16 seconds
x03: 1/16 seconds
x04: 1/16 seconds
x05: 1/4 seconds
x06: 1/8 seconds
x07: 1/16 seconds
x08: 3/4 seconds
x09: 5 seconds
x0A: 1 second
x0B: 1/2 seconds
x0C: 5/4 seconds

TIM = Time before next Unit Rotates.
000: Instant.
255: 1 Second.
Now, do you remember how we did the walk command? If you look at how we did and and think about how walking works.
In the end of it Ramza would be facing north, so our objective here will be to make him look East again once he is done walking.
So let's break this down:

If I still have to explain this, then I have failed in this tutorial. This will be x01As you can see by the EVSP explanation, chooses weither or not enemy teams are effected,
keep in mind that in order for the 00 to take effect and make it effect enemies and units alike,
you will have to put 00 in the ID portion rather then a actual unit IDNow this one has caused some confusion will people. There are 2 different standing Poses in FFT, both are done by UnitAnim. 02 and 07
02 is used for events, as you already know by the UnitAnim we setup earlier. 07 is only used for in battle dialogue, think when Miluda speaks and the units stop to turn and look at her.

Now when using RotateUnit, you need to know which standing Pose the Unit is currently using.
If you are using 02, then you will follow this:
x00: South
x01: Southwest
x02: Southwest
x03: West
x04: West
x05: Northwest
x06: Northwest
x07: North
x08: North
x09: Northeast
x0A: Northeast
x0B: East
x0C: East
x0D: Southeast
x0E: Southeast
x0F: South
If you are using 07, then you will follow this:
x00: South East
x01: South
x02: South
x03: South West
x04: South West
x05: West
x06: West
x07: North West
x08: North West
x09: North
x0A: North
x0B: North East
x0C: North East
x0D: East
x0E: East
x0F: South East
So given that info, we now have:

RotateUnit(x01,x00,x0B,xCL,xRS,TIM)
All this does is choose if you want to make the char turn Clockwise or Counter Clockwise,
I always leave it at 00 since that just chooses the fastest direction

Now we are at:

RotateUnit(x01,x00,x0B,x00,xRS,TIM)
Another simple one. How fast do you want to turn? This is another one that I generally leave at 00, since it seems to be the smoothest movement.

Now:

RotateUnit(x01,x00,x0B,x00,x00,TIM)
Last part for this command, I have never touched this personally, it supposedly effects the time before another unit can Rotate,
but i use other methods for this, you however may find it useful. But for now since Ramza is the only character, we will leave it at 000.
Which completes the RotateUnit Command at:

RotateUnit(x01,x00,x0B,x00,x00,000)
WaitRotateUnit(xID,x00)
Very easy, if you remember the WaitWalk command from above, this functions the exact same way, meaning the
event won't proceed past it until after the Unit Rotation is complete
Now we will place our completed commands after the second UnitAnim in the event. Which should look like this:

Offset(x00004000)

UnitAnim(x01,x00,x02,x00,x00)

{63}(rC9)
Camera(+00560,-00048,+00560,+00302,+03584,+00000,+04096,+00001)
Camera(+00560,-00048,+00560,+00302,+03584,+00000,+04096,+00128)
{4D}(r78)
Camera(+00560,-00048,+00560,+00302,+03584,+00000,+04096,+00128)

Wait(00200)

WalkTo(x01,x00,001,007,x00,x00,+028,x01)
WaitWalk(x01,x00)

WalkTo(x01,x00,005,007,x00,x00,+028,x01)
WaitWalk(x01,x00)

WalkTo(x01,x00,005,003,x00,x00,+028,x01)
WaitWalk(x01,x00)

WalkTo(x01,x00,001,003,x00,x00,+028,x01)
WaitWalk(x01,x00)

WalkTo(x01,x00,001,005,x00,x00,+028,x01)
WaitWalk(x01,x00)

UnitAnim(x01,x00,x02,x00,x00)

RotateUnit(x01,x00,x0B,x00,x00,000)
WaitRotateUnit(x01,x00)

DisplayMessage(x10,x11,x0001,x01,x00,x00,+00000,+00000,+00000,x03)
WaitForInstruction(x01,x00)

Wait(01000)
EventEnd()

//INSTRUCTION SECTION END -  TEXT START

//Message x01
{font:08}{Ramza}{br}
{font:00}
Random dialogue here!{br}
{br}
More Random{br}
Dialogue!{end}Block Command looks like:

BlockStart()

BlockEnd()

Anything you put in a block will happen at the same time as what is after
it. Used for making units walk and do other things at the same time.
See Wiki for limitations on which commands can be used in blocks.



ADD UNITS INTO EVENT AFTER TELEPORT OUT, OR IF NOT SET TO ALWAYS PRESENT
IN ENTD

AddUnitStart()
AddUnit(x01,x00,x01)
AddUnit(x0D,x00,x01)
AddUnit(x0F,x00,x01)
AddUnitEnd()
WaitAddUnitEnd()


WARPUNIT TO SPECIFIC COORDINATES 00,01,02,03 = S,W,N,E
(x0D, x01, x0F are Unit IDs)

WarpUnit(x0D,x00,002,000,x00,x02)
WarpUnit(x01,x00,003,000,x00,x02)
WarpUnit(x0F,x00,004,000,x00,x02)



WAIT COMMAND

Wait(00010)


WALK IN FROM SOUTHERN EDGE OF MAP. UNIT MUST BE ERASED OR NOT PRESENT (WITH ADDUNIT)
BEFORE THIS COMMAND SET. REMOVE BLOCK (START & END) IF YOU DO NOT WANT COMMANDS
FOLLOWING THIS TO HAPPEN AT THE SAME TIME AS THIS

BlockStart()
SpriteMove(x01,x00,+00000,+00000,-00014,x00,x01,+00000)
ColorUnit(x01,x00,x01,-006,-004,-002,000)
Wait(00002)
Draw(x01,x00)
ColorUnit(x01,x00,x08,+000,+000,+000,004)
SpriteMove(x01,x00,+00000,+00000,+00000,x00,x01,+00018)
WaitSpriteMove(x01,x00)
WalkTo(x01,x00,001,005,x00,x00,+008,x01)
WaitWalk(x01,x00)
UnitAnim(x01,x00,x0002,x00)
RotateUnit(x01,x00,x00,x00,x00,x00)
WaitRotateUnit(x01,x00)
BlockEnd()


CAMERA SETUP FOR FADE IN

{63}(rC9)
Camera(+00225,-00048,+00600,+00302,-00512,+00000,+04096,+00001)
Camera(+00225,-00048,+00600,+00302,-00512,+00000,+04096,+00001)
Reveal(120)
Camera(+00225,-00048,+00600,+00302,-00512,+00000,+04096,+00128)
WaitForInstruction(x04,x00)


SPRITEMOVE 1 PANEL SOUTH INSTANTLY (USED FOR WALKING IN OFF MAP)

SpriteMove(x01,x00,-00000,+00000,-00028,x00,x01,+00000)


DRAW/ERASE COMMANDS

Draw(x01,x00)
Erase(x01,x00)


WALKTO COMMAND SET

WalkTo(x01,x00,006,000,x00,x00,+008,x01)
WaitWalk(x01,x00)


ROTATE COMMAND SET

RotateUnit(x01,x00,x08,x00,x00,000)
WaitRotateUnit(x01,x00)


ANIMATION

UnitAnim(x01,x00,x0002,x00)


FACEUNIT COMMAND

FaceUnit(x01,x00,x00,x01,x00,x00,x00)


DISPLAY MESSAGE BELOW CHARACTER (CHANGE x12 TO x11 TO BE ABOVE CHARACTER)
(x01 is Unit ID)

DisplayMessage(x10,x12,x0001,x01,x00,x00,+00000,+00000,+00000,x03)
WaitForInstruction(x01,x00)


DISPLAY MESSAGE WITH CHANGE DIALOGUE, USED TO ALLOW YOU DO MAKE A
CHARACTER TURN OR ROTATE WITHOUT CLOSING THE DIALOGUE BOX, OR OTHER
USES.

DisplayMessage(x10,x92,x0001,x01,x00,x00,+00000,+00000,+00000,x03)
WaitForInstruction(x01,x00)

ChangeDialog(x02,x0002,x00,x00)
WaitForInstruction(x01,x00)
ChangeDialog(x02,xFFFF,x00,x00)
WaitForInstruction(x01,x00)


Other commands and or command sets can be requests to be listed here.

We used to have a command called BlackoutBeta, this was thought to just be a way to blacken the screen.
However, this command actually allows you to darken the screen and select a new map, this also resets the
event and allows you to essentially start the event over on another map. You could technically link several
events together in 1 slot this way, but you can still only have 2 music tracks per event.

Before the newest Config.ini the Command would look like this:
BlackoutBeta(x00,x00)

In the newest Config.ini the Command would look like this:
ChangeMap(MAP,x00)

(Click MAP to see a map listing)

After using this command, you need another {4D} Reveal command and a Camera command the way you
would at the start of a normal event.

http://www.youtube.com/watch?v=p64EZiyFQHk
http://www.youtube.com/watch?v=nuy1yEL_Nhk
http://www.youtube.com/watch?v=e5hAK3oq1jk
http://www.youtube.com/watch?v=IfY2k-K9QT4
http://www.youtube.com/watch?v=gzsVopyV8qU
http://www.youtube.com/watch?v=FV4MFYTsSt8
http://www.youtube.com/watch?v=i5M8vgKs0dk
http://www.youtube.com/watch?v=b5Laep3xW6I
http://www.youtube.com/watch?v=lyYWyisGCWk
http://www.youtube.com/watch?v=uwQTzp11m40
http://www.youtube.com/watch?v=V9s1yk6TZ-Q
http://www.youtube.com/watch?v=E_MsgGy5Eq8
http://www.youtube.com/watch?v=tbqy-eps6mE
http://www.youtube.com/watch?v=FIWTnnXCRlE
http://www.youtube.com/watch?v=X4c7ndl2Hoc
http://www.youtube.com/watch?v=t0kQ2cAagvY
http://www.youtube.com/watch?v=zq6l85c5aA8
http://www.youtube.com/watch?v=g4h7N28snP8
http://www.youtube.com/watch?v=XG9RpL9pIOw
http://www.youtube.com/watch?v=-EgFI9GPG1c
http://www.youtube.com/watch?v=RzSZwOMuCNo
http://www.youtube.com/watch?v=ONXc6touBKw
http://www.youtube.com/watch?v=b43Gz0lw7ac
http://www.youtube.com/watch?v=3pSs0KiNvv4


HOW TO EDIT WORLDMAP FLOW
*Written by Raven, Translated to dummy-speak by Elric*

You can find WORLDMAP 1.00 HERE inside of the Game Progression Workbook Compilation
inside of Ravens Workbooks.rar
NOTE: All World Map Commands are HALF-WORDS in LITTLE ENDIAN.

SPOILER LEGEND: COMMAND ID (WHAT YOU'LL FIND IT AFTER)


VARI = Variable ID.  List can be found on the Wiki.
VALU = Value contained in VARI.

0100 VARI VALU //IF VARI EQUAL TO VALU, EXECUTE
0200 VARI VALU //IF VARI GREATER THAN VALU, EXECUTE
0300 VARI VALU //IF VARI LESS THAN VALU, EXECUTE

Runs checks on certain in-game variables to see whether the code can be executed.
Some of the most important commands as they determine when specific events trigger
on locations where more than one thing occurs, which is most of them.


SPID = Sprite ID

0400 SPID // Checks for SPID, EXECUTE.

Checks if a character with the appropriate SPRITE ID is in the player's party to
execute the event. This is how Vanilla checks for things like your party containing
Beowulf, Reis, and/or Mustadio at appropriate times.

While not tested, many of these commands mirror ATTACK.OUT commands, meaning
that there is a chance that 0500 SPID or 0600 SPID would allow you to check if a
specific Sprite ID is NOT in the party, but I can't confirm that.


EVID = Event ID

1900 EVID 0100 //Plays EVID "Aggressively" <-- For Battles
1900 EVID 0200 //Plays EVID "Calmly"         <-- For Events

The following command will play the Event you wish to play on that location if conditions
are met and player walks onto or off it.

"Aggressively" is the battle swirl-intro

"Calmly" is the cutscene-style fade-in

TEX# = Text ID.  Probably editable in FFTacText somewhere.
EVD# = Event ID.

1A00 TEX1 EVD1 TEX2 EVD2 TEX3 EVD3 TEX4 EVD4 //Display choice list

The following command pops up a list of choices for the player to choose which
event to play when stopping on the location. Does not trigger if the player walks past it.
(THINK: North Wall / South Wall of Bethla Garrison or popups for things like
Lionel Castle Gate.)

Four choices is the apparent maximum. If you do not wish to use a choice, its TEX#
and EVD# values should be set to 0000

TXID = Text ID

1D00 TXID //Displays TXID

The following command will play a text display when conditions are met.
Can be edited via FFTacText.

NOTE: 1E00 and 1F00 are related to the Deep Dungeon. I don't know how their work yet, though.
Just that the list is populated with a unique set of commands and has a maximum of 127 entries.


LOC1 = Location to start drawing from.
LOC2 = Location to stop drawing at.

2000 LOC1 LOC2 // Draw path from LOC1 to LOC2

The following command draws paths between specific locations on the map. These locations already
exist in the game beforehand, so attempting to link two previously unlinked locations requires
editing that data, which is not easy to do. However, lines can be drawn from either location without
issue.

Example: Draw from Zaland to Dorter without issue even though Vanilla draws from Dorter to Zaland.

LOC1 = Location to start erasing from.
LOC2 = Location to stop erasing at.

2100 LOC1 LOC2 // Remove path from LOC1 to LOC2

The following command removes already drawn lines from the map.  The structure is the same as
command 2000, as can be expected.

LCID = Location ID.
(Location List is in the Variables list on the Wiki.) (Each location is -200 Ex: Lionel Castle is 0300)

2200 LCID // Draws location

The following command draws a location's dot onto the map. The dot colors can be edited via event variable,
to switch between Red & Blue

LCID = Location ID.
(Location List is in the Variables list on the Wiki.) (Each location is -200 Ex: Lionel Castle is 0300)

2300 LCID // Removes location

The following command removes a location's dot onto the map.
In case Section 1 was not informative enough, I will break down some Worldmap Hex Strings here.


Breaks down into

0100          6E00                    0300          1900               1400          0200          IFStory Progress =03Start EventEVIDCalmly
IF VAR 0x006E (Story Progress) = 0x0003 THEN -> EXECUTE EVENT 0x0014 CALMLY


0100          6E00                    2E00          1A00               4200          4B01                    4300          4E01                    0000          0000          0000          0000          IFStory Progress =2ECall Choices0x0042Execute 0x014B0x0043Execute 0x014C0x00000x00000x00000x0000
IF VAR 0x006E (Story Progress) = 0x002E THEN -> CALL CHOICES 0x0042 AND 0x0043, EXECUTE 0x014B OR 0x014C AS CHOSEN
(Unused Choices are 00000000 00000000 as mentioned above)


0100          1502                    0100          0100          6E00                      1200      2300                      1500               IFBethla Garrison =DrawnIFStory Progress =12Remove Location15 (Bethla Garrison)
IF VAR 0x215 (Bethla Garrison) = 0x0001 (Drawn) THEN -> IF VAR 0x006E (Story Progress) = 0x0012 THEN ->
REMOVE MAP LOCATION 0x0015 (Bethla Garrison)
MORE TO COME!!


HOW TO EDIT WINNING CONDITIONS
*All files and original tutorial by Xifanie, except Bonus Bin Utility and tutorial updates by Choto*

Let's say you are making a story mod, you obviously haven't a need for winning condition like "Save Algus!" However,
until recently this was sort of a pain in the ass to edit for someone not understanding of Hex. Now, thanks to Xifanie's
original tutorial on editing these and a program made by Choto, anyone can simply edit these conditions.
1) Download THIS FILE and extract the included PSD
 - You will also want to have Photoshop and GraphicsGale installed for this tutorial. You also need to be able to use TIMUTIL.EXE
2) Open the PSD and edit in Photoshop. (Xifanie made this very easy to edit, so be sure to thank her)
3) Turn off all colors (block/text edge reference layers)
4) Save it as a BMP file
5) Open the BMP in GraphicsGale
6) Set the color depth to 8bit/256 colors
7) Import the first palette from the 8bit original BMP and black for everything else. Make sure the "Match Pixels with Colors" box is checked.
8) Set the color depth to 4bit/16 colors
9) Import the first palette again, again, make sure the "Match Pixels with Colors" box is checked.
10) Save
11) Open the BMP in TIMUTIL.EXE
12) Convert to a 4bit TIM with translucent all but black & transparent black
13) Start "Bonus Bin Utility.exe", Select your BONUS.BIN file (must be extracted from you ISO), Then select your .TIM file, and hit save.
14) Import BONUS.BIN and enjoy!

Argy:
Brilliant work Elric!  I will try this out on Thursday night! As I always say, keep these great tutes coming!!

Jon:
Excellent video and tutorial step by step. This really helps me a lot! Thank you! :mrgreen:

Elric:
You guys are very welcome, I'm glad that its helpful. If you have any questions or any issues be sure to let me know.  :mrgreen:

Kokojo:
Godamnit you're amazing, Elric.

Navigation

[0] Message Index

[#] Next page

Go to full version